fix missing source folder

1 files changed, 562 insertions, 0 deletions

diff --git a/src/main/java/ihl/IHLModConfig.java b/src/main/java/ihl/IHLModConfig.java
new file mode 100644
index 0000000..6beddfe
--- /dev/null
+++ b/src/main/java/ihl/IHLModConfig.java
@@ -0,0 +1,562 @@
+package ihl;

+

+import java.io.BufferedWriter;

+import java.io.File;

+import java.io.FileInputStream;

+import java.io.FileOutputStream;

+import java.io.IOException;

+import java.io.InputStream;

+import java.io.InputStreamReader;

+import java.io.LineNumberReader;

+import java.io.OutputStreamWriter;

+import java.util.ArrayList;

+import java.util.Iterator;

+import java.util.List;

+import java.util.Map.Entry;

+

+import cpw.mods.fml.common.event.FMLPreInitializationEvent;

+import ic2.api.recipe.IRecipeInput;

+import ic2.api.recipe.RecipeInputFluidContainer;

+import ic2.api.recipe.RecipeInputItemStack;

+import ic2.api.recipe.RecipeInputOreDict;

+import ihl.flexible_cable.IronWorkbenchTileEntity;

+import ihl.recipes.IronWorkbenchRecipe;

+import ihl.recipes.RecipeInputDie;

+import ihl.recipes.RecipeInputWire;

+import ihl.recipes.RecipeOutputItemStack;

+import ihl.recipes.UniversalRecipeInput;

+import ihl.recipes.UniversalRecipeManager;

+import ihl.recipes.UniversalRecipeOutput;

+import ihl.utils.IHLUtils;

+import net.minecraft.item.ItemStack;

+import net.minecraft.nbt.NBTTagCompound;

+import net.minecraftforge.common.config.Configuration;

+import net.minecraftforge.fluids.FluidRegistry;

+import net.minecraftforge.fluids.FluidStack;

+

+public class IHLModConfig 

+{

+	public int explosionVectorSizeBits=7;

+	public int explosionPowerBase=100;

+	

+	public int handpumpTier=1;

+	public int handpumpMaxCharge=30000;

+	public int handpumpOperationEUCost=180;

+	

+	public int advancedHandpumpTier=3;

+	public int advancedHandpumpMaxCharge=1000000;

+	public int advancedHandpumpOperationEUCost=10000;

+

+	public int tditTier=4;

+	public int tditMaxEnergyStorage=12000;

+	public int tditEnergyConsumePerStack=12000;

+	

+	public boolean enableHandpump=true;

+	public boolean enableRubberTreeSack=true;

+	public boolean enableWailers=true;

+	public boolean enableTDIT=true;

+	

+	public boolean enableFlexibleCablesCrafting=true;

+	public boolean enableFlexibleCablesGridPowerLossCalculations=true;

+	public boolean generateApatiteOre=true;

+	public boolean generateSaltpeterOre=true;

+	public boolean generateLimestone=true;

+	public boolean generateGypsum=true;

+	public boolean generatePotassiumFeldspar=true;

+	public boolean generateTrona=true;

+	public boolean generateRocksalt=true;

+	public boolean generateCinnabar=true;

+	public boolean generateGyubnera=true;

+	public boolean generateBauxite=true;

+	public boolean generateChromite=true;

+	public boolean generateMuscovite=true;

+	public boolean generateOil=true;

+	public boolean generateDatolite=true;

+	public boolean generateSaltwater=true;

+	public boolean generateBischofite=true;

+	public int chanceOreWillNotBeGenerated = 100;

+	public int mirrorReflectionRange=14;

+	public int mirrorReflectionUpdateSpeed=128;

+	public String preventMachineBlockRegistrationName="null";

+	public boolean skipRecipeLoad=false;

+	public int machineryEnergyConsume=100;

+	public int maxCatalystUses = 1000;

+	

+	public IHLModConfig(FMLPreInitializationEvent evt) throws IOException

+	{

+		Configuration config = new Configuration(evt.getSuggestedConfigurationFile());

+		config.load();

+		skipRecipeLoad = config.get(Configuration.CATEGORY_GENERAL, "skipRecipeLoad", skipRecipeLoad).getBoolean(skipRecipeLoad);

+		preventMachineBlockRegistrationName = config.get(Configuration.CATEGORY_GENERAL, "preventMachineBlockRegistrationName", preventMachineBlockRegistrationName).getString();

+		enableHandpump = config.get(Configuration.CATEGORY_GENERAL, "enableHandpump", enableHandpump).getBoolean(enableHandpump);

+		enableRubberTreeSack = config.get(Configuration.CATEGORY_GENERAL, "enableRubberTreeSack", enableRubberTreeSack).getBoolean(enableRubberTreeSack);

+		enableWailers = config.get(Configuration.CATEGORY_GENERAL, "enableWailers", enableWailers).getBoolean(enableWailers);

+		enableTDIT = config.get(Configuration.CATEGORY_GENERAL, "enableTDIT", enableTDIT).getBoolean(enableTDIT);

+		

+		generateApatiteOre = config.get(Configuration.CATEGORY_GENERAL, "generateApatiteOre", generateApatiteOre).getBoolean(generateApatiteOre);

+		generateSaltpeterOre = config.get(Configuration.CATEGORY_GENERAL, "generateSaltpeterOre", generateSaltpeterOre).getBoolean(generateSaltpeterOre);

+		generateLimestone = config.get(Configuration.CATEGORY_GENERAL, "generateLimestone", generateLimestone).getBoolean(generateLimestone);

+		generateGypsum = config.get(Configuration.CATEGORY_GENERAL, "generateGypsum", generateGypsum).getBoolean(generateGypsum);

+		generatePotassiumFeldspar = config.get(Configuration.CATEGORY_GENERAL, "generatePotassiumFeldspar", generatePotassiumFeldspar).getBoolean(generatePotassiumFeldspar);

+		generateTrona = config.get(Configuration.CATEGORY_GENERAL, "generateTrona", generateTrona).getBoolean(generateTrona);

+		generateRocksalt = config.get(Configuration.CATEGORY_GENERAL, "generateRocksalt", generateRocksalt).getBoolean(generateRocksalt);

+		generateCinnabar = config.get(Configuration.CATEGORY_GENERAL, "generateCinnabar", generateCinnabar).getBoolean(generateCinnabar);

+		generateGyubnera = config.get(Configuration.CATEGORY_GENERAL, "generateGyubnera", generateGyubnera).getBoolean(generateGyubnera);

+		generateBauxite = config.get(Configuration.CATEGORY_GENERAL, "generateBauxite", generateBauxite).getBoolean(generateBauxite);

+		generateChromite = config.get(Configuration.CATEGORY_GENERAL, "generateChromite", generateChromite).getBoolean(generateChromite);

+		generateMuscovite = config.get(Configuration.CATEGORY_GENERAL, "generateMuscovite", generateMuscovite).getBoolean(generateMuscovite);

+		generateOil = config.get(Configuration.CATEGORY_GENERAL, "generateOil", generateOil).getBoolean(generateOil);

+		generateDatolite = config.get(Configuration.CATEGORY_GENERAL, "generateDatolite", generateDatolite).getBoolean(generateDatolite);

+		generateSaltwater = config.get(Configuration.CATEGORY_GENERAL, "generateSaltwater", generateSaltwater).getBoolean(generateSaltwater);

+		generateBischofite = config.get(Configuration.CATEGORY_GENERAL, "generateBischofite", generateBischofite).getBoolean(generateBischofite);

+		

+		handpumpTier = config.get(Configuration.CATEGORY_GENERAL, "handpumpTier", handpumpTier).getInt();

+		handpumpMaxCharge = config.get(Configuration.CATEGORY_GENERAL, "handpumpMaxCharge", handpumpMaxCharge).getInt();

+		handpumpOperationEUCost = config.get(Configuration.CATEGORY_GENERAL, "handpumpOperationEUCost", handpumpOperationEUCost).getInt();

+		advancedHandpumpTier = config.get(Configuration.CATEGORY_GENERAL, "advancedHandpumpTier", advancedHandpumpTier).getInt();

+		advancedHandpumpMaxCharge = config.get(Configuration.CATEGORY_GENERAL, "advancedHandpumpMaxCharge", advancedHandpumpMaxCharge).getInt();

+		advancedHandpumpOperationEUCost = config.get(Configuration.CATEGORY_GENERAL, "advancedHandpumpOperationEUCost", advancedHandpumpOperationEUCost).getInt();

+		

+		tditTier = config.get(Configuration.CATEGORY_GENERAL, "tditTier", tditTier).getInt();

+		tditMaxEnergyStorage = config.get(Configuration.CATEGORY_GENERAL, "tditMaxEnergyStorage", tditMaxEnergyStorage).getInt();

+		tditEnergyConsumePerStack = config.get(Configuration.CATEGORY_GENERAL, "tditEnergyConsumePerStack", tditEnergyConsumePerStack).getInt();

+			

+		enableFlexibleCablesGridPowerLossCalculations = config.get(Configuration.CATEGORY_GENERAL, "enableFlexibleCablesGridPowerLossCalculations", enableFlexibleCablesGridPowerLossCalculations).getBoolean(enableFlexibleCablesGridPowerLossCalculations);

+		enableFlexibleCablesCrafting = config.get(Configuration.CATEGORY_GENERAL, "enableFlexibleCablesCrafting", enableFlexibleCablesCrafting).getBoolean(enableFlexibleCablesCrafting);

+		mirrorReflectionRange = config.get(Configuration.CATEGORY_GENERAL, "mirrorReflectionRange", mirrorReflectionRange).getInt();

+		mirrorReflectionUpdateSpeed = config.get(Configuration.CATEGORY_GENERAL, "mirrorReflectionUpdateSpeed", mirrorReflectionUpdateSpeed).getInt();

+		

+		explosionVectorSizeBits = config.get(Configuration.CATEGORY_GENERAL, "explosionVectorSizeBits", explosionVectorSizeBits).getInt();

+		explosionPowerBase = config.get(Configuration.CATEGORY_GENERAL, "explosionPowerBase", explosionPowerBase).getInt();

+		chanceOreWillNotBeGenerated = config.get(Configuration.CATEGORY_GENERAL, "chanceOreWillNotBeGenerated", chanceOreWillNotBeGenerated).getInt();

+		

+		maxCatalystUses = config.get(Configuration.CATEGORY_GENERAL, "maxCatalystUses", maxCatalystUses).getInt();

+		machineryEnergyConsume  = config.get(Configuration.CATEGORY_GENERAL, "machineryEnergyConsume", machineryEnergyConsume).getInt();

+		config.save();

+	}

+	

+	private void loadRecipeConfig(InputStream resourceAsStream, boolean rewriteConfig) throws IOException 

+	{

+		OutputStreamWriter osWriter = null;

+		BufferedWriter writer = null;

+		if(rewriteConfig)

+		{

+        	osWriter = new OutputStreamWriter(new FileOutputStream(getFile()), "UTF-8");

+			writer = new BufferedWriter(osWriter);

+		}

+        InputStreamReader isReader = new InputStreamReader(resourceAsStream, "UTF-8");

+        LineNumberReader reader = new LineNumberReader(isReader);

+        String line;

+        StringBuffer currentModificator = new StringBuffer("");

+        int bracketCounter=0;

+        boolean modificatorStart=false;

+		while ((line = reader.readLine()) != null)

+        {

+			if(osWriter!=null)

+			{

+				writer.newLine();

+				writer.append(line);

+			}

+            line = IHLUtils.trim(line);

+            if (!line.isEmpty() && !line.startsWith("//") && !line.startsWith(";"))

+            {

+            	currentModificator.append(line);

+            	for(int i=0;i<line.length();i++)

+            	{

+            		char c = line.charAt(i);

+            		if(c=='(')

+            		{

+            	        bracketCounter++;

+            	        modificatorStart=true;

+            		}

+            		else if(c==')')

+            		{

+            	        bracketCounter--;

+            		}

+            		if(bracketCounter==0 && modificatorStart)

+            		{

+            			processModificator(currentModificator.toString());

+            			modificatorStart=false;

+            			currentModificator.delete(0, currentModificator.length());

+            		}

+            	}

+            }

+        }

+		isReader.close();

+		if(osWriter!=null)

+		{

+			writer.newLine();

+			writer.newLine();

+			writer.append("//Available machines:");

+			writer.newLine();

+			writer.append("//ironworkbench");

+			Iterator<Entry<String, UniversalRecipeManager>> urmi = UniversalRecipeManager.machineRecipeManagers.entrySet().iterator();

+			while(urmi.hasNext())

+			{

+				writer.newLine();

+				writer.append("//"+urmi.next().getKey());

+			}

+			writer.close();

+	        osWriter.close();

+		}

+	}

+		

+	    private void processModificator(String string) 

+	    {

+	    	String action = null;

+	    	String machineName = null;

+	    	String recipeInput = null;

+	    	String recipeOutput = null;

+	    	UniversalRecipeInput uRecipeInput = null;

+	    	UniversalRecipeOutput uRecipeOutput = null;

+	    	String[] functionAndParameters = extractFunctionAndParameters(string);

+	    	action=functionAndParameters[0].toLowerCase();

+	    	List<String> parameters = splitParameters(functionAndParameters[1]);

+	    	Iterator<String> parametersi=parameters.iterator();

+	    	while(parametersi.hasNext())

+	    	{

+	    		String parameter = parametersi.next();

+	    		if(parameter.equalsIgnoreCase("ironworkbench"))

+	    		{

+	    			machineName=parameter;

+	    		}

+	    		else if(UniversalRecipeManager.machineRecipeManagers.containsKey(parameter))

+	    		{

+	    			machineName=parameter;

+	    		}

+	    		else if(parameter.startsWith("recipeinput"))

+	    		{

+	    			recipeInput=parameter;

+	    		}

+	    		else if(parameter.startsWith("recipeoutput"))

+	    		{

+	    			recipeOutput=parameter;

+	    		}

+	    	}

+    		List<IRecipeInput> recipeInputsItems = new ArrayList<IRecipeInput>();

+    		List<IRecipeInput> recipeInputsTools = new ArrayList<IRecipeInput>();

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

+	    	if(recipeInput!=null)

+	    	{

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

+		    	String[] rifunctionAndParameters = extractFunctionAndParameters(recipeInput);

+		    	List<String> riparameters = splitParameters(rifunctionAndParameters[1]);

+		    	Iterator<String> riparametersi=riparameters.iterator();

+		    	while(riparametersi.hasNext())

+		    	{

+		    		String parameter = riparametersi.next();

+			    	String[] riItemFunctionAndParameters = extractFunctionAndParameters(parameter);

+			    	if(riItemFunctionAndParameters[0].startsWith("itemstack"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	String[] modAndItemName = riItemStackparameters.get(0).split(":");

+				    	int iDamage = 0;

+				    	int iQuantity = Integer.parseInt(riItemStackparameters.get(1));

+				    	String sDamage = riItemStackparameters.get(2);

+				    	if(sDamage.startsWith("hash"))

+				    	{

+				    		iDamage=extractFunctionAndParameters(sDamage)[1].hashCode() & Integer.MAX_VALUE;

+				    	}

+				    	else

+				    	{

+				    		iDamage=Integer.parseInt(sDamage);

+				    	}

+				    	recipeInputsItems.add(new RecipeInputItemStack(IHLUtils.getOtherModItemStackWithDamage(modAndItemName[0], modAndItemName[1], iDamage, iQuantity),iQuantity));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("die"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	recipeInputsItems.add(new RecipeInputDie("setOfDies1_5sqmm", Integer.parseInt(riItemStackparameters.get(0))));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("fiber"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	ItemStack stack = IHLUtils.getThisModWireItemStackWithLength(riItemStackparameters.get(0), Integer.parseInt(riItemStackparameters.get(1)));

+				    	recipeInputsItems.add(new RecipeInputWire(stack, Integer.parseInt(riItemStackparameters.get(1))));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("wire"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	recipeInputsItems.add(new RecipeInputWire(riItemStackparameters.get(0), Integer.parseInt(riItemStackparameters.get(1)), Integer.parseInt(riItemStackparameters.get(2))));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("cable"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	recipeInputsItems.add(new RecipeInputWire(riItemStackparameters.get(0), Integer.parseInt(riItemStackparameters.get(1)), Integer.parseInt(riItemStackparameters.get(2)),riItemStackparameters.get(3),Integer.parseInt(riItemStackparameters.get(4)),Integer.parseInt(riItemStackparameters.get(5))));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("oredict"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	recipeInputsItems.add(new RecipeInputOreDict(riItemStackparameters.get(0),Integer.parseInt(riItemStackparameters.get(1))));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("fluidcontainer"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	recipeInputsItems.add(new RecipeInputFluidContainer(FluidRegistry.getFluid(riItemStackparameters.get(0)),Integer.parseInt(riItemStackparameters.get(1))));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("toolitemstack"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	String[] modAndItemName = riItemStackparameters.get(0).split(":");

+				    	ItemStack stack = IHLUtils.getOtherModItemStackWithDamage(modAndItemName[0], modAndItemName[1], Integer.parseInt(riItemStackparameters.get(2)), Integer.parseInt(riItemStackparameters.get(1)));

+					    stack.stackTagCompound = new NBTTagCompound();

+					    NBTTagCompound gtTagCompound = new NBTTagCompound();

+					    gtTagCompound.setInteger("Damage",0);

+					    gtTagCompound.setInteger("MaxDamage",2000);

+					    stack.stackTagCompound.setTag("GT.ToolStats", gtTagCompound);

+				    	recipeInputsTools.add(new RecipeInputItemStack(stack,stack.stackSize));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("tooloredict"))

+			    	{

+				    	recipeInputsTools.add(new RecipeInputOreDict(splitParameters(riItemFunctionAndParameters[1]).get(0)));

+				    	

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("machine"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	String[] modAndItemName = riItemStackparameters.get(0).split(":");

+				    	recipeInputsMachines.add(IHLUtils.getThisModItemStack(modAndItemName[1]));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("fluidstack"))

+			    	{

+				    	List<String> riFluidStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	recipeInputsFluids.add(IHLUtils.getFluidStackWithSize(riFluidStackparameters.get(0),Integer.parseInt(riFluidStackparameters.get(1))));

+			    	}

+		    	}

+		    	uRecipeInput = new UniversalRecipeInput(recipeInputsFluids.toArray(),recipeInputsItems.toArray());

+	    	}

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

+    		List<RecipeOutputItemStack> recipeOutputsRecipeOut = new ArrayList<RecipeOutputItemStack>();

+	    	if(recipeOutput!=null)

+	    	{

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

+		    	String[] rifunctionAndParameters = extractFunctionAndParameters(recipeOutput);

+		    	List<String> riparameters = splitParameters(rifunctionAndParameters[1]);

+		    	Iterator<String> riparametersi=riparameters.iterator();

+		    	while(riparametersi.hasNext())

+		    	{

+		    		String parameter = riparametersi.next();

+			    	String[] riItemFunctionAndParameters = extractFunctionAndParameters(parameter);

+			    	if(riItemFunctionAndParameters[0].startsWith("itemstack"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	String[] modAndItemName = riItemStackparameters.get(0).split(":");

+				    	String sDamage = riItemStackparameters.get(2);

+				    	int iDamage = 0;

+				    	if(sDamage.startsWith("hash"))

+				    	{

+				    		iDamage=extractFunctionAndParameters(sDamage)[1].hashCode() & Integer.MAX_VALUE;

+				    	}

+				    	else

+				    	{

+				    		iDamage=Integer.parseInt(sDamage);

+				    	}

+				    	ItemStack stack = IHLUtils.getOtherModItemStackWithDamage(modAndItemName[0], modAndItemName[1], iDamage,Integer.parseInt(riItemStackparameters.get(1)));

+			    		if(stack==null)

+			    		{

+			    			throw new java.lang.IllegalArgumentException("Item not found: "+parameter);

+			    		}

+				    	if(riItemStackparameters.size()>3){

+				    		stack.stackTagCompound = new NBTTagCompound();

+				    		String[] fp = extractFunctionAndParameters(riItemStackparameters.get(3));

+				    		Iterator<String> iparams2 = splitParameters(fp[1]).iterator();

+				    		while(iparams2.hasNext()){

+					    		decodeNBT(iparams2.next(), stack.stackTagCompound);

+				    		}

+				    	}

+				    	recipeOutputsItems.add(stack);

+				    	recipeOutputsRecipeOut.add(new RecipeOutputItemStack(stack.copy(),Float.parseFloat(riItemStackparameters.get(1))));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("fiber"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	recipeOutputsItems.add(IHLUtils.getThisModWireItemStackWithLength(riItemStackparameters.get(0), Integer.parseInt(riItemStackparameters.get(1))));

+				    	recipeOutputsRecipeOut.add(new RecipeOutputItemStack(IHLUtils.getThisModWireItemStackWithLength(riItemStackparameters.get(0), Integer.parseInt(riItemStackparameters.get(1))),1));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("wire"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	recipeOutputsItems.add(IHLUtils.getUninsulatedWire(riItemStackparameters.get(0), Integer.parseInt(riItemStackparameters.get(1)), Integer.parseInt(riItemStackparameters.get(2))));

+				    	recipeOutputsRecipeOut.add(new RecipeOutputItemStack(IHLUtils.getUninsulatedWire(riItemStackparameters.get(0), Integer.parseInt(riItemStackparameters.get(1)), Integer.parseInt(riItemStackparameters.get(2))),1));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("cable"))

+			    	{

+				    	List<String> riItemStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	recipeOutputsItems.add(IHLUtils.getInsulatedWire(riItemStackparameters.get(0), Integer.parseInt(riItemStackparameters.get(1)), Integer.parseInt(riItemStackparameters.get(2)),riItemStackparameters.get(3),Integer.parseInt(riItemStackparameters.get(4))));

+				    	recipeOutputsRecipeOut.add(new RecipeOutputItemStack(IHLUtils.getInsulatedWire(riItemStackparameters.get(0), Integer.parseInt(riItemStackparameters.get(1)), Integer.parseInt(riItemStackparameters.get(2)),riItemStackparameters.get(3),Integer.parseInt(riItemStackparameters.get(4))),1));

+			    	}

+			    	else if(riItemFunctionAndParameters[0].startsWith("fluidstack"))

+			    	{

+				    	List<String> riFluidStackparameters = splitParameters(riItemFunctionAndParameters[1]);

+				    	recipeOutputsFluids.add(IHLUtils.getFluidStackWithSize(riFluidStackparameters.get(0),Integer.parseInt(riFluidStackparameters.get(1))));

+			    	}

+		    	}

+		    	uRecipeOutput = new UniversalRecipeOutput(recipeOutputsFluids,recipeOutputsRecipeOut, 200);

+	    	}

+    		if(action.equalsIgnoreCase("addrecipe"))

+    		{

+    			if(machineName.equalsIgnoreCase("ironworkbench"))

+    			{

+    				IronWorkbenchTileEntity.addRecipe(new IronWorkbenchRecipe(recipeInputsTools,recipeInputsItems, recipeOutputsItems, recipeInputsMachines));

+    			}

+    			else

+    			{

+    				UniversalRecipeManager.machineRecipeManagers.get(machineName).addRecipe(uRecipeInput, uRecipeOutput);

+    			}

+    		}

+    		else if(action.equalsIgnoreCase("addcasting"))

+    		{

+    			IHLMod.moltenAmounts.put(parameters.get(0),Integer.parseInt(parameters.get(1)));

+    		}

+    		else if(action.equalsIgnoreCase("removerecipe"))

+    		{

+    			if(machineName.equalsIgnoreCase("ironworkbench"))

+    			{

+    				if(recipeInputsTools.isEmpty() && recipeInputsItems.isEmpty() && recipeInputsMachines.isEmpty())

+    				{

+        				IronWorkbenchTileEntity.removeRecipeByOutput(recipeOutputsItems);

+    				}

+    				else

+    				{

+        				IronWorkbenchTileEntity.removeRecipeByInput(recipeInputsTools,recipeInputsItems, recipeInputsMachines);

+    				}

+    			}

+    			else

+    			{

+    				if(uRecipeInput==null)

+    				{

+    					UniversalRecipeManager.machineRecipeManagers.get(machineName).removeRecipeByOutput(uRecipeOutput);

+    				}

+    				else

+    				{

+    					UniversalRecipeManager.machineRecipeManagers.get(machineName).removeRecipeByInput(uRecipeInput);

+    				}

+    			}

+    		}

+	    }

+

+	private void decodeNBT(String string, NBTTagCompound out) {

+		String[] fp = extractFunctionAndParameters(string);

+		List<String> params = splitParameters(fp[1]);

+		if(fp[0].equalsIgnoreCase("string")){

+			out.setString(params.get(0), params.get(1));

+		}

+		else if(fp[0].equalsIgnoreCase("boolean")){

+			out.setBoolean(params.get(0), Boolean.getBoolean(params.get(1)));

+		}

+		else if(fp[0].equalsIgnoreCase("float")){

+			out.setFloat(params.get(0), Float.parseFloat(params.get(1)));

+		}

+		else if(fp[0].equalsIgnoreCase("double")){

+			out.setDouble(params.get(0), Double.parseDouble(params.get(1)));

+		}

+		else if(fp[0].equalsIgnoreCase("integer")){

+			out.setInteger(params.get(0), Integer.parseInt(params.get(1)));

+		}

+		else if(fp[0].equalsIgnoreCase("long")){

+			out.setLong(params.get(0), Long.parseLong(params.get(1)));

+		}

+		else if(fp[0].equalsIgnoreCase("nbt")){

+			NBTTagCompound out2 = new NBTTagCompound();

+			for(int i = 1; i <  params.size(); i++){

+				decodeNBT(params.get(i), out2);

+			}

+			out.setTag(params.get(0), out2);

+		}

+	}

+	

+	

+

+	private List<String> splitParameters(String string) {

+		ArrayList<String> result = new ArrayList<String>();

+	        int bracketCounter=0;

+	        boolean modificatorStart=false;

+	        StringBuffer currentModificator = new StringBuffer("");

+           	for(int i=0;i<string.length();i++)

+           	{

+           		char c = string.charAt(i);

+           		if(c==',')

+           		{

+	           	        if(!modificatorStart) {

+	           	        	result.add(currentModificator.toString());

+	               			currentModificator.delete(0, currentModificator.length());

+	           	        }

+           		} else if(c=='(') {

+	           	        bracketCounter++;

+          			modificatorStart=true;

+           		} else if(c==')') {

+           		        bracketCounter--;

+           		}

+           		if(bracketCounter==0 && modificatorStart) {

+          			modificatorStart=false;

+           		}

+       	        	if(c!=',' || modificatorStart) {

+               			currentModificator.append(c);

+       	        	}

+           	}

+        	result.add(currentModificator.toString());

+			return result;

+	}

+

+	private String[] extractFunctionAndParameters(String string) {

+	        int bracketCounter=0;

+	        boolean modificatorStart=false;

+	        String function = null;

+	        String parameters = null;

+	        StringBuffer currentModificator = new StringBuffer("");

+           	for(int i=0;i<string.length();i++)

+           	{

+           		char c = string.charAt(i);

+           		if(c=='(')

+           		{

+           	        bracketCounter++;

+           	        if(!modificatorStart)

+           	        {

+           	        	function=currentModificator.toString();

+               			currentModificator.delete(0, currentModificator.length());

+               			modificatorStart=true;

+           	        }

+           		}

+           		else if(c==')')

+           		{

+           	        bracketCounter--;

+           		}

+           		if(bracketCounter==0 && modificatorStart)

+           		{

+       	        	parameters=currentModificator.substring(1, currentModificator.length());

+       	        	break;

+           		}

+           		currentModificator.append(c);

+           	}

+			return new String[] {function,parameters};

+		}

+

+

+	private void loadRecipeConfig(File configFile) throws IOException 

+	{

+        FileInputStream is = new FileInputStream(configFile);

+        loadRecipeConfig(is, false);

+	}

+

+    private static File getFile()

+    {

+        File folder = new File(IHLMod.proxy.getMinecraftDir(), "config");

+        folder.mkdirs();

+        return new File(folder, "ihl-recipe.cfg");

+    }

+

+	public void loadRecipeModificators() throws IOException 

+	{

+        File configFile = getFile();

+        if (configFile.exists())

+        {

+            loadRecipeConfig(configFile);

+        }

+        else

+        {

+        	InputStream inputStream = IHLMod.class.getResourceAsStream("/assets/ihl/config/ihl-recipe.cfg");

+        	loadRecipeConfig(inputStream, true);

+        }

+

+	}

+}