Implement basic mixed component recipe layer

Author: robotgryphon

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

@@ -6,7 +6,7 @@
 import com.robotgryphon.compactcrafting.items.FieldProjectorItem;
 import com.robotgryphon.compactcrafting.recipes.IRecipeLayer;
 import com.robotgryphon.compactcrafting.recipes.MiniaturizationRecipe;
-import com.robotgryphon.compactcrafting.recipes.SingleComponentRecipeLayer;
+import com.robotgryphon.compactcrafting.recipes.MixedComponentRecipeLayer;
 import net.minecraft.block.Block;
 import net.minecraft.block.Blocks;
 import net.minecraft.block.material.Material;
@@ -83,40 +83,42 @@ public class Registration {
     {
         MiniaturizationRecipe rec = new MiniaturizationRecipe();
 
-        Set<BlockPos> template = new HashSet<>();
+        Set<BlockPos> glassColl = new HashSet<>();
+        Set<BlockPos> handleColl = new HashSet<>();
 
-        BlockPos[] complexPattern = new BlockPos[] {
-                // Glass
+        BlockPos[] glass = new BlockPos[]{
                 new BlockPos(3, 0, 0),
                 new BlockPos(4, 0, 0),
                 new BlockPos(2, 0, 1),
                 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),
+                new BlockPos(4, 0, 3)
+        };
 
-                // Tail
+        BlockPos[] handle = new BlockPos[]{
                 new BlockPos(2, 0, 3),
                 new BlockPos(1, 0, 4),
                 new BlockPos(0, 0, 5)
         };
 
-        Collections.addAll(template, complexPattern);
+        Collections.addAll(glassColl, glass);
+        Collections.addAll(handleColl, handle);
 
-        rec.setLayers(new IRecipeLayer[]{
-                new SingleComponentRecipeLayer("O", template),
-                new SingleComponentRecipeLayer("G", template)
+        MixedComponentRecipeLayer mixed = new MixedComponentRecipeLayer();
+        mixed.addMultiple("S", handleColl);
+        mixed.addMultiple("G", glassColl);
 
-        });
+        rec.setLayers(new IRecipeLayer[]{mixed});
 
         rec.catalyst = Items.ANVIL;
         rec.outputs = new ItemStack[]{
                 new ItemStack(Items.CRYING_OBSIDIAN, 11)
         };
 
-        rec.addComponent("O", Blocks.OBSIDIAN.getDefaultState());
-        rec.addComponent("G", Blocks.GLOWSTONE.getDefaultState());
+        rec.addComponent("S", Blocks.STONE.getDefaultState());
+        rec.addComponent("G", Blocks.GLASS.getDefaultState());
 
         return rec;
     });

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

@@ -0,0 +1,96 @@
+package com.robotgryphon.compactcrafting.recipes;
+
+import com.robotgryphon.compactcrafting.util.BlockSpaceUtil;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.IWorldReader;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+public class MixedComponentRecipeLayer implements IRecipeLayer {
+    private AxisAlignedBB dimensions;
+    private Map<BlockPos, String> componentLookup;
+    private Map<String, Integer> totalCache;
+
+    public MixedComponentRecipeLayer() {
+        this.dimensions = AxisAlignedBB.withSizeAtOrigin(0, 0, 0);
+        this.componentLookup = new HashMap<>();
+    }
+
+    public void add(String component, BlockPos location) {
+        componentLookup.putIfAbsent(location, component);
+        this.dimensions = BlockSpaceUtil.getBoundsForBlocks(componentLookup.keySet());
+    }
+
+    public void addMultiple(String component, Collection<BlockPos> locations) {
+        boolean recalc = false;
+        for(BlockPos loc : locations) {
+            if(!componentLookup.containsKey(loc)) {
+                componentLookup.put(loc, component);
+                recalc = true;
+            }
+        }
+
+        if(recalc)
+            this.dimensions = BlockSpaceUtil.getBoundsForBlocks(componentLookup.keySet());
+    }
+
+    @Override
+    public boolean hasPadding(IWorldReader world, MiniaturizationRecipe recipe) {
+        return false;
+    }
+
+    @Override
+    public AxisAlignedBB getDimensions() {
+        return this.dimensions;
+    }
+
+    @Override
+    public Map<String, Integer> getComponentTotals() {
+        if(this.totalCache != null)
+            return this.totalCache;
+
+        Map<String, Integer> totals = new HashMap<>();
+        componentLookup.forEach((pos, comp) -> {
+            int prev = 0;
+            if(!totals.containsKey(comp))
+                totals.put(comp, 0);
+            else
+                prev = totals.get(comp);
+
+            totals.replace(comp, prev + 1);
+        });
+
+        this.totalCache = totals;
+
+        return this.totalCache;
+    }
+
+    @Override
+    public String getRequiredComponentKeyForPosition(BlockPos pos) {
+        if(componentLookup.containsKey(pos))
+            return componentLookup.get(pos);
+
+        return null;
+    }
+
+    @Override
+    public Collection<BlockPos> getNonAirPositions() {
+        return componentLookup.keySet();
+    }
+
+    @Override
+    public boolean isPositionRequired(BlockPos pos) {
+        return componentLookup.containsKey(pos);
+    }
+
+    @Override
+    public int getNumberFilledPositions() {
+        return getComponentTotals()
+                .values()
+                .stream()
+                .reduce(0, Integer::sum);
+    }
+}