First working multi-layer, anywhere-in-field check

Author: robotgryphon

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

@@ -1,6 +1,5 @@
 package com.robotgryphon.compactcrafting.blocks;
 
-import com.robotgryphon.compactcrafting.CompactCrafting;
 import com.robotgryphon.compactcrafting.core.Registration;
 import com.robotgryphon.compactcrafting.crafting.CraftingHelper;
 import com.robotgryphon.compactcrafting.field.FieldProjection;
@@ -19,20 +18,16 @@
 import net.minecraft.util.Direction;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.vector.Vector3i;
 import net.minecraft.world.server.ServerWorld;
 import net.minecraftforge.fml.RegistryObject;
 
-import java.util.Collection;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;
 import java.util.stream.Collectors;
 
 public class FieldProjectorTile extends TileEntity implements ITickableTileEntity {
 
     private boolean isCrafting = false;
-    private Optional<FieldProjection> field = Optional.empty();
+    private FieldProjection field = null;
     private MiniaturizationRecipe currentRecipe = null;
     private int fieldCheckTimeout = 0;
 
@@ -54,10 +49,9 @@ public void remove() {
      * @return
      */
     public Optional<BlockPos> getOppositeProjector() {
-        if (!field.isPresent())
+        if (field == null)
             return Optional.empty();
 
-        FieldProjection field = this.field.get();
         FieldProjectionSize size = field.getFieldSize();
 
         int offset = (size.getProjectorDistance() * 2) + 1;
@@ -89,9 +83,8 @@ public Optional<BlockPos> getMainProjectorPosition() {
         if (this.isMainProjector())
             return Optional.of(this.pos);
 
-        if (this.field.isPresent()) {
-            FieldProjection fp = this.field.get();
-            BlockPos north = fp.getProjectorInDirection(Direction.NORTH);
+        if (this.field != null) {
+            BlockPos north = field.getProjectorInDirection(Direction.NORTH);
 
             return Optional.of(north);
         }
@@ -103,21 +96,22 @@ public void invalidateField() {
         if(world == null || world.isRemote)
             return;
 
-        if(this.field.isPresent()) {
-            BlockPos center = this.field.get().getCenterPosition();
+        if(field != null) {
+            BlockPos center = this.field.getCenterPosition();
             ProjectionFieldSavedData data = ProjectionFieldSavedData.get((ServerWorld) world);
             data.ACTIVE_FIELDS.remove(center);
             data.markDirty();
 
-            this.field = Optional.empty();
+            this.field = null;
             this.fieldCheckTimeout = 20;
         }
     }
 
     @Override
     public void tick() {
+        // TODO: Do this in the field projector placement method instead
         // If we don't have a valid field, search again
-        if (!field.isPresent()) {
+        if (field == null) {
             if (fieldCheckTimeout > 0) {
                 fieldCheckTimeout--;
                 return;
@@ -127,7 +121,7 @@ public void tick() {
             doFieldCheck();
 
             // If we still don't have a valid field, get out of tick logic
-            if (!field.isPresent())
+            if (field == null)
                 return;
         }
 
@@ -143,19 +137,18 @@ private void doFieldCheck() {
 
         Optional<FieldProjection> field = FieldProjection.tryCreateFromPosition(world, this.pos);
         if (field.isPresent()) {
-            this.field = field;
-            FieldProjection fp = field.get();
+            this.field = field.get();
 
             if(world != null && !world.isRemote) {
                 ProjectionFieldSavedData data = ProjectionFieldSavedData.get((ServerWorld) world);
-                data.ACTIVE_FIELDS.put(fp.getCenterPosition(), ProjectorFieldData.fromInstance(fp));
+                data.ACTIVE_FIELDS.put(this.field.getCenterPosition(), ProjectorFieldData.fromInstance(this.field));
                 data.markDirty();
             }
 
             return;
         }
 
-        this.field = Optional.empty();
+        this.field = null;
 
         // If we didn't find a valid field, restart timer and keep looking
         fieldCheckTimeout = 20;
@@ -165,14 +158,13 @@ private void doFieldCheck() {
      * Scans the field and attempts to match a recipe that's placed in it.
      */
     public void doRecipeScan() {
-        if(!this.field.isPresent())
+        if(this.field == null)
             return;
 
         if(this.world == null)
             return;
 
-        FieldProjection fp = this.field.get();
-        FieldProjectionSize size = fp.getFieldSize();
+        FieldProjectionSize size = field.getFieldSize();
 
         // Only the primary projector needs to worry about the recipe scan
         if(!isMainProjector())
@@ -191,7 +183,13 @@ public void doRecipeScan() {
             return;
         }
 
-        AxisAlignedBB fieldBounds = fp.getBounds();
+        Collection<RegistryObject<MiniaturizationRecipe>> entries = Registration.MINIATURIZATION_RECIPES.getEntries();
+
+        // If there are no registered recipes, then we obv can't match anything - exit early
+        if (entries.isEmpty())
+            return;
+
+        AxisAlignedBB fieldBounds = field.getBounds();
         BlockPos[] nonAirPositions = BlockPos.getAllInBox(fieldBounds)
                 .filter(p -> !world.isAirBlock(p))
                 .map(BlockPos::toImmutable)
@@ -202,37 +200,43 @@ public void doRecipeScan() {
         // ===========================================================================================================
         //   RECIPE BEGIN
         // ===========================================================================================================
-
-        Collection<RegistryObject<MiniaturizationRecipe>> entries = Registration.MINIATURIZATION_RECIPES.getEntries();
-        if (entries.isEmpty())
-            return;
-
-        Set<MiniaturizationRecipe> matchedRecipes = entries
+        Set<MiniaturizationRecipe> recipesBoundFitted = entries
                 .stream()
                 .map(RegistryObject::get)
                 .filter(recipe -> recipe.fitsInFieldSize(size))
                 .filter(recipe -> BlockSpaceUtil.boundsFitsInside(filledBounds, recipe.getDimensions()))
                 .collect(Collectors.toSet());
 
-        BlockPos[] testLocations = new BlockPos[] {
-                new BlockPos(5, 0, 5),
-                new BlockPos(7, 0, 5),
-                new BlockPos(5, 0, 7)
-        };
+        // All the recipes we have registered won't fit in the filled bounds -
+        // blocks were placed in a larger space than the max recipe size
+        if(recipesBoundFitted.size() == 0)
+            return;
+
+//        BlockPos[] testLocations = new BlockPos[] {
+//                new BlockPos(5, 0, 5),
+//                new BlockPos(7, 0, 5),
+//                new BlockPos(5, 0, 7)
+//        };
+//
+//        BlockPos[] rotatedCW = BlockSpaceUtil.rotateLayerPositions(testLocations, new Vector3i(5, 0, 5));
 
-        BlockPos[] rotatedCW = BlockSpaceUtil.rotateLayerPositions(testLocations, new Vector3i(5, 0, 5));
+        // Begin recipe dry run - loop, check bottom layer for matches
+        MiniaturizationRecipe matchedRecipe = null;
+        for(MiniaturizationRecipe recipe : recipesBoundFitted) {
+            boolean recipeMatches = recipe.matches(world, field.getFieldSize(), fieldBounds, filledBounds);
+            if(!recipeMatches)
+                continue;
 
-        CompactCrafting.LOGGER.debug(".");
+            matchedRecipe = recipe;
+            break;
+        }
 
-//        Optional<MiniaturizationRecipe> matched = matchedRecipes.findFirst();
-//
-//        this.currentRecipe = matched.orElse(null);
+        this.currentRecipe = matchedRecipe;
     }
 
     private void tickCrafting() {
-        if (this.field.isPresent()) {
-            FieldProjection fieldProjection = this.field.get();
-            AxisAlignedBB fieldBounds = fieldProjection.getBounds();
+        if (this.field != null) {
+            AxisAlignedBB fieldBounds = field.getBounds();
 
             // Get out, client worlds
             if (world == null || world.isRemote())
@@ -246,11 +250,11 @@ private void tickCrafting() {
                 this.isCrafting = true;
 
                 // We know the "recipe" in the field is an exact match already, so wipe the field
-                fieldProjection.clearBlocks(world);
+                field.clearBlocks(world);
 
                 CraftingHelper.consumeCatalystItem(catalystEntities.get(0), 1);
 
-                BlockPos fieldCenter = field.get().getCenterPosition();
+                BlockPos fieldCenter = field.getCenterPosition();
                 for (ItemStack is : currentRecipe.getOutputs()) {
                     ItemEntity itemEntity = new ItemEntity(world, fieldCenter.getX() + 0.5f, fieldCenter.getY() + 0.5f, fieldCenter.getZ() + 0.5f, is);
                     world.addEntity(itemEntity);
@@ -295,15 +299,14 @@ private int collectItems(List<ItemEntity> itemsInRange) {
     public AxisAlignedBB getRenderBoundingBox() {
         // Check - if we have a valid field use the entire field plus space
         // Otherwise just use the super implementation
-        if (this.field.isPresent()) {
-            FieldProjection fp = this.field.get();
-            return fp.getBounds().grow(10);
+        if (this.field != null) {
+            return field.getBounds().grow(10);
         }
 
         return super.getRenderBoundingBox();
     }
 
     public Optional<FieldProjection> getField() {
-        return this.field;
+        return Optional.ofNullable(this.field);
     }
 }

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

@@ -96,7 +96,8 @@ public class Registration {
         Collections.addAll(template, layerBlocks);
 
         rec.setLayers(new IRecipeLayer[]{
-                new SingleComponentRecipeLayer("O", template)
+                new SingleComponentRecipeLayer("O", template),
+                new SingleComponentRecipeLayer("G", template)
         });
 
         rec.catalyst = Items.ANVIL;
@@ -105,6 +106,7 @@ public class Registration {
         };
 
         rec.addComponent("O", Blocks.OBSIDIAN.getDefaultState());
+        rec.addComponent("G", Blocks.GLOWSTONE.getDefaultState());
 
         return rec;
     });

src/main/java/com/robotgryphon/compactcrafting/crafting/CraftingHelper.java

@@ -2,18 +2,9 @@
 
 import net.minecraft.entity.item.ItemEntity;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.math.AxisAlignedBB;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.IWorldReader;
 
 public abstract class CraftingHelper {
 
-    public static boolean hasBlocksInField(IWorldReader world, AxisAlignedBB area) {
-        // Remove blocks from the world
-        return BlockPos.getAllInBox(area)
-                .anyMatch(p -> !world.isAirBlock(p));
-    }
-
     /**
      * Consumes a number of items from a stack in the world.
      *

src/main/java/com/robotgryphon/compactcrafting/field/FieldHelper.java

@@ -4,21 +4,17 @@
 import com.robotgryphon.compactcrafting.blocks.FieldProjectorTile;
 import com.robotgryphon.compactcrafting.core.BlockUpdateType;
 import com.robotgryphon.compactcrafting.core.Registration;
-import com.robotgryphon.compactcrafting.recipes.MiniaturizationRecipe;
-import com.robotgryphon.compactcrafting.recipes.RecipeHelper;
 import com.robotgryphon.compactcrafting.world.ProjectionFieldSavedData;
 import com.robotgryphon.compactcrafting.world.ProjectorFieldData;
-import net.minecraft.block.BlockState;
-import net.minecraft.fluid.FluidState;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IWorld;
-import net.minecraft.world.IWorldReader;
 import net.minecraft.world.TickPriority;
 import net.minecraft.world.server.ServerWorld;
 
-import java.util.*;
-import java.util.stream.Stream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
 
 /**
  * Provides utilities to help with projector field management.
@@ -36,7 +32,6 @@ public static void checkBlockPlacement(IWorld world, BlockPos pos, BlockUpdateTy
         List<BlockPos> projectors = new ArrayList<>();
         int maxDimensions = FieldProjectionSize.maximum().getDimensions();
         for(BlockPos center : data.ACTIVE_FIELDS.keySet()) {
-            // FieldProjectorTile mainTile = (FieldProjectorTile) world.getTileEntity(fielf)
             boolean closeEnough = center.withinDistance(pos, maxDimensions);
             if(closeEnough) {
                 ProjectorFieldData field = data.ACTIVE_FIELDS.get(center);
@@ -75,55 +70,5 @@ public static void checkBlockPlacement(IWorld world, BlockPos pos, BlockUpdateTy
         }
     }
 
-    public static Stream<AxisAlignedBB> splitIntoLayers(FieldProjectionSize size, AxisAlignedBB full) {
-
-        int s = size.getSize();
-        BlockPos bottomCenter = new BlockPos(full.getCenter()).down(s);
-        AxisAlignedBB bottomLayerBounds = new AxisAlignedBB(bottomCenter).grow(s, 0, s);
-
-        AxisAlignedBB[] layers = new AxisAlignedBB[size.getDimensions()];
-        for(int layer = 0; layer < size.getDimensions(); layer++) {
-            AxisAlignedBB layerBounds = bottomLayerBounds.offset(0, layer, 0);
-            layers[layer] = layerBounds;
-        }
-
-        return Stream.of(layers);
-    }
-
-    /**
-     * Converts a layer of a field into its relative recipe component definition.
-     *
-     * @param world
-     * @param recipe
-     * @param fieldSize
-     * @param layer
-     * @return
-     */
-    public static Map<BlockPos, String> remapLayerToRecipe(IWorldReader world, MiniaturizationRecipe recipe, FieldProjectionSize fieldSize, AxisAlignedBB layer) {
-        Map<BlockPos, String> relativeMap = new HashMap<>();
-
-        BlockPos[] filled = BlockPos.getAllInBox(layer)
-                .filter(pos -> !world.isAirBlock(pos))
-                .map(BlockPos::toImmutable)
-                .toArray(BlockPos[]::new);
-
-        for(BlockPos pos : filled) {
-            BlockState state = world.getBlockState(pos);
-            FluidState fluid = world.getFluidState(pos);
-
-            // TODO: Fluid crafting! :D
-
-            Optional<String> recipeComponentKey = recipe.getRecipeComponentKey(state);
-            if(recipeComponentKey.isPresent())
-            {
-                // Get relative position in layer and add to map
-                BlockPos normalized = RecipeHelper.normalizeLayerPosition(layer, pos);
-                relativeMap.put(normalized, recipeComponentKey.get());
-            }
-        }
-
-        return relativeMap;
-    }
-
 
 }