All rotations now check state

robotgryphon · robotgryphon · commit fcbfd1fee4e9 · 2020-10-09T03:39:18.000-04:00
diff --git a/src/main/java/com/robotgryphon/compactcrafting/recipes/MiniaturizationRecipe.java b/src/main/java/com/robotgryphon/compactcrafting/recipes/MiniaturizationRecipe.java
@@ -1,6 +1,5 @@
 package com.robotgryphon.compactcrafting.recipes;
 
-import com.robotgryphon.compactcrafting.CompactCrafting;
 import com.robotgryphon.compactcrafting.field.FieldProjectionSize;
 import com.robotgryphon.compactcrafting.field.MiniaturizationFieldBlockData;
 import com.robotgryphon.compactcrafting.util.BlockSpaceUtil;
@@ -15,6 +14,7 @@
 import net.minecraft.world.IWorldReader;
 import net.minecraftforge.registries.ForgeRegistryEntry;
 
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
@@ -51,12 +51,12 @@ private void recalculateDimensions() {
         int x = 0;
         int z = 0;
 
-        for(IRecipeLayer layer : this.layers) {
+        for (IRecipeLayer layer : this.layers) {
             AxisAlignedBB dimensions = layer.getDimensions();
-            if(dimensions.getXSize() > x)
+            if (dimensions.getXSize() > x)
                 x = (int) Math.ceil(dimensions.getXSize());
 
-            if(dimensions.getZSize() > z)
+            if (dimensions.getZSize() > z)
                 z = (int) Math.ceil(dimensions.getZSize());
         }
 
@@ -92,17 +92,17 @@ public boolean matches(IWorldReader world, FieldProjectionSize fieldSize, Miniat
         // We know that the recipe will at least fit inside the current projection field
         AxisAlignedBB filledBounds = fieldBlocks.getFilledBounds();
 
-        Rotation[] validRotations = new Rotation[] {
+        Rotation[] validRotations = new Rotation[]{
                 Rotation.NONE,
                 Rotation.CLOCKWISE_90,
                 Rotation.CLOCKWISE_180,
                 Rotation.COUNTERCLOCKWISE_90
         };
 
-        for(Rotation rot : validRotations) {
+        for (Rotation rot : validRotations) {
             boolean matchesRot = checkRotation(world, rot, filledBounds);
-            if(matchesRot)
-               return true;
+            if (matchesRot)
+                return true;
         }
 
         return false;
@@ -113,12 +113,45 @@ private boolean checkRotation(IWorldReader world, Rotation rot, AxisAlignedBB fi
 
         int maxY = (int) dimensions.getYSize();
         for (int offset = 0; offset < maxY; offset++) {
+            Optional<IRecipeLayer> layer = getLayer(offset);
+
             BlockPos[] layerFilled = BlockSpaceUtil.getFilledBlocksByLayer(world, filledBounds, offset);
-            BlockPos[] layerRotated = BlockSpaceUtil.rotatePositionsInPlace(layerFilled, rot);
 
-            boolean layerMatches = doLayerBlocksMatch(world, rot, filledBounds, layerRotated);
+            // If we have no layer definition do lighter processing
+            // TODO: Consider changing the layers to a map so we can make air layers null/nonexistent
+            if(!layer.isPresent() && layerFilled.length > 0) {
+                // We're being safe here - if there's no layer definition we assume the layer is all-air
+                return false;
+            }
+
+            Map<BlockPos, BlockPos> layerRotated = BlockSpaceUtil.rotatePositionsInPlace(layerFilled, rot);
+
+            // Check that the rotated positions are correct
+            boolean layerMatches = areLayerPositionsCorrect(filledBounds, layerRotated.values().toArray(new BlockPos[0]));
             if (!layerMatches)
                 return false;
+
+            // Check the states are correct
+            for(BlockPos unrotatedPos : layerFilled) {
+                BlockPos rotatedPos = layerRotated.get(unrotatedPos);
+                BlockPos normalizedRotatedPos = BlockSpaceUtil.normalizeLayerPosition(filledBounds, rotatedPos);
+
+                BlockState actualState = world.getBlockState(unrotatedPos);
+
+                IRecipeLayer l = layer.get();
+                String requiredComponentKeyForPosition = l.getRequiredComponentKeyForPosition(normalizedRotatedPos);
+                Optional<String> recipeComponentKey = this.getRecipeComponentKey(actualState);
+
+                if(!recipeComponentKey.isPresent()) {
+                    // At this point we don't have a lookup for the state that's at the position
+                    // No match can be made here
+                    return false;
+                }
+
+                boolean statesEqual = recipeComponentKey.get().equals(requiredComponentKeyForPosition);
+                if(!statesEqual)
+                    return false;
+            }
         }
 
         return true;
@@ -138,8 +171,8 @@ public Optional<BlockState> getRecipeComponent(String i) {
     }
 
     public Optional<String> getRecipeComponentKey(BlockState state) {
-        for(String comp : this.components.keySet()) {
-            if(components.get(comp) == state)
+        for (String comp : this.components.keySet()) {
+            if (components.get(comp) == state)
                 return Optional.of(comp);
         }
 
@@ -155,16 +188,15 @@ public AxisAlignedBB getDimensions() {
     }
 
     /**
-     * Checks if a given recipe layer matches the filled blocks provided.
+     * Checks if a given recipe layer matches all the positions for a rotation.
      *
-     * @param world
      * @param fieldFilledBounds The boundaries of all filled blocks in the field.
-     * @param filledPositions The filled positions on the layer to check.
+     * @param filledPositions   The filled positions on the layer to check.
      * @return
      */
-    public boolean doLayerBlocksMatch(IWorldReader world, Rotation rot, AxisAlignedBB fieldFilledBounds, BlockPos[] filledPositions) {
+    public boolean areLayerPositionsCorrect(AxisAlignedBB fieldFilledBounds, BlockPos[] filledPositions) {
         // Recipe layers using this method must define at least one filled space
-        if(filledPositions.length == 0)
+        if (filledPositions.length == 0)
             return false;
 
         Optional<IRecipeLayer> layer = getRecipeLayerFromPositions(fieldFilledBounds, filledPositions);
@@ -177,7 +209,7 @@ public boolean doLayerBlocksMatch(IWorldReader world, Rotation rot, AxisAlignedB
         int requiredFilled = l.getNumberFilledPositions();
 
         // Early exit if we don't have the correct number of blocks in the layer
-        if(totalFilled != requiredFilled)
+        if (totalFilled != requiredFilled)
             return false;
 
         BlockPos[] fieldNormalizedPositionsFieldOffset = BlockSpaceUtil.normalizeLayerPositions(fieldFilledBounds, filledPositions);
@@ -192,38 +224,13 @@ public boolean doLayerBlocksMatch(IWorldReader world, Rotation rot, AxisAlignedB
                 .map(BlockPos::toImmutable)
                 .toArray(BlockPos[]::new);
 
-        for(BlockPos normalizedFieldPosition : fieldNormalizedPositionsLayerOffset) {
-
-            // normalizedFieldPosition is the normalized position in the ROTATED layout
-            boolean required = l.isPositionRequired(normalizedFieldPosition);
-            if(!required) {
-                // is block set? - if so, exit as a failure
-            }
-
-            String requiredCompKey = l.getRequiredComponentKeyForPosition(normalizedFieldPosition);
-            if(requiredCompKey == null) {
-                CompactCrafting.LOGGER.error("Relative position marked as required but the recipe layer did not have a lookup.");
-                return false;
-            }
-
-//            Optional<String> realComponentInPosition = this.getRecipeComponentKey(state);
-//
-//
-//
-//            // No lookup defined in the recipe for the state in the position
-//            if(!realComponentInPosition.isPresent())
-//                return false;
-//
-//            // Does component match in position?
-//            if(!realComponentInPosition.get().equals(requiredCompKey))
-//                return false;
-        }
-
-        return true;
+        return Arrays.stream(fieldNormalizedPositionsLayerOffset)
+                .parallel()
+                .allMatch(l::isPositionRequired);
     }
 
     private Optional<IRecipeLayer> getRecipeLayerFromPositions(AxisAlignedBB fieldFilledBounds, BlockPos[] filledPositions) {
-        if(filledPositions.length == 0)
+        if (filledPositions.length == 0)
             return Optional.empty();
 
         int filledYLevel = filledPositions[0].getY();
@@ -234,7 +241,7 @@ private Optional<IRecipeLayer> getRecipeLayerFromPositions(AxisAlignedBB fieldFi
     }
 
     public Optional<IRecipeLayer> getLayer(int y) {
-        if(y < 0 || y > this.layers.length - 1)
+        if (y < 0 || y > this.layers.length - 1)
             return Optional.empty();
 
         return Optional.of(this.layers[y]);
diff --git a/src/main/java/com/robotgryphon/compactcrafting/util/BlockSpaceUtil.java b/src/main/java/com/robotgryphon/compactcrafting/util/BlockSpaceUtil.java
@@ -9,6 +9,9 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public abstract class BlockSpaceUtil {
@@ -33,45 +36,32 @@ public static AxisAlignedBB getLayerBoundsByYOffset(AxisAlignedBB fullBounds, in
         );
     }
 
-    public static BlockPos[] rotatePositionsInPlace(BlockPos[] positions) {
+    public static Map<BlockPos, BlockPos> rotatePositionsInPlace(BlockPos[] positions) {
         return rotatePositionsInPlace(positions, Rotation.CLOCKWISE_90);
     }
 
-    public static BlockPos rotatePositionInPlace(AxisAlignedBB bounds, BlockPos rotated, Rotation rotation) {
-        Rotation rotBack = rotation.add(Rotation.CLOCKWISE_180);
-
-        BlockPos normalized = normalizeLayerPosition(bounds, rotated);
-        BlockPos rotatedBack = normalized.rotate(rotBack);
-        BlockPos denormalized = denormalizeLayerPosition(bounds, rotatedBack);
-
-        AxisAlignedBB boundsRotated = new AxisAlignedBB(denormalized, denormalized);
-        BlockPos reNormalized = normalizeLayerPosition(boundsRotated, denormalized);
-
-        return denormalizeLayerPosition(bounds, reNormalized);
-
-    }
-
-    public static BlockPos[] rotatePositionsInPlace(BlockPos[] positions, Rotation rot) {
+    public static Map<BlockPos, BlockPos> rotatePositionsInPlace(BlockPos[] positions, Rotation rot) {
         AxisAlignedBB bounds = getBoundsForBlocks(positions);
 
         // Rotation around a normalized world offset (smallest position is 0,0)
-        BlockPos[] rotatedPreNormalize = Stream.of(positions)
-                .map(p -> normalizeLayerPosition(bounds, p))
-                .map(p -> p.rotate(rot))
-                .map(p -> denormalizeLayerPosition(bounds, p))
-                .map(BlockPos::toImmutable)
-                .toArray(BlockPos[]::new);
+        Map<BlockPos, BlockPos> rotatedPreNormalize = Stream.of(positions)
+                .map(p -> new BlockPos[] { p, normalizeLayerPosition(bounds, p) })
+                .map(p -> new BlockPos[] { p[0], p[1].rotate(rot) })
+                .map(p -> new BlockPos[] { p[0], denormalizeLayerPosition(bounds, p[1]) })
+                .map(p -> new BlockPos[] { p[0], p[1].toImmutable() })
+                .collect(Collectors.toMap(p -> p[0], p -> p[1]));
 
-        AxisAlignedBB rotatedBounds = BlockSpaceUtil.getBoundsForBlocks(rotatedPreNormalize);
+        AxisAlignedBB rotatedBounds = BlockSpaceUtil.getBoundsForBlocks(rotatedPreNormalize.values());
 
         // Re-Normalize the positions to fix the offsetting that rotation does (we're rotating in place)
-        BlockPos[] reNormalized = normalizeLayerPositions(rotatedBounds, rotatedPreNormalize);
-
-        // Rotated positions were normalized before to fix the offsetting that rotation does - denormalize again
-        return Stream.of(reNormalized)
-                .map(p -> denormalizeLayerPosition(bounds, p))
-                .map(BlockPos::toImmutable)
-                .toArray(BlockPos[]::new);
+        Map<BlockPos, BlockPos> realPositions = new HashMap<>();
+        rotatedPreNormalize.forEach((k, rp) -> {
+            BlockPos reNormalized = normalizeLayerPosition(rotatedBounds, rp);
+            BlockPos realPosition = denormalizeLayerPosition(bounds, reNormalized);
+            realPositions.put(k.toImmutable(), realPosition.toImmutable());
+        });
+
+        return realPositions;
     }
 
     public static boolean boundsFitsInside(AxisAlignedBB check, AxisAlignedBB space) {
diff --git a/src/test/java/com/robotgryphon/compactcrafting/RotationsTest.java b/src/test/java/com/robotgryphon/compactcrafting/RotationsTest.java
@@ -9,6 +9,7 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Stream;
 
 public class RotationsTest {
@@ -19,9 +20,9 @@ void SingleBlockRotatesCorrectly() {
                 new BlockPos(1, 0, 0)
         };
 
-        BlockPos[] newLocations = BlockSpaceUtil.rotatePositionsInPlace(singleBlock);
+        Map<BlockPos, BlockPos> newLocations = BlockSpaceUtil.rotatePositionsInPlace(singleBlock);
 
-        BlockPos rotatedPos = newLocations[0];
+        BlockPos rotatedPos = newLocations.get(singleBlock[0]);
 
         Assertions.assertEquals(new BlockPos(0, 0, 1), rotatedPos);
     }
@@ -82,10 +83,10 @@ void ComplexShapeRotatesInPlaceCorrectly() {
                 new BlockPos(2, 0, 2)
         };
 
-        BlockPos[] rotatedPattern = BlockSpaceUtil.rotatePositionsInPlace(complexPattern, Rotation.CLOCKWISE_90);
+        Map<BlockPos, BlockPos> rotatedPattern = BlockSpaceUtil.rotatePositionsInPlace(complexPattern, Rotation.CLOCKWISE_90);
 
         List<BlockPos> expected = Arrays.asList(relativeWestPositions);
-        List<BlockPos> actual = Arrays.asList(rotatedPattern);
+        List<BlockPos> actual = Arrays.asList(rotatedPattern.values().toArray(new BlockPos[0]));
 
         Assertions.assertTrue(actual.containsAll(expected));
     }
@@ -153,10 +154,10 @@ void ComplexShapeRotates180Correctly () {
                 new BlockPos(5, 0, 0)
         };
 
-        BlockPos[] rotatedPattern = BlockSpaceUtil.rotatePositionsInPlace(complexPattern, Rotation.CLOCKWISE_180);
+        Map<BlockPos, BlockPos> rotatedPattern = BlockSpaceUtil.rotatePositionsInPlace(complexPattern, Rotation.CLOCKWISE_180);
 
         List<BlockPos> expected = Arrays.asList(relativeWestPositions);
-        List<BlockPos> actual = Arrays.asList(rotatedPattern);
+        List<BlockPos> actual = Arrays.asList(rotatedPattern.values().toArray(new BlockPos[0]));
 
         Assertions.assertTrue(actual.containsAll(expected));
     }
