307 lines
11 KiB
Java
307 lines
11 KiB
Java
package com.pahimar.ee3.util;
|
|
|
|
import com.pahimar.ee3.exchange.OreStack;
|
|
import com.pahimar.ee3.exchange.WrappedStack;
|
|
|
|
import cpw.mods.fml.common.registry.GameRegistry;
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.item.crafting.FurnaceRecipes;
|
|
import net.minecraft.item.crafting.IRecipe;
|
|
import net.minecraft.item.crafting.ShapedRecipes;
|
|
import net.minecraft.item.crafting.ShapelessRecipes;
|
|
import net.minecraftforge.oredict.ShapedOreRecipe;
|
|
import net.minecraftforge.oredict.ShapelessOreRecipe;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* Equivalent-Exchange-3
|
|
* <p/>
|
|
* RecipeHelper
|
|
*
|
|
* @author pahimar
|
|
*/
|
|
public class RecipeHelper
|
|
{
|
|
|
|
/**
|
|
* Returns a list of elements that constitute the input in a crafting recipe
|
|
*
|
|
* @param recipe The IRecipe being examined
|
|
* @return List of elements that constitute the input of the given IRecipe. Could be an ItemStack or an Arraylist
|
|
*/
|
|
public static List<WrappedStack> getRecipeInputs(IRecipe recipe)
|
|
{
|
|
ArrayList<WrappedStack> recipeInputs = new ArrayList<WrappedStack>();
|
|
|
|
if (recipe instanceof ShapedRecipes)
|
|
{
|
|
ShapedRecipes shapedRecipe = (ShapedRecipes) recipe;
|
|
|
|
for (int i = 0; i < shapedRecipe.recipeItems.length; i++)
|
|
{
|
|
if (shapedRecipe.recipeItems[i] instanceof ItemStack)
|
|
{
|
|
ItemStack itemStack = shapedRecipe.recipeItems[i].copy();
|
|
|
|
if (itemStack.stackSize > 1)
|
|
{
|
|
itemStack.stackSize = 1;
|
|
}
|
|
|
|
recipeInputs.add(WrappedStack.wrap(itemStack));
|
|
}
|
|
}
|
|
}
|
|
else if (recipe instanceof ShapelessRecipes)
|
|
{
|
|
ShapelessRecipes shapelessRecipe = (ShapelessRecipes) recipe;
|
|
|
|
for (Object object : shapelessRecipe.recipeItems)
|
|
{
|
|
if (object instanceof ItemStack)
|
|
{
|
|
ItemStack itemStack = ((ItemStack) object).copy();
|
|
|
|
if (itemStack.stackSize > 1)
|
|
{
|
|
itemStack.stackSize = 1;
|
|
}
|
|
|
|
recipeInputs.add(WrappedStack.wrap(itemStack));
|
|
}
|
|
}
|
|
}
|
|
else if (recipe instanceof ShapedOreRecipe)
|
|
{
|
|
ShapedOreRecipe shapedOreRecipe = (ShapedOreRecipe) recipe;
|
|
|
|
if (validateOreDictionaryRecipe(Arrays.asList(shapedOreRecipe.getInput())))
|
|
{
|
|
for (int i = 0; i < shapedOreRecipe.getInput().length; i++)
|
|
{
|
|
/*
|
|
* If the element is a list, then it is an OreStack
|
|
*/
|
|
if (shapedOreRecipe.getInput()[i] instanceof ArrayList)
|
|
{
|
|
WrappedStack oreStack = WrappedStack.wrap(shapedOreRecipe.getInput()[i]);
|
|
|
|
if (oreStack != null && oreStack.getWrappedObject() instanceof OreStack)
|
|
{
|
|
recipeInputs.add(oreStack);
|
|
}
|
|
}
|
|
else if (shapedOreRecipe.getInput()[i] instanceof ItemStack)
|
|
{
|
|
ItemStack itemStack = ((ItemStack) shapedOreRecipe.getInput()[i]).copy();
|
|
|
|
if (itemStack.stackSize > 1)
|
|
{
|
|
itemStack.stackSize = 1;
|
|
}
|
|
|
|
recipeInputs.add(WrappedStack.wrap(itemStack));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (recipe instanceof ShapelessOreRecipe)
|
|
{
|
|
ShapelessOreRecipe shapelessOreRecipe = (ShapelessOreRecipe) recipe;
|
|
|
|
if (validateOreDictionaryRecipe(shapelessOreRecipe.getInput()))
|
|
{
|
|
for (Object object : shapelessOreRecipe.getInput())
|
|
{
|
|
|
|
if (object instanceof ArrayList)
|
|
{
|
|
recipeInputs.add(WrappedStack.wrap(object));
|
|
}
|
|
else if (object instanceof ItemStack)
|
|
{
|
|
|
|
ItemStack itemStack = ((ItemStack) object).copy();
|
|
|
|
if (itemStack.stackSize > 1)
|
|
{
|
|
itemStack.stackSize = 1;
|
|
}
|
|
|
|
recipeInputs.add(WrappedStack.wrap(itemStack));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return collateInputStacks(recipeInputs);
|
|
}
|
|
|
|
/**
|
|
* Collates an uncollated, unsorted List of Objects into a sorted, collated List of WrappedStacks
|
|
*
|
|
* @param uncollatedStacks List of objects for collating
|
|
* @return A sorted, collated List of WrappedStacks
|
|
*/
|
|
public static List<WrappedStack> collateInputStacks(List<?> uncollatedStacks)
|
|
{
|
|
List<WrappedStack> collatedStacks = new ArrayList<WrappedStack>();
|
|
|
|
WrappedStack stack;
|
|
boolean found;
|
|
|
|
for (Object object : uncollatedStacks)
|
|
{
|
|
found = false;
|
|
|
|
if (WrappedStack.canBeWrapped(object))
|
|
{
|
|
stack = WrappedStack.wrap(object);
|
|
|
|
if (collatedStacks.isEmpty())
|
|
{
|
|
collatedStacks.add(stack);
|
|
}
|
|
else
|
|
{
|
|
|
|
for (WrappedStack collatedStack : collatedStacks)
|
|
{
|
|
if (collatedStack.getWrappedObject() != null)
|
|
{
|
|
if (stack.getWrappedObject() instanceof ItemStack && collatedStack.getWrappedObject() instanceof ItemStack)
|
|
{
|
|
if (ItemStackUtils.equals((ItemStack) stack.getWrappedObject(), (ItemStack) collatedStack.getWrappedObject()))
|
|
{
|
|
collatedStack.setStackSize(collatedStack.getStackSize() + stack.getStackSize());
|
|
found = true;
|
|
}
|
|
}
|
|
else if (stack.getWrappedObject() instanceof OreStack && collatedStack.getWrappedObject() instanceof OreStack)
|
|
{
|
|
if (OreStack.compareOreNames((OreStack) stack.getWrappedObject(), (OreStack) collatedStack.getWrappedObject()))
|
|
{
|
|
collatedStack.setStackSize(collatedStack.getStackSize() + stack.getStackSize());
|
|
found = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!found)
|
|
{
|
|
collatedStacks.add(stack);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Collections.sort(collatedStacks);
|
|
return collatedStacks;
|
|
}
|
|
|
|
/**
|
|
* Validates the list of recipe inputs for an OreDictionary recipe to ensure that if there is an
|
|
* OreDictionary entry found in the recipe (a list) that it is not empty (that there are ItemStacks
|
|
* associated with that particular OreDictionary entry)
|
|
*
|
|
* @param objects a list of recipe inputs for an OreDictionary recipe
|
|
* @return true if there exists no "invalid" (empty) OreDictionary entries in the provided list of recipe inputs
|
|
*/
|
|
// FIXME This is not working as intended
|
|
private static boolean validateOreDictionaryRecipe(List objects)
|
|
{
|
|
for (Object object : objects)
|
|
{
|
|
if (object != null)
|
|
{
|
|
if (!WrappedStack.canBeWrapped(object))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static void addRecipe(final ItemStack output, final Object... input) {
|
|
GameRegistry.addShapelessRecipe(output, input);
|
|
}
|
|
|
|
public static void addRecipe(final ItemStack output, final ItemStack transmutationStone, final Object... input) {
|
|
final Object[] inputs = new Object[input.length + 1];
|
|
System.arraycopy(input, 0, inputs, 0, input.length);
|
|
inputs[input.length] = transmutationStone;
|
|
addRecipe(output, inputs);
|
|
}
|
|
|
|
public static void addRecipe(final Block output, final Object... input) {
|
|
addRecipe(new ItemStack(output), input);
|
|
}
|
|
|
|
public static void addRecipe(final Block output, final int count, final Object... input) {
|
|
addRecipe(new ItemStack(output, count), input);
|
|
}
|
|
|
|
public static void addRecipe(final Item output, final Object... input) {
|
|
addRecipe(new ItemStack(output), input);
|
|
}
|
|
|
|
public static void addRecipe(final Item output, final int count, final Object... input) {
|
|
addRecipe(new ItemStack(output, count), input);
|
|
}
|
|
|
|
public static Object[] getMetaCycle(final Object input, final int n) {
|
|
final ArrayList<ItemStack> list = new ArrayList<>();
|
|
for (int i = 0; i < n; ++i) {
|
|
final ItemStack stack = ItemStackUtils.convertObjectToItemStack(input);
|
|
stack.setItemDamage(i);
|
|
list.add(stack);
|
|
}
|
|
return list.toArray();
|
|
}
|
|
|
|
public static Object[] getMetaCycle(final Object input, final int n, final int... excludedMeta) {
|
|
final ArrayList<ItemStack> list = new ArrayList<>();
|
|
for (int i = 0; i < n; ++i) {
|
|
for (final int j : excludedMeta) {
|
|
if (i == j) {
|
|
++i;
|
|
}
|
|
}
|
|
if (i >= n) {
|
|
break;
|
|
}
|
|
final ItemStack stack = ItemStackUtils.convertObjectToItemStack(input);
|
|
stack.setItemDamage(i);
|
|
list.add(stack);
|
|
}
|
|
return list.toArray();
|
|
}
|
|
|
|
public static void addSmeltingRecipe(final ItemStack input, final ItemStack stone, final ItemStack fuel) {
|
|
final ItemStack result = FurnaceRecipes.smelting().getSmeltingResult(input);
|
|
if (input == null || input.getItem() == null || result == null) {
|
|
return;
|
|
}
|
|
final Object[] list = new Object[9];
|
|
list[0] = stone;
|
|
list[1] = fuel;
|
|
for (int i = 2; i < 9; ++i) {
|
|
list[i] = new ItemStack(input.getItem(), 1, input.getItemDamage());
|
|
}
|
|
if (result.stackSize * 7 <= result.getItem().getItemStackLimit()) {
|
|
GameRegistry.addShapelessRecipe(new ItemStack(result.getItem(), result.stackSize * 7, result.getItemDamage()), list);
|
|
}
|
|
else {
|
|
GameRegistry.addShapelessRecipe(new ItemStack(result.getItem(), result.getItem().getItemStackLimit(), result.getItemDamage()), list);
|
|
}
|
|
}
|
|
}
|