Recipe rotation checking works; state matching does not

Author: robotgryphon

src/main/java/com/robotgryphon/compactcrafting/blocks/FieldProjectorTile.java

@@ -7,7 +7,6 @@
 import com.robotgryphon.compactcrafting.field.MiniaturizationFieldBlockData;
 import com.robotgryphon.compactcrafting.field.ProjectorHelper;
 import com.robotgryphon.compactcrafting.recipes.MiniaturizationRecipe;
-import com.robotgryphon.compactcrafting.util.BlockSpaceUtil;
 import com.robotgryphon.compactcrafting.world.ProjectionFieldSavedData;
 import com.robotgryphon.compactcrafting.world.ProjectorFieldData;
 import net.minecraft.block.BlockState;
@@ -22,7 +21,10 @@
 import net.minecraft.world.server.ServerWorld;
 import net.minecraftforge.fml.RegistryObject;
 
-import java.util.*;
+import java.util.Collection;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 public class FieldProjectorTile extends TileEntity implements ITickableTileEntity {
@@ -208,8 +210,7 @@ public void doRecipeScan() {
         Set<MiniaturizationRecipe> recipesBoundFitted = entries
                 .stream()
                 .map(RegistryObject::get)
-                .filter(recipe -> recipe.fitsInFieldSize(size))
-                .filter(recipe -> BlockSpaceUtil.boundsFitsInside(recipe.getDimensions(), fieldBlocks.getFilledBounds()))
+                .filter(recipe -> recipe.fitsInDimensions(fieldBlocks.getFilledBounds()))
                 .collect(Collectors.toSet());
 
         // All the recipes we have registered won't fit in the filled bounds -

src/main/java/com/robotgryphon/compactcrafting/core/Registration.java

@@ -85,28 +85,39 @@ public class Registration {
 
         Set<BlockPos> template = new HashSet<>();
 
-        // cross pattern, see docs
-        BlockPos[] layerBlocks = new BlockPos[]{
-                new BlockPos(1, 0, 0),
-                new BlockPos(0, 0, 1),
+        BlockPos[] complexPattern = new BlockPos[] {
+                // Glass
+                new BlockPos(3, 0, 0),
+                new BlockPos(4, 0, 0),
                 new BlockPos(2, 0, 1),
-                new BlockPos(1, 0, 2)
+                new BlockPos(5, 0, 1),
+                new BlockPos(2, 0, 2),
+                new BlockPos(5, 0, 2),
+                new BlockPos(3, 0, 3),
+                new BlockPos(4, 0, 3),
+
+                // Tail
+                new BlockPos(2, 0, 3),
+                new BlockPos(1, 0, 4),
+                new BlockPos(0, 0, 5)
         };
 
-        Collections.addAll(template, layerBlocks);
+        Collections.addAll(template, complexPattern);
 
         rec.setLayers(new IRecipeLayer[]{
-                new SingleComponentRecipeLayer("O", template),
-                new SingleComponentRecipeLayer("G", template)
+                new SingleComponentRecipeLayer("S", template)
+                // new SingleComponentRecipeLayer("O", template),
+                // new SingleComponentRecipeLayer("G", template)
         });
 
-        rec.catalyst = Items.ANVIL;
+        rec.catalyst = Items.GLASS;
         rec.outputs = new ItemStack[]{
-                new ItemStack(Items.CRYING_OBSIDIAN, 1)
+                new ItemStack(Items.BELL, 1)
         };
 
-        rec.addComponent("O", Blocks.OBSIDIAN.getDefaultState());
-        rec.addComponent("G", Blocks.GLOWSTONE.getDefaultState());
+        rec.addComponent("S", Blocks.STONE.getDefaultState());
+        // rec.addComponent("O", Blocks.OBSIDIAN.getDefaultState());
+        // rec.addComponent("G", Blocks.GLOWSTONE.getDefaultState());
 
         return rec;
     });

src/main/java/com/robotgryphon/compactcrafting/recipes/MiniaturizationRecipe.java

@@ -8,6 +8,7 @@
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Direction;
+import net.minecraft.util.Rotation;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.vector.Vector3d;
@@ -84,27 +85,39 @@ public boolean fitsInFieldSize(FieldProjectionSize fieldSize) {
         return fits;
     }
 
-    private boolean hasMatchingBottomLayer(IWorldReader world, FieldProjectionSize fieldSize, AxisAlignedBB field) {
-        if (!fitsInFieldSize(fieldSize))
-            return false;
-
-        return true;
-    }
-
     public boolean matches(IWorldReader world, FieldProjectionSize fieldSize, MiniaturizationFieldBlockData fieldBlocks) {
         if (!fitsInFieldSize(fieldSize))
             return false;
 
         // We know that the recipe will at least fit inside the current projection field
         AxisAlignedBB filledBounds = fieldBlocks.getFilledBounds();
 
-        // Check rest of the recipe layers
+        Rotation[] validRotations = new Rotation[] {
+                Rotation.NONE,
+                Rotation.CLOCKWISE_90,
+                Rotation.CLOCKWISE_180,
+                Rotation.COUNTERCLOCKWISE_90
+        };
+
+        for(Rotation rot : validRotations) {
+            boolean matchesRot = checkRotation(world, rot, filledBounds);
+            if(matchesRot)
+               return true;
+        }
+
+        return false;
+    }
+
+    private boolean checkRotation(IWorldReader world, Rotation rot, AxisAlignedBB filledBounds) {
+        // Check the recipe layer by layer
+
         int maxY = (int) dimensions.getYSize();
-        for(int offset = 0; offset < maxY; offset++) {
+        for (int offset = 0; offset < maxY; offset++) {
             BlockPos[] layerFilled = BlockSpaceUtil.getFilledBlocksByLayer(world, filledBounds, offset);
+            BlockPos[] layerRotated = BlockSpaceUtil.rotatePositionsInPlace(layerFilled, rot);
 
-            boolean layerMatches = doLayerBlocksMatch(world, filledBounds, layerFilled);
-            if(!layerMatches)
+            boolean layerMatches = doLayerBlocksMatch(world, rot, filledBounds, layerRotated);
+            if (!layerMatches)
                 return false;
         }
 
@@ -149,68 +162,77 @@ public AxisAlignedBB getDimensions() {
      * @param filledPositions The filled positions on the layer to check.
      * @return
      */
-    public boolean doLayerBlocksMatch(IWorldReader world, AxisAlignedBB fieldFilledBounds, BlockPos[] filledPositions) {
+    public boolean doLayerBlocksMatch(IWorldReader world, Rotation rot, AxisAlignedBB fieldFilledBounds, BlockPos[] filledPositions) {
         // Recipe layers using this method must define at least one filled space
         if(filledPositions.length == 0)
             return false;
 
-        int filledYLevel = filledPositions[0].getY();
-        int minFilledLevel = (int) Math.floor(fieldFilledBounds.minY);
-        int yLevelRelative = filledYLevel - minFilledLevel;
-
-        Optional<IRecipeLayer> layer = this.getLayer(yLevelRelative);
-
-        // No such layer exists
-        if(!layer.isPresent())
+        Optional<IRecipeLayer> layer = getRecipeLayerFromPositions(fieldFilledBounds, filledPositions);
+        if (!layer.isPresent())
             return false;
 
         IRecipeLayer l = layer.get();
 
         int totalFilled = filledPositions.length;
         int requiredFilled = l.getNumberFilledPositions();
 
+        // Early exit if we don't have the correct number of blocks in the layer
         if(totalFilled != requiredFilled)
             return false;
 
-        BlockPos[] fieldNormalizedPositions = BlockSpaceUtil.normalizeLayerPositions(fieldFilledBounds, filledPositions);
-        int extraYOffset = fieldNormalizedPositions[0].getY();
+        BlockPos[] fieldNormalizedPositionsFieldOffset = BlockSpaceUtil.normalizeLayerPositions(fieldFilledBounds, filledPositions);
 
-        for(BlockPos fieldFilledPosition : fieldNormalizedPositions) {
-            BlockPos realPos = BlockSpaceUtil.denormalizeLayerPosition(fieldFilledBounds, fieldFilledPosition);
-            BlockState state = world.getBlockState(realPos);
+        // TODO: Make recipe loading respect multiple layers as Y=0, 1, etc
+        int extraYOffset = fieldNormalizedPositionsFieldOffset[0].getY();
 
-            // If we require a block at a position and it's air...
-            BlockPos zeroedRecipePosition = fieldFilledPosition.offset(Direction.DOWN, extraYOffset);
-            if(!l.isPositionRequired(zeroedRecipePosition)) {
-                CompactCrafting.LOGGER.debug("Position filled but the recipe does not require a block there; recipe not matched.");
-                return false;
-            }
+        // We'll need an extra offset layer to match against the recipe layer's Y=0
+        BlockPos[] fieldNormalizedPositionsLayerOffset = Stream.of(fieldNormalizedPositionsFieldOffset)
+                .parallel()
+                .map(p -> p.offset(Direction.DOWN, extraYOffset))
+                .map(BlockPos::toImmutable)
+                .toArray(BlockPos[]::new);
 
-            // Position is required but the block there is air?
-            // This shouldn't happen, the air check should have happened before this
-            if(state.isAir(world, realPos))
-                return false;
+        for(BlockPos normalizedFieldPosition : fieldNormalizedPositionsLayerOffset) {
 
-            String requiredCompKey = l.getRequiredComponentKeyForPosition(zeroedRecipePosition);
-            Optional<String> realComponentInPosition = this.getRecipeComponentKey(state);
+            // 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;
             }
 
-            // 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;
+//            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;
     }
 
+    private Optional<IRecipeLayer> getRecipeLayerFromPositions(AxisAlignedBB fieldFilledBounds, BlockPos[] filledPositions) {
+        if(filledPositions.length == 0)
+            return Optional.empty();
+
+        int filledYLevel = filledPositions[0].getY();
+        int minFilledLevel = (int) Math.floor(fieldFilledBounds.minY);
+        int yLevelRelative = filledYLevel - minFilledLevel;
+
+        return this.getLayer(yLevelRelative);
+    }
+
     public Optional<IRecipeLayer> getLayer(int y) {
         if(y < 0 || y > this.layers.length - 1)
             return Optional.empty();

src/main/java/com/robotgryphon/compactcrafting/util/BlockSpaceUtil.java

@@ -1,6 +1,5 @@
 package com.robotgryphon.compactcrafting.util;
 
-import com.robotgryphon.compactcrafting.field.MiniaturizationFieldBlockData;
 import net.minecraft.util.Rotation;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
@@ -38,6 +37,20 @@ public static 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) {
         AxisAlignedBB bounds = getBoundsForBlocks(positions);