Basic crafting hologram + animation

Author: robotgryphon

assets/colors.gif

@@ -0,0 +1,25 @@
+package com.robotgryphon.compactcrafting.blocks;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.IBlockReader;
+
+import javax.annotation.Nullable;
+
+public class FieldCraftingPreviewBlock extends Block {
+    public FieldCraftingPreviewBlock(Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    public boolean hasTileEntity(BlockState state) {
+        return true;
+    }
+
+    @Nullable
+    @Override
+    public TileEntity createTileEntity(BlockState state, IBlockReader world) {
+        return new FieldCraftingPreviewTile();
+    }
+}

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

@@ -0,0 +1,112 @@
+package com.robotgryphon.compactcrafting.blocks;
+
+import com.robotgryphon.compactcrafting.core.Registration;
+import com.robotgryphon.compactcrafting.crafting.EnumCraftingState;
+import com.robotgryphon.compactcrafting.recipes.MiniaturizationRecipe;
+import com.robotgryphon.compactcrafting.recipes.MiniaturizationRecipeManager;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.entity.item.ItemEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.play.server.SUpdateTileEntityPacket;
+import net.minecraft.tileentity.ITickableTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+
+import java.util.Optional;
+
+public class FieldCraftingPreviewTile extends TileEntity implements ITickableTileEntity {
+    private FieldProjectorTile masterProjector;
+    private int craftingProgress = 0;
+    private MiniaturizationRecipe recipe;
+
+    public FieldCraftingPreviewTile() {
+        super(Registration.FIELD_CRAFTING_PREVIEW_TILE.get());
+    }
+
+    public int getProgress() {
+        return this.craftingProgress;
+    }
+
+    public Optional<MiniaturizationRecipe> getRecipe() {
+        return Optional.ofNullable(recipe);
+    }
+
+    public void setMasterProjector(FieldProjectorTile master) {
+        this.masterProjector = master;
+        this.recipe = master.getCurrentRecipe().get();
+        this.markDirty();
+    }
+
+    @Override
+    public AxisAlignedBB getRenderBoundingBox() {
+        return new AxisAlignedBB(pos).grow(6.0f);
+    }
+
+    @Override
+    public void tick() {
+        this.craftingProgress++;
+        if(world.isRemote) {
+            return;
+        }
+
+        if(this.craftingProgress >= 200) {
+            if(masterProjector != null) {
+                masterProjector.updateCraftingState(EnumCraftingState.DONE);
+
+                BlockPos fieldCenter = masterProjector.getField().get().getCenterPosition();
+
+                getRecipe().ifPresent(recipe -> {
+                    for (ItemStack is : recipe.getOutputs()) {
+                        ItemEntity itemEntity = new ItemEntity(world, fieldCenter.getX() + 0.5f, fieldCenter.getY() + 0.5f, fieldCenter.getZ() + 0.5f, is);
+                        world.addEntity(itemEntity);
+                    }
+                });
+            }
+
+            world.setBlockState(pos, Blocks.AIR.getDefaultState());
+        }
+    }
+
+    @Override
+    public void read(BlockState state, CompoundNBT compound) {
+        super.read(state, compound);
+
+        craftingProgress = compound.getInt("progress");
+
+        if(compound.contains("recipe")) {
+            ResourceLocation recipeId = new ResourceLocation(compound.getString("recipe"));
+            this.recipe = MiniaturizationRecipeManager.get(recipeId).orElse(null);
+        }
+    }
+
+    @Override
+    public CompoundNBT write(CompoundNBT compound) {
+        super.write(compound);
+        if(recipe != null) {
+            compound.putString("recipe", recipe.getRegistryName().toString());
+        }
+
+        compound.putInt("progress", craftingProgress);
+        return compound;
+    }
+
+    @Override
+    public SUpdateTileEntityPacket getUpdatePacket() {
+        return new SUpdateTileEntityPacket(pos, 1, getUpdateTag());
+    }
+
+    @Override
+    public CompoundNBT getUpdateTag() {
+        return write(new CompoundNBT());
+    }
+
+    @Override
+    public void onDataPacket(NetworkManager net, SUpdateTileEntityPacket packet) {
+        read(getBlockState(), packet.getNbtCompound());
+    }
+}

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

@@ -4,6 +4,7 @@
 import com.robotgryphon.compactcrafting.core.EnumProjectorColorType;
 import com.robotgryphon.compactcrafting.core.Registration;
 import com.robotgryphon.compactcrafting.crafting.CraftingHelper;
+import com.robotgryphon.compactcrafting.crafting.EnumCraftingState;
 import com.robotgryphon.compactcrafting.field.FieldProjection;
 import com.robotgryphon.compactcrafting.field.FieldProjectionSize;
 import com.robotgryphon.compactcrafting.field.MiniaturizationFieldBlockData;
@@ -32,7 +33,7 @@
 
 public class FieldProjectorTile extends TileEntity implements ITickableTileEntity {
 
-    private boolean isCrafting = false;
+    private EnumCraftingState craftingState = EnumCraftingState.NOT_MATCHED;
     private FieldProjection field = null;
     private MiniaturizationRecipe currentRecipe = null;
     private int fieldCheckTimeout = 0;
@@ -49,7 +50,7 @@ public Color getProjectionColor(EnumProjectorColorType type) {
         int green = base.getGreen();
         int blue = base.getBlue();
 
-        switch(type) {
+        switch (type) {
             case FIELD:
             case SCAN_LINE:
                 return new Color(red, green, blue, 100);
@@ -120,10 +121,10 @@ public Optional<BlockPos> getMainProjectorPosition() {
     }
 
     public void invalidateField() {
-        if(world == null || world.isRemote)
+        if (world == null || world.isRemote)
             return;
 
-        if(field != null) {
+        if (field != null) {
             BlockPos center = this.field.getCenterPosition();
             ProjectionFieldSavedData data = ProjectionFieldSavedData.get((ServerWorld) world);
             data.ACTIVE_FIELDS.remove(center);
@@ -152,7 +153,7 @@ public void tick() {
                 return;
         }
 
-        if(this.currentRecipe != null)
+        if (this.currentRecipe != null)
             tickCrafting();
     }
 
@@ -166,7 +167,7 @@ private void doFieldCheck() {
         if (field.isPresent()) {
             this.field = field.get();
 
-            if(world != null && !world.isRemote) {
+            if (world != null && !world.isRemote) {
                 ProjectionFieldSavedData data = ProjectionFieldSavedData.get((ServerWorld) world);
                 data.ACTIVE_FIELDS.put(this.field.getCenterPosition(), ProjectorFieldData.fromInstance(this.field));
                 data.markDirty();
@@ -185,25 +186,24 @@ private void doFieldCheck() {
      * Scans the field and attempts to match a recipe that's placed in it.
      */
     public void doRecipeScan() {
-        if(this.field == null)
+        if (this.field == null)
             return;
 
-        if(this.world == null)
+        if (this.world == null)
             return;
 
         FieldProjectionSize size = field.getFieldSize();
 
         // Only the primary projector needs to worry about the recipe scan
-        if(!isMainProjector())
-        {
+        if (!isMainProjector()) {
             Optional<BlockPos> center = ProjectorHelper.getCenterForSize(world, pos, size);
-            if(!center.isPresent())
+            if (!center.isPresent())
                 return;
 
             BlockPos masterPos = ProjectorHelper.getProjectorLocationForDirection(world, center.get(), Direction.NORTH, size);
 
             FieldProjectorTile masterTile = (FieldProjectorTile) world.getTileEntity(masterPos);
-            if(masterTile == null)
+            if (masterTile == null)
                 return;
 
             masterTile.doRecipeScan();
@@ -215,6 +215,7 @@ public void doRecipeScan() {
         // If there are no registered recipes, then we obv can't match anything - exit early
         if (entries.isEmpty()) {
             this.currentRecipe = null;
+            this.craftingState = EnumCraftingState.NOT_MATCHED;
             return;
         }
 
@@ -223,8 +224,9 @@ public void doRecipeScan() {
         MiniaturizationFieldBlockData fieldBlocks = MiniaturizationFieldBlockData.getFromField(world, fieldBounds);
 
         // If no positions filled, exit early
-        if(fieldBlocks.getNumberFilledBlocks() == 0) {
+        if (fieldBlocks.getNumberFilledBlocks() == 0) {
             this.currentRecipe = null;
+            this.craftingState = EnumCraftingState.NOT_MATCHED;
             return;
         }
 
@@ -238,19 +240,21 @@ public void doRecipeScan() {
 
         // 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) {
+        if (recipesBoundFitted.size() == 0) {
             this.currentRecipe = null;
+            this.craftingState = EnumCraftingState.NOT_MATCHED;
             return;
         }
 
         // Begin recipe dry run - loop, check bottom layer for matches
         MiniaturizationRecipe matchedRecipe = null;
-        for(MiniaturizationRecipe recipe : recipesBoundFitted) {
+        for (MiniaturizationRecipe recipe : recipesBoundFitted) {
             boolean recipeMatches = recipe.matches(world, field.getFieldSize(), fieldBlocks);
-            if(!recipeMatches)
+            if (!recipeMatches)
                 continue;
 
             matchedRecipe = recipe;
+            this.craftingState = EnumCraftingState.MATCHED;
             break;
         }
 
@@ -271,22 +275,32 @@ private void tickCrafting() {
                 // We dropped a catalyst item in
                 // At this point, we had a valid recipe and a valid catalyst entity
                 // Start crafting
-                this.isCrafting = true;
+                switch (craftingState) {
+                    case MATCHED:
+                        craftingState = EnumCraftingState.CRAFTING;
 
-                // We know the "recipe" in the field is an exact match already, so wipe the field
-                field.clearBlocks(world);
+                        // We know the "recipe" in the field is an exact match already, so wipe the field
+                        field.clearBlocks(world);
 
-                CraftingHelper.consumeCatalystItem(catalystEntities.get(0), 1);
+                        CraftingHelper.consumeCatalystItem(catalystEntities.get(0), 1);
 
-                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);
-                }
+                        BlockPos centerField = field.getCenterPosition();
+                        world.setBlockState(centerField, Registration.FIELD_CRAFTING_PREVIEW_BLOCK.get().getDefaultState());
+                        FieldCraftingPreviewTile tile = (FieldCraftingPreviewTile) world.getTileEntity(centerField);
+                        if(tile != null)
+                            tile.setMasterProjector(this);
+
+                        break;
 
-                // We aren't crafting any more - recipe complete, reset for next one
-                this.isCrafting = false;
-                this.currentRecipe = null;
+                    case CRAFTING:
+                        break;
+
+                    case DONE:
+                        // We aren't crafting any more - recipe complete, reset for next one
+                        this.craftingState = EnumCraftingState.NOT_MATCHED;
+                        this.currentRecipe = null;
+                        break;
+                }
             }
         }
     }
@@ -333,4 +347,13 @@ public AxisAlignedBB getRenderBoundingBox() {
     public Optional<FieldProjection> getField() {
         return Optional.ofNullable(this.field);
     }
+
+    public Optional<MiniaturizationRecipe> getCurrentRecipe() {
+        return Optional.ofNullable(this.currentRecipe);
+    }
+
+    public void updateCraftingState(EnumCraftingState state) {
+        this.craftingState = state;
+        this.markDirty();
+    }
 }

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

@@ -1,6 +1,7 @@
 package com.robotgryphon.compactcrafting.client;
 
 import com.robotgryphon.compactcrafting.CompactCrafting;
+import com.robotgryphon.compactcrafting.client.render.FieldCraftingPreviewRenderer;
 import com.robotgryphon.compactcrafting.client.render.FieldProjectorRenderer;
 import com.robotgryphon.compactcrafting.core.Constants;
 import com.robotgryphon.compactcrafting.core.Registration;
@@ -18,6 +19,7 @@ public class ClientSetup {
     @SubscribeEvent
     public static void init(final FMLClientSetupEvent event) {
         ClientRegistry.bindTileEntityRenderer(Registration.FIELD_PROJECTOR_TILE.get(), FieldProjectorRenderer::new);
+        ClientRegistry.bindTileEntityRenderer(Registration.FIELD_CRAFTING_PREVIEW_TILE.get(), FieldCraftingPreviewRenderer::new);
     }
 
     @SubscribeEvent