285 lines
9.1 KiB
Java
285 lines
9.1 KiB
Java
package WayofTime.bloodmagic.compress;
|
|
|
|
public class StorageBlockCraftingRecipeAssimilator {
|
|
// public static final List<Class> ignore = new ArrayList<Class>();
|
|
//
|
|
// public List<IRecipe> getPackingRecipes()
|
|
// {
|
|
// // grab all recipes potentially suitable for packing or unpacking
|
|
//
|
|
// List<PackingRecipe> packingRecipes = new LinkedList<PackingRecipe>();
|
|
// List<IRecipe> unpackingRecipes = new ArrayList<IRecipe>();
|
|
//
|
|
// for (IRecipe recipe : getCraftingRecipes())
|
|
// {
|
|
// if (ignore.contains(recipe.getClass()))
|
|
// continue;
|
|
//
|
|
// ItemStack output = recipe.getRecipeOutput();
|
|
// if (output.isEmpty())
|
|
// continue;
|
|
//
|
|
// if (output.getCount() == 1)
|
|
// {
|
|
// PackingRecipe packingRecipe = getPackingRecipe(recipe);
|
|
//
|
|
// if (packingRecipe != null)
|
|
// {
|
|
// packingRecipes.add(packingRecipe);
|
|
// }
|
|
// } else if ((output.getCount() == 4 || output.getCount() == 9) && recipe.canFit(1, 1))
|
|
// {
|
|
// unpackingRecipes.add(recipe);
|
|
// }
|
|
// }
|
|
//
|
|
// // grab all packing recipes which accept the output of any of the
|
|
// // unpacking recipes
|
|
//
|
|
// Container container = makeDummyContainer();
|
|
// InventoryCrafting inventoryUnpack = new InventoryCrafting(container, 2, 2);
|
|
// InventoryCrafting inventory2x2 = new InventoryCrafting(container, 2, 2);
|
|
// InventoryCrafting inventory3x3 = new InventoryCrafting(container, 3, 3);
|
|
// World world = null; // TODO: use a proper dummy world?
|
|
//
|
|
// List<IRecipe> ret = new ArrayList<IRecipe>();
|
|
//
|
|
// for (IRecipe recipeUnpack : unpackingRecipes)
|
|
// {
|
|
// if (ignore.contains(recipeUnpack.getClass()))
|
|
// continue;
|
|
//
|
|
// ItemStack unpacked = recipeUnpack.getRecipeOutput();
|
|
// InventoryCrafting inventory = null;
|
|
//
|
|
// for (Iterator<PackingRecipe> it = packingRecipes.iterator(); it.hasNext();)
|
|
// {
|
|
// PackingRecipe recipePack = it.next();
|
|
//
|
|
// // check if the packing recipe accepts the unpacking recipe's output
|
|
//
|
|
// boolean matched = false;
|
|
//
|
|
// if (recipePack.possibleInputs != null)
|
|
// {
|
|
// // the recipe could be parsed, use its inputs directly since that's faster verify recipe size
|
|
//
|
|
// if (recipePack.inputCount != unpacked.getCount())
|
|
// continue;
|
|
//
|
|
// // check if any of the input options matches the unpacked
|
|
// // item stack
|
|
//
|
|
// for (ItemStack stack : recipePack.possibleInputs)
|
|
// {
|
|
// if (areInputsIdentical(unpacked, stack))
|
|
// {
|
|
// matched = true;
|
|
// break;
|
|
// }
|
|
// }
|
|
// } else
|
|
// {
|
|
// // unknown IRecipe, check through the recipe conventionally verify recipe size for 3x3 to skip anything smaller quickly
|
|
//
|
|
// if (unpacked.getCount() == 9 && recipePack.recipe.getIngredients().size() < 9)
|
|
// continue;
|
|
//
|
|
// // initialize inventory late, but only once per unpack recipe
|
|
//
|
|
// if (inventory == null)
|
|
// {
|
|
// if (unpacked.getCount() == 4)
|
|
// {
|
|
// inventory = inventory2x2;
|
|
// } else
|
|
// {
|
|
// inventory = inventory3x3;
|
|
// }
|
|
//
|
|
// for (int i = 0; i < unpacked.getCount(); i++)
|
|
// {
|
|
// inventory.setInventorySlotContents(i, unpacked.copy());
|
|
// }
|
|
// }
|
|
//
|
|
// // check if the packing recipe accepts the unpacked item
|
|
// // stack
|
|
//
|
|
// matched = recipePack.recipe.matches(inventory, world);
|
|
// }
|
|
//
|
|
// if (matched)
|
|
// {
|
|
// // check if the unpacking recipe accepts the packing
|
|
// // recipe's output
|
|
//
|
|
// ItemStack packOutput = recipePack.recipe.getRecipeOutput();
|
|
// inventoryUnpack.setInventorySlotContents(0, packOutput.copy());
|
|
//
|
|
// if (recipeUnpack.matches(inventoryUnpack, world))
|
|
// {
|
|
// ret.add(recipePack.recipe);
|
|
// it.remove();
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// return ret;
|
|
// }
|
|
//
|
|
// @SuppressWarnings("unchecked")
|
|
// private List<IRecipe> getCraftingRecipes()
|
|
// {
|
|
// return ForgeRegistries.RECIPES.getValues();
|
|
// }
|
|
//
|
|
// private Container makeDummyContainer()
|
|
// {
|
|
// return new Container()
|
|
// {
|
|
// @Override
|
|
// public boolean canInteractWith(EntityPlayer player)
|
|
// {
|
|
// return true;
|
|
// }
|
|
// };
|
|
// }
|
|
//
|
|
// private PackingRecipe getPackingRecipe(IRecipe recipe)
|
|
// {
|
|
// if (recipe.getIngredients().size() < 4)
|
|
// return null;
|
|
//
|
|
// List<Ingredient> inputs = recipe.getIngredients();
|
|
//
|
|
// // check if the recipe inputs are size 4 or 9
|
|
//
|
|
// int count = 0;
|
|
//
|
|
// for (Object o : inputs)
|
|
// {
|
|
// if (o != null)
|
|
// count++;
|
|
// }
|
|
//
|
|
// if (count != 4 && count != 9)
|
|
// return null;
|
|
//
|
|
// // grab identical inputs
|
|
//
|
|
// List<Ingredient> identicalInputs = getIdenticalInputs(inputs);
|
|
// if (identicalInputs == null)
|
|
// return null;
|
|
//
|
|
// return new PackingRecipe(recipe, identicalInputs, count);
|
|
// }
|
|
//
|
|
// /**
|
|
// * Determine the item stacks from the provided inputs which are suitable for
|
|
// * every input element.
|
|
// *
|
|
// * @param inputs
|
|
// * List of all inputs, null elements are being ignored.
|
|
// * @return List List of all options.
|
|
// */
|
|
// @SuppressWarnings("unchecked")
|
|
// private List<Ingredient> getIdenticalInputs(List<Ingredient> inputs)
|
|
// {
|
|
// List<Ingredient> options = null;
|
|
//
|
|
// for (Ingredient input : inputs)
|
|
// {
|
|
// if (input == null)
|
|
// continue;
|
|
//
|
|
// List<ItemStack> offers;
|
|
//
|
|
// if (input. instanceof ItemStack)
|
|
// {
|
|
// offers = Collections.singletonList((ItemStack) input);
|
|
// } else if (input instanceof List)
|
|
// {
|
|
// offers = (List<ItemStack>) input;
|
|
//
|
|
// if (offers.isEmpty())
|
|
// return null;
|
|
// } else
|
|
// {
|
|
// throw new RuntimeException("invalid input: " + input.getClass());
|
|
// }
|
|
//
|
|
// if (options == null)
|
|
// {
|
|
// options = new ArrayList<ItemStack>(offers);
|
|
// continue;
|
|
// }
|
|
//
|
|
// for (Iterator<ItemStack> it = options.iterator(); it.hasNext();)
|
|
// {
|
|
// ItemStack stackReq = it.next();
|
|
// boolean found = false;
|
|
//
|
|
// for (ItemStack stackCmp : offers)
|
|
// {
|
|
// if (areInputsIdentical(stackReq, stackCmp))
|
|
// {
|
|
// found = true;
|
|
// break;
|
|
// }
|
|
// }
|
|
//
|
|
// if (!found)
|
|
// {
|
|
// it.remove();
|
|
//
|
|
// if (options.isEmpty())
|
|
// return null;
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// return options;
|
|
// }
|
|
//
|
|
// private boolean areInputsIdentical(ItemStack a, ItemStack b)
|
|
// {
|
|
//
|
|
// try
|
|
// {
|
|
// if (a.getItem() != b.getItem())
|
|
// return false;
|
|
//
|
|
// int dmgA = a.getItemDamage();
|
|
// int dmgB = b.getItemDamage();
|
|
//
|
|
// return dmgA == dmgB || dmgA == OreDictionary.WILDCARD_VALUE || dmgB == OreDictionary.WILDCARD_VALUE;
|
|
// } catch (NullPointerException e)
|
|
// {
|
|
//
|
|
// BloodMagic.instance.getLogger().error("A mod in this instance has registered an item with a null input. Known problem mods are:");
|
|
//
|
|
// // String err = "";
|
|
// // for (String problem : problemMods)
|
|
// // err += (err.length() > 0 ? ", " : "") + problem;
|
|
// // BloodMagic.instance.getLogger().error(err);
|
|
//
|
|
// return false;
|
|
// }
|
|
// }
|
|
//
|
|
// private static class PackingRecipe
|
|
// {
|
|
// PackingRecipe(IRecipe recipe, List<ItemStack> possibleInputs, int inputCount)
|
|
// {
|
|
// this.recipe = recipe;
|
|
// this.possibleInputs = possibleInputs;
|
|
// this.inputCount = inputCount;
|
|
// }
|
|
//
|
|
// final IRecipe recipe;
|
|
// final List<ItemStack> possibleInputs;
|
|
// final int inputCount;
|
|
// }
|
|
}
|