Merge branch 'master-1.11' into master-1.12

Conflicts:
	build.properties
	src/main/java/org/cyclops/structuredcrafting/craft/WorldCraftingMatrix.java

Author: rubensworks

resources/changelog/1.11.2-0.1.9.txt

@@ -0,0 +1,5 @@
+As always, don't forget to backup your world before updating!
+Requires CyclopsCore version 0.10.6 or higher.
+
+Fixes:
+* Fix conflicting handling of recipes that use inventories and blocks, Closes #6. Different possibilities are now checked in parallel.

src/main/java/org/cyclops/structuredcrafting/craft/WorldCraftingMatrix.java

@@ -1,6 +1,7 @@
 package org.cyclops.structuredcrafting.craft;
 
 import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
 import net.minecraft.item.ItemStack;
 import net.minecraft.item.crafting.CraftingManager;
 import net.minecraft.item.crafting.IRecipe;
@@ -15,15 +16,14 @@
 import org.cyclops.structuredcrafting.craft.provider.IItemStackProviderRegistry;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * A crafting matrix represented with blockstates.
  * @author rubensworks
  */
 public class WorldCraftingMatrix {
 
-    private static final WorldInventoryCrafting INVENTORY_CRAFTING = new WorldInventoryCrafting();
-
     private final World world;
     private final BlockPos centerPos;
     private final EnumFacing.Axis axis;
@@ -56,13 +56,14 @@ protected List<IItemStackProvider> getItemStackProviders() {
                 getRegistry(IItemStackProviderRegistry.class).getProviders();
     }
 
-    protected Pair<ItemStack, IItemStackProvider> determineItemStackProviderForInput(World world, BlockPos pos, EnumFacing side) {
+    protected Map<ItemStack, IItemStackProvider> determineItemStackProviderForInput(World world, BlockPos pos, EnumFacing side) {
+        Map<ItemStack, IItemStackProvider> providers = Maps.newHashMap();
         for(IItemStackProvider provider : getItemStackProviders()) {
             if(provider.hasItemStack(world, pos, side)) {
-                return Pair.of(provider.getItemStack(world, pos, side), provider);
+                providers.put(provider.getItemStack(world, pos, side), provider);
             }
         }
-        return null;
+        return providers;
     }
 
     protected boolean addItemStackForOutput(World world, BlockPos pos, EnumFacing side, List<IItemStackProvider> outputProviders, ItemStack itemStack, boolean simulate) {
@@ -86,45 +87,113 @@ public boolean craft(boolean simulate) {
             return false;
         }
 
-        BlockPos[] positions = new BlockPos[9];
-        IItemStackProvider[] providers = new IItemStackProvider[9];
-        ItemStack itemStack = ItemStack.EMPTY;
+        CraftingPossibility chosenPossibility = null;
+        ItemStack itemStack = null;
         for(int k = 0; k < 3; k++) {
             // Set crafting grid
-            if(itemStack.isEmpty()) {
+            if(chosenPossibility == null) {
+                List<CraftingPossibility> possibilities = Lists.newArrayList(new CraftingPossibility());
                 for (int i = -1; i < 2; i++) {
                     for (int j = -1; j < 2; j++) {
-                        int arrayIndex = (j + 1) * 3 + (i + 1);
                         BlockPos pos = addInAxis(centerPos, axis, i, j);
-                        Pair<ItemStack, IItemStackProvider> result = determineItemStackProviderForInput(world, pos, inputSide);
-                        ItemStack itemStackInput = result != null ? result.getLeft() : ItemStack.EMPTY;
-                        if (!itemStackInput.isEmpty()) {
-                            itemStackInput = itemStackInput.copy();
-                            itemStackInput.setCount(1);
+                        Map<ItemStack, IItemStackProvider> results = determineItemStackProviderForInput(world, pos, inputSide);
+                        boolean processedSingleResult = false;
+                        List<CraftingPossibility> possibilitiesAtStart = Lists.newArrayList(possibilities);
+                        for (Map.Entry<ItemStack, IItemStackProvider> result : results.entrySet()) {
+                            ItemStack itemStackInput = result.getKey();
+                            if (!itemStackInput.isEmpty()) {
+                                itemStackInput = itemStackInput.copy();
+                                itemStackInput.setCount(1);
+                            }
+
+                            if (!processedSingleResult) {
+                                // The first result we process, just add position to all existing possibilities
+                                for (CraftingPossibility possibility : possibilities) {
+                                    possibility.setPosition(i, j, k, pos, result.getValue(), result.getKey());
+                                }
+                                processedSingleResult = true;
+                            } else {
+                                // We have more than one possibility!
+                                // Duplicate all existing possibilities.
+                                for (CraftingPossibility possibility : possibilitiesAtStart) {
+                                    possibility = possibility.clone();
+                                    possibility.setPosition(i, j, k, pos, result.getValue(), result.getKey());
+                                    possibilities.add(possibility);
+                                }
+                            }
                         }
-                        // This makes sure we can also accept recipes which are rotated, mirroring is already supported by Vanilla.
-                        if (k == 0) {
-                            INVENTORY_CRAFTING.setItemStack(i + 1, j + 1, itemStackInput);
-                        } else if(k == 1) {
-                            INVENTORY_CRAFTING.setItemStack(j + 1, i + 1, itemStackInput);
-                        } else if(k == 2) {
-                            INVENTORY_CRAFTING.setItemStack(i + 1, 2 - (j + 1), itemStackInput);
+
+                        // No valid result was found, add an empty slot to all possibilities
+                        if (!processedSingleResult) {
+                            for (CraftingPossibility possibility : possibilities) {
+                                possibility.setPosition(i, j, k, pos, null, ItemStack.EMPTY);
+                            }
                         }
-                        positions[arrayIndex] = pos;
-                        providers[arrayIndex] = result != null ? result.getRight() : null;
                     }
                 }
-                IRecipe recipe = CraftingManager.findMatchingRecipe(INVENTORY_CRAFTING, world);
-                if (recipe != null) {
-                    itemStack = recipe.getCraftingResult(INVENTORY_CRAFTING);
+                for (CraftingPossibility possibility : possibilities) {
+                    if (!(itemStack = possibility.getOutput(world)).isEmpty()) {
+                        chosenPossibility = possibility;
+                        break;
+                    }
                 }
             }
         }
 
         // Determine output
-        if(!itemStack.isEmpty() && addItemStackForOutput(world, targetPos, targetSide, outputProviders, itemStack, simulate)) {
-            // Handle remaining container items: place blocks and drop items
-            NonNullList<ItemStack> remainingStacks = CraftingManager.getRemainingItems(INVENTORY_CRAFTING, world);
+        if(chosenPossibility != null && !itemStack.isEmpty()
+                && addItemStackForOutput(world, targetPos, targetSide, outputProviders, itemStack, simulate)) {
+            chosenPossibility.handleRemainingItems(world, inputSide, simulate);
+            return true;
+        }
+        return false;
+    }
+
+    public static WorldCraftingMatrix deriveMatrix(World world, BlockPos centerPos) {
+        EnumFacing side = (world.getBlockState(centerPos).getValue(BlockStructuredCrafter.FACING)).getOpposite();
+        return new WorldCraftingMatrix(world, centerPos.offset(side), side.getAxis(),
+                centerPos.offset(side.getOpposite()), side.getOpposite());
+    }
+
+    public static class CraftingPossibility {
+        private final WorldInventoryCrafting inventoryCrafting = new WorldInventoryCrafting();
+        private final BlockPos[] positions = new BlockPos[9];
+        private final IItemStackProvider[] providers = new IItemStackProvider[9];
+
+        public CraftingPossibility() {
+
+        }
+
+        public void setPosition(int i, int j, int rotation, BlockPos pos, IItemStackProvider itemStackProvider, ItemStack itemStack) {
+            int arrayIndex = (j + 1) * 3 + (i + 1);
+            // This makes sure we can also accept recipes which are rotated, mirroring is already supported by Vanilla.
+            if (rotation == 0) {
+                inventoryCrafting.setItemStack(i + 1, j + 1, itemStack);
+            } else if(rotation == 1) {
+                inventoryCrafting.setItemStack(j + 1, i + 1, itemStack);
+            } else if(rotation == 2) {
+                inventoryCrafting.setItemStack(i + 1, 2 - (j + 1), itemStack);
+            }
+            positions[arrayIndex] = pos;
+            providers[arrayIndex] = itemStackProvider;
+        }
+
+        public ItemStack getOutput(World world) {
+            IRecipe recipe = CraftingManager.findMatchingRecipe(inventoryCrafting, world);
+            if (recipe != null) {
+                return recipe.getCraftingResult(inventoryCrafting);
+            }
+            return ItemStack.EMPTY;
+        }
+
+        /**
+         * Handle remaining container items: place blocks and drop items
+         * @param world The world.
+         * @param inputSide The crafting side.
+         * @param simulate If the crafting should be simulated.
+         */
+        public void handleRemainingItems(World world, EnumFacing inputSide, boolean simulate) {
+            NonNullList<ItemStack> remainingStacks = CraftingManager.getRemainingItems(inventoryCrafting, world);
             for(int i = 0; i < remainingStacks.size(); i++) {
                 ItemStack remainingStack = remainingStacks.get(i);
                 if(providers[i] != null) {
@@ -134,15 +203,17 @@ public boolean craft(boolean simulate) {
                     }
                 }
             }
-            return true;
         }
-        return false;
-    }
 
-    public static WorldCraftingMatrix deriveMatrix(World world, BlockPos centerPos) {
-        EnumFacing side = (world.getBlockState(centerPos).getValue(BlockStructuredCrafter.FACING)).getOpposite();
-        return new WorldCraftingMatrix(world, centerPos.offset(side), side.getAxis(),
-                centerPos.offset(side.getOpposite()), side.getOpposite());
+        public CraftingPossibility clone() {
+            CraftingPossibility craftingPossibility = new CraftingPossibility();
+            for (int i = 0; i < this.inventoryCrafting.getSizeInventory(); i++) {
+                craftingPossibility.inventoryCrafting.setInventorySlotContents(i, this.inventoryCrafting.getStackInSlot(i));
+            }
+            System.arraycopy(this.positions, 0, craftingPossibility.positions, 0, this.positions.length);
+            System.arraycopy(this.providers, 0, craftingPossibility.providers, 0, this.providers.length);
+            return craftingPossibility;
+        }
     }
 
 }