fix missing source folder

1 files changed, 205 insertions, 0 deletions

diff --git a/src/main/java/ihl/recipes/UniversalRecipeInput.java b/src/main/java/ihl/recipes/UniversalRecipeInput.java
new file mode 100644
index 0000000..7cdb386
--- /dev/null
+++ b/src/main/java/ihl/recipes/UniversalRecipeInput.java
@@ -0,0 +1,205 @@
+package ihl.recipes;

+

+import java.util.ArrayList;

+import java.util.Arrays;

+import java.util.HashMap;

+import java.util.Iterator;

+import java.util.List;

+import java.util.Map;

+

+import ic2.api.recipe.IRecipeInput;

+import ic2.api.recipe.RecipeInputItemStack;

+import ic2.api.recipe.RecipeInputOreDict;

+import ihl.interfaces.IWire;

+import ihl.utils.IHLUtils;

+import ihl.worldgen.ores.IHLFluid;

+import net.minecraft.item.ItemStack;

+import net.minecraftforge.fluids.FluidStack;

+

+public class UniversalRecipeInput {

+

+	private final List<IRecipeInputFluid> fluidInputs = new ArrayList<IRecipeInputFluid>();

+	private final List<IRecipeInput> itemInputs = new ArrayList<IRecipeInput>();

+

+	public UniversalRecipeInput(Object[] fluidStacks, Object[] iRecipeInputs) {

+		if (fluidStacks != null) {

+			for (Object material : fluidStacks) {

+				if (material == null) {

+					throw new NullPointerException("Recipe input cannot be null!");

+				}

+				if (material instanceof FluidStack) {

+					fluidInputs.add(new RecipeInputFluidStack((FluidStack) material));

+				} else {

+					fluidInputs.add((IRecipeInputFluid) material);

+				}

+			}

+		}

+		sortFluidsByDensity();

+		if (iRecipeInputs != null) {

+			for (Object material : iRecipeInputs) {

+				if (material == null) {

+					throw new NullPointerException("Recipe input cannot be null!");

+				}

+				if (material instanceof ItemStack) {

+					ItemStack stack = (ItemStack) material;

+					String oreDictName = IHLUtils.getFirstOreDictNameExcludingTagAny(stack);

+					if (stack.getItem() instanceof IWire) {

+						itemInputs.add(new RecipeInputWire(stack));

+					} else if (!oreDictName.isEmpty() && oreDictName.length() > 3) {

+						itemInputs.add(new RecipeInputOreDict(oreDictName, stack.stackSize));

+					} else {

+						itemInputs.add(new RecipeInputItemStack(stack));

+					}

+				} else {

+					itemInputs.add((IRecipeInput) material);

+				}

+			}

+		}

+	}

+	

+	public void sortFluidsByDensity()

+	{

+		Map<Integer, IRecipeInputFluid> sortMap = new HashMap<Integer, IRecipeInputFluid>();

+		int[] keysArray = new int[fluidInputs.size()];

+    	Iterator<IRecipeInputFluid> fli = fluidInputs.iterator();

+		while(fli.hasNext())

+    	{

+			IRecipeInputFluid rinput = fli.next();

+        	FluidStack fluid=rinput.getInputs().get(0);

+        	if(fluid==null)

+        	{

+        		return;

+        	}

+        		int key = Math.round(IHLFluid.getRealDensity(fluid.getFluid())*100F);

+        		while(sortMap.containsKey(key))

+        		{

+        			key++;

+        		}

+        		sortMap.put(key, rinput);

+        		keysArray[fluidInputs.indexOf(rinput)]=key;

+    	}

+		Arrays.sort(keysArray);

+		List<IRecipeInputFluid> newFluidList = new ArrayList<IRecipeInputFluid>();

+		for(int i=keysArray.length-1;i>=0;i--)

+		{

+			newFluidList.add(sortMap.get(keysArray[i]));

+		}

+		this.fluidInputs.clear();

+		this.fluidInputs.addAll(newFluidList);

+	}

+

+	public boolean matches(List<FluidStack> fluidInputs1, List<ItemStack> itemInputs1) {

+		return this.matches(fluidInputs1, itemInputs1, false);

+	}

+

+	public List<IRecipeInputFluid> getFluidInputs() {

+		return fluidInputs;

+	}

+

+	public List<IRecipeInput> getItemInputs() {

+		return itemInputs;

+	}

+

+	public boolean matches(UniversalRecipeInput input) {

+		List<IRecipeInput> rInputs = input.getItemInputs();

+		Iterator<IRecipeInput> ii = rInputs.iterator();

+		List<ItemStack> rInputsItems = new ArrayList<ItemStack>();

+		while (ii.hasNext()) {

+			IRecipeInput is = ii.next();

+			rInputsItems.add(is.getInputs().get(0));

+		}

+		List<FluidStack> rInputsFluids = new ArrayList<FluidStack>();

+		List<IRecipeInputFluid> rInputsF = input.getFluidInputs();

+		Iterator<IRecipeInputFluid> iiF = rInputsF.iterator();

+		while (iiF.hasNext()) {

+			IRecipeInputFluid is = iiF.next();

+			rInputsFluids.add(is.getInputs().get(0));

+		}

+		return this.matches(rInputsFluids, rInputsItems);

+	}

+

+	public boolean matches(List<FluidStack> fluidInputs1, List<ItemStack> itemInputs1, boolean doCheckAmounts) {

+		if (incorrectInputAmount(fluidInputs1, itemInputs1)) {

+			return false;

+		}

+		if (fluidInputs1 != null) {

+			Iterator<IRecipeInputFluid> fi = fluidInputs.iterator();

+			while (fi.hasNext()) {

+				IRecipeInputFluid fs = fi.next();

+				FluidStack fs1 = getMatchedFluidStack(fs, fluidInputs1);

+				if (fs1 == null || !fs.matches(fs1)) {

+					return false;

+				} else if (doCheckAmounts && fs1.amount < fs.getAmount()) {

+					return false;

+				}

+			}

+		}

+		if (itemInputs1 != null) {

+			Iterator<IRecipeInput> ii = itemInputs.iterator();

+			while (ii.hasNext()) {

+				IRecipeInput is = ii.next();

+				ItemStack is1 = getMatchedItemStack(is, itemInputs1);

+				if (is1 == null || !is.matches(is1)) {

+					return false;

+				} else if (doCheckAmounts && IHLUtils.getAmountOf(is1) < is.getAmount()) {

+					return false;

+				}

+			}

+		}

+		return true;

+	}

+

+	private ItemStack getMatchedItemStack(IRecipeInput is, List<ItemStack> itemInputs1) {

+		for (ItemStack is1 : itemInputs1) {

+			if (is1 != null) {

+				if (is.matches(is1)) {

+					return is1;

+				}

+			}

+		}

+		return null;

+	}

+

+	private FluidStack getMatchedFluidStack(IRecipeInputFluid fs, List<FluidStack> fluidInputs1) {

+		for (FluidStack fs1 : fluidInputs1) {

+			if (fs.matches(fs1)) {

+				return fs1;

+			}

+		}

+		return null;

+	}

+

+	public boolean containItemStack(ItemStack ingredient) {

+		if (itemInputs == null || itemInputs.isEmpty()) {

+			return false;

+		}

+		Iterator<IRecipeInput> ii = itemInputs.iterator();

+		while (ii.hasNext()) {

+			IRecipeInput is = ii.next();

+			if (is.matches(ingredient)) {

+				return true;

+			}

+		}

+		return false;

+	}

+

+	public boolean containFluidStack(FluidStack fluidStack) {

+		if (fluidInputs == null || fluidInputs.isEmpty()) {

+			return false;

+		}

+		Iterator<IRecipeInputFluid> ii = fluidInputs.iterator();

+		while (ii.hasNext()) {

+			IRecipeInputFluid is = ii.next();

+			if (is != null && is.matches(fluidStack)) {

+				return true;

+			}

+		}

+		return false;

+	}

+

+	private boolean incorrectInputAmount(List<FluidStack> fluidInputs1, List<ItemStack> itemInputs1) {

+		return (fluidInputs.size() > 0 && fluidInputs1 == null) || (itemInputs.size() > 0 && itemInputs1 == null)

+				|| (fluidInputs1 != null && fluidInputs.size() > fluidInputs1.size())

+				|| (itemInputs1 != null && itemInputs.size() > itemInputs1.size());

+	}

+}