Update block break handling to schedule an update on FP tile

Author: robotgryphon

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

@@ -25,6 +25,7 @@
 
 import javax.annotation.Nullable;
 import java.util.Optional;
+import java.util.Random;
 
 //import mcjty.theoneprobe.api.IProbeHitData;
 //import mcjty.theoneprobe.api.IProbeInfo;
@@ -53,6 +54,16 @@ public static Optional<Direction> getDirection(IWorldReader world, BlockPos posi
         return Optional.of(facing);
     }
 
+    @Override
+    public void tick(BlockState state, ServerWorld worldIn, BlockPos pos, Random rand) {
+        FieldProjectorTile tile = (FieldProjectorTile) worldIn.getTileEntity(pos);
+        if(tile == null)
+            return;
+
+        tile.doRecipeScan();
+    }
+
+
     @Override
     public VoxelShape getRenderShape(BlockState state, IBlockReader worldIn, BlockPos pos) {
         return VoxelShapes.empty();

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

@@ -1,6 +1,5 @@
 package com.robotgryphon.compactcrafting.blocks;
 
-import com.robotgryphon.compactcrafting.core.BlockUpdateType;
 import com.robotgryphon.compactcrafting.core.Registration;
 import com.robotgryphon.compactcrafting.crafting.CraftingHelper;
 import com.robotgryphon.compactcrafting.field.FieldProjection;
@@ -162,7 +161,7 @@ private void doFieldCheck() {
     /**
      * Scans the field and attempts to match a recipe that's placed in it.
      */
-    private void doRecipeScan() {
+    public void doRecipeScan() {
         if(!this.field.isPresent())
             return;
 
@@ -276,27 +275,4 @@ public AxisAlignedBB getRenderBoundingBox() {
     public Optional<FieldProjection> getField() {
         return this.field;
     }
-
-    /**
-     * Called whenever a nearby block is changed near the field.
-     *
-     * @param pos The position a block was updated at.
-     */
-    public void handleNearbyBlockUpdate(BlockPos pos, BlockUpdateType updateType) {
-        if (updateType == BlockUpdateType.UNKNOWN)
-            return;
-
-        // Is there a current projection field that's active?
-        if(this.field.isPresent()) {
-            AxisAlignedBB fieldBounds = this.field.get().getBounds();
-
-            // Is the block update INSIDE the current field?
-            boolean blockInField = fieldBounds
-                    .contains(pos.getX() + 0.5f, pos.getY() + 0.5f, pos.getZ() + 0.5f);
-
-            // Recipe update
-            if(blockInField)
-                doRecipeScan();
-        }
-    }
 }

src/main/java/com/robotgryphon/compactcrafting/events/EventHandler.java

@@ -14,7 +14,7 @@
 public class EventHandler {
 
     @SubscribeEvent
-    public static void onBlockDestroyed(final BlockEvent.EntityPlaceEvent blockPlaced) {
+    public static void onBlockPlaced(final BlockEvent.EntityPlaceEvent blockPlaced) {
         // Check if block is in or around a projector field
 
         IWorld world = blockPlaced.getWorld();

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

@@ -3,15 +3,21 @@
 import com.robotgryphon.compactcrafting.CompactCrafting;
 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.ArrayList;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Stream;
 
 /**
@@ -49,7 +55,23 @@ public static void checkBlockPlacement(IWorld world, BlockPos pos, BlockUpdateTy
                 continue;
             }
 
-            tile.handleNearbyBlockUpdate(pos, type);
+            Optional<FieldProjection> field = tile.getField();
+
+            if(field.isPresent()) {
+                AxisAlignedBB fieldBounds = field.get().getBounds();
+
+                // Is the block update INSIDE the current field?
+                boolean blockInField = fieldBounds
+                        .contains(pos.getX() + 0.5f, pos.getY() + 0.5f, pos.getZ() + 0.5f);
+
+                if(!blockInField)
+                    continue;;
+
+                // Schedule an update tick for half a second out, handles blocks breaking better
+                world
+                    .getPendingBlockTicks()
+                    .scheduleTick(p, Registration.FIELD_PROJECTOR_BLOCK.get(), 10, TickPriority.NORMAL);
+            }
         }
     }
 
@@ -67,4 +89,39 @@ public static Stream<AxisAlignedBB> splitIntoLayers(FieldProjectionSize size, Ax
 
         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;
+    }
+}

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

@@ -1,5 +1,6 @@
 package com.robotgryphon.compactcrafting.recipes;
 
+import com.robotgryphon.compactcrafting.field.FieldProjectionSize;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IWorldReader;
@@ -26,10 +27,11 @@ public interface IRecipeLayer {
      *
      * @param world
      * @param recipe
+     * @param fieldSize
      * @param fieldLayer
      * @return
      */
-    boolean matchesFieldLayer(IWorldReader world, MiniaturizationRecipe recipe, AxisAlignedBB fieldLayer);
+    boolean matchesFieldLayer(IWorldReader world, MiniaturizationRecipe recipe, FieldProjectionSize fieldSize, AxisAlignedBB fieldLayer);
 
     /**
      * Gets the trimmed dimensions of the given recipe layer.

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

@@ -90,7 +90,7 @@ public boolean matches(IWorldReader world, FieldProjectionSize fieldSize, AxisAl
 
         // Check each layer bottom to see if it matches the bottom layer of this recipe
         return possibleRecipeBottomLayers.stream()
-                .anyMatch(fieldLayer -> layers[0].matchesFieldLayer(world, this, fieldLayer));
+                .anyMatch(fieldLayer -> layers[0].matchesFieldLayer(world, this, fieldSize, fieldLayer));
     }
 
     public ItemStack[] getOutputs() {

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

@@ -7,7 +7,10 @@
 import net.minecraft.util.math.vector.Vector3i;
 import net.minecraft.world.IWorldReader;
 
-import java.util.*;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Optional;
+import java.util.Set;
 import java.util.stream.Stream;
 
 public abstract class RecipeHelper {
@@ -19,6 +22,13 @@ public static BlockState getBlockStateForNormalizedLocation(IWorldReader world,
         return world.getBlockState(offsetPos);
     }
 
+    public static BlockPos normalizeLayerPosition(AxisAlignedBB layerBounds, BlockPos pos) {
+        return new BlockPos(
+                pos.getX() - layerBounds.minX,
+                pos.getY() - layerBounds.minY,
+                pos.getZ() - layerBounds.minZ
+        );
+    }
     /**
      * Converts world-coordinate positions into relative field positions.
      *
@@ -30,11 +40,7 @@ public static BlockPos[] normalizeLayerPositions(AxisAlignedBB layerBounds, Bloc
         // Normalize the block positions so the recipe can match easier
         return Stream.of(fieldPositions)
                 .parallel()
-                .map(p -> new BlockPos(
-                        p.getX() - layerBounds.minX,
-                        p.getY() - layerBounds.minY,
-                        p.getZ() - layerBounds.minZ
-                ))
+                .map(p -> normalizeLayerPosition(layerBounds, p))
                 .map(BlockPos::toImmutable)
                 .toArray(BlockPos[]::new);
     }
@@ -75,6 +81,7 @@ public static String[][] getTrimmedTemplateForLayer(IRecipeLayer layer, AxisAlig
 
         return components;
     }
+
     /**
      * Checks if a layer matches a template by extracting information about components
      * from the various filled positions.
@@ -88,15 +95,13 @@ public static boolean layerMatchesTemplate(IWorldReader world, MiniaturizationRe
         AxisAlignedBB trimmedBounds = getBoundsForBlocks(Arrays.asList(filledLocations));
         BlockPos[] normalizedLocations = normalizeLayerPositions(trimmedBounds, filledLocations);
 
-        String[][] template = getTrimmedTemplateForLayer(layer, fieldBounds);
-
         // Finally, simply check the normalized template
         for(BlockPos pos : normalizedLocations) {
             String key = layer.getRequiredComponentKeyForPosition(pos);
             if(key == null)
                 return false;
 
-            BlockState state = getBlockStateForNormalizedLocation(world, pos, layer.getDimensions());
+            BlockState state = getBlockStateForNormalizedLocation(world, pos, fieldBounds);
             Optional<String> worldKey = recipe.getRecipeComponentKey(state);
 
             // Is the position the correct block?

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

@@ -1,6 +1,8 @@
 package com.robotgryphon.compactcrafting.recipes;
 
 import com.robotgryphon.compactcrafting.CompactCrafting;
+import com.robotgryphon.compactcrafting.field.FieldHelper;
+import com.robotgryphon.compactcrafting.field.FieldProjectionSize;
 import net.minecraft.block.BlockState;
 import net.minecraft.util.math.AxisAlignedBB;
 import net.minecraft.util.math.BlockPos;
@@ -39,7 +41,7 @@ public boolean hasPadding(IWorldReader world, MiniaturizationRecipe recipe) {
     }
 
     @Override
-    public boolean matchesFieldLayer(IWorldReader world, MiniaturizationRecipe recipe, AxisAlignedBB fieldLayer) {
+    public boolean matchesFieldLayer(IWorldReader world, MiniaturizationRecipe recipe, FieldProjectionSize fieldSize, AxisAlignedBB fieldLayer) {
         Optional<BlockState> component = recipe.getRecipeComponent(componentKey);
         // We can't find a component definition in the recipe, so something very wrong happened
         if(!component.isPresent()) {
@@ -77,6 +79,7 @@ public boolean matchesFieldLayer(IWorldReader world, MiniaturizationRecipe recip
         // Whitespace trim done - no padding needed, min and max bounds are already correct
 
         // Check recipe template against padded world layout
+        Map<BlockPos, String> templateMap = FieldHelper.remapLayerToRecipe(world, recipe, fieldSize, fieldLayer);
 
         return RecipeHelper.layerMatchesTemplate(world, recipe, this, fieldLayer, normalizedFilledPositions);
     }