IRecipeHandler

"This Article is Locked because all information on this page is official if you would like to make an edit to this page please message me about the change you'd like to make, including an example if it is reasonably possible and I will get back to you."

Documentation for the IRecipeHandler Class which is usually referenced in instances from RecipeManager. This is the main class that actually handles all of the recipes made using this mod. This page is incomplete at the moment but should be finished here in the next few days with a little luck.

= Sub Class Methods =

=addRecipe:=

This method creates an instance of a sub-class containing methods that can be used to add a recipe to the recipe handler.

void addSimpleRecipe(String Mod, String RecipeID, ItemStack Input, Itemstack Output, float Exp), addSimpleOreRecipe(String Mod, String RecipeID, String Input, ItemStack Output, float Exp)
addSimpleRecipe(...) and addSimpleOreRecipe(...) are used to add a recipe that has 1 input and 1 output to the recipe handler.

In this mod each recipe is represented by an ID, consisting of a mod ID (Mod), that may or may not match the mod's mod ID depending on the modder's decision, and a ID for the recipe it self that must be different for each recipe the mod adds to the handler(RecipeID). If a mod attempts to add 2 recipes using the same mod ID(Mod) and recipe ID(RecipeID) no recipe will be added. Such instances will be recorded in the error log as a "[RecipeHandler][Error at IRecipehandler.addRecipe] dupiclicate recipe ID {Mod, RecipeID} skipping the dupilcate instance".

The Input for addSimpleRecipe(...) should be an ItemStack containing the input item used in the recipe.

The Input for addSimpleOreRecipe(...) should be a String containing a  Minecraft Forge Ore Dictionary reference. A Ore Dictionary reference is the String used to add an ItemStack to the Ore Dictionary. If there is no ItemStack registerd int the Ore Dictionary using the String the recipe will be un-useable. Full documentation on the Minecraft Fore Ore Dictionary can be found here, and a list of comon Ore Dictionary references can be found here.

The Output for these methods should always be a ItemStack containg the output ItemStack that will be produced using the recipe

The Exp for these methods should all ways be a float indicating the amount of exp to be rewarded or used for the recipe. ==void addRecipe(String Mod, String ID, ArrayList Input, ArrayList Output, ArrayListPower, ArrayList Power Type, float Exp), addRecipe(String[] ID, ItemStack[] Input, ItemStack[] Output, int[] Power, String[] PowerType, float Exp)== addRecipe(...) is used for adding un-shaped recipes that use more then 1 input and/or output.

In this mod each recipe is represented by an ID, consisting of a mod ID (Mod), that may or may not match the mod's mod ID depending on the modder's decision, and a ID for the recipe it self that must be different for each recipe the mod adds to the handler(RecipeID). When specifying the ID as a String[] you should make sure the String[] has at most a length of 2 consisting of the Mod ID as [0] and RecipeID as [1]. If an ID String[] with a length of more then 2 is recived the String[] will be trimmed to the first 2 values which will be used as the Mod ID[0] and RecipeID[1]. If a mod attempts to add 2 recipes using the same mod ID(Mod) and recipe ID(RecipeID) no recipe will be added. Such instances will be recorded in the error log as a "[RecipeHandler][Error at IRecipehandler.addRecipe] dupiclicate recipe ID {Mod, RecipeID} skipping the dupilcate instance".

addRecipe(...) will accept an Input of ArrayList or ItemStack[] of ItemStacks that will be used as the inputs for the recipe

addRecipe(...) will accept an Output of ArrayList or ItemStack[] of ItemStacks that will be produced using the recipe.

addRecipe(...) allows the modder to add a power reuirement in the form of a set of ArrayList Power and ArrayList PowerType, or a set of int[] Power and String[] PowerType. Power is a list of power requirements that the recipe should use, and PowerType should be a list that listing the power requirement type for the  ArrayList Powe or int[] Power of the same index. The power type is typicaly used when multiple machines use the same recipe handler, such and example would be the Maecrator from IC2 and the Pulverizer from IC2 where though the do the same thing, and thus might use the same recipe handler, the recipes would require 2 diffrent power requirements which the machine would have to sort through.

addRecipe(...) will accept and Exp of float indicating the amount of experience to be rewared or used by a recipe ==void addOreRecipe(String Mod, String ID, ArrayList Input, ArrayList Output, ArrayListPower, ArrayList Power Type, float Exp), addOreRecipe(String[] ID, Object[] Input, ItemStack[] Output, int[] Power, String[] PowerType, float Exp)==

addOreRecipe(...) is used for adding un-shaped recipes using more them 1 input or output, with at least one of the inputs using the Minecraft Forge OreDictionary.

In this mod each recipe is represented by an ID, consisting of a mod ID (Mod), that may or may not match the mod's mod ID depending on the modder's decision, and a ID for the recipe it self that must be different for each recipe the mod adds to the handler(RecipeID). When specifying the ID as a String[] you should make sure the String[] has at most a length of 2 consisting of the Mod ID as [0] and RecipeID as [1]. If an ID String[] with a length of more then 2 is recived the String[] will be trimmed to the first 2 values which will be used as the Mod ID[0] and RecipeID[1]. If a mod attempts to add 2 recipes using the same mod ID(Mod) and recipe ID(RecipeID) no recipe will be added. Such instances will be recorded in the error log as a "[RecipeHandler][Error at IRecipehandler.addRecipe] dupiclicate recipe ID {Mod, RecipeID} skipping the duplicate instance".

addOreRecipe(...) will accept an Input of ArrayList or Object[] of ItemStacks and String references to the Minecraft Forge Ore Dictionary that will be used as the inputs for the recipe. An Ore Dictionary reference is the string that is used to add an ItemStack to the ore dictionary, as such a recipe will be useless if there is nothing has been registered in the Ore Dictionary using the string provided. Full documentation on the Minecraft Fore Ore Dictionary can be found here, and a list of common Ore Dictionary references can be found here.

addOreRecipe(...) will accept an Output of ArrayList or ItemStack[] of ItemStacks that will be produced using the recipe.

addOreRecipe(...) allows the modder to add a power requirement in the form of a set of ArrayList Power and ArrayList<String> PowerType, or a set of int[] Power and String[] PowerType. Power is a list of power requirements that the recipe should use, and PowerType should be a list that listing the power requirement type for the  ArrayList<Integer> Powe or int[] Power of the same index. The power type is typicaly used when multiple machines use the same recipe handler, such and example would be the Maecrator from IC2 and the Pulverizer from IC2 where though the do the same thing, and thus might use the same recipe handler, the recipes would require 2 different power requirements which the machine would have to sort through.

addOreRecipe(...) will accept an Exp of float indicating the amount of experience to be reward or used by a recipe

==void addShapedRecipe(String Mod, String ID, ArrayList<Object> Input, ArrayList<ItemStack> Output, ArrayList<Integer>Power, ArrayList<String> PowerType, float Exp, int Rows), addShapedRecipe(String[] ID, Object[] Input, ItemStack[] Output, int[] Power, String[] PowerType, float Exp, int Rows)== addShapedRecipe(...) is used for adding shaped recipes using more them 1 input.

In this mod each recipe is represented by an ID, consisting of a mod ID (Mod), that may or may not match the mod's mod ID depending on the modder's decision, and a ID for the recipe it self that must be different for each recipe the mod adds to the handler(RecipeID). When specifying the ID as a String[] you should make sure the String[] has at most a length of 2 consisting of the Mod ID as [0] and RecipeID as [1]. If an ID String[] with a length of more then 2 is received the String[] will be trimmed to the first 2 values which will be used as the Mod ID[0] and RecipeID[1]. If a mod attempts to add 2 recipes using the same mod ID(Mod) and recipe ID(RecipeID) no recipe will be added. Such instances will be recorded in the error log as a "[RecipeHandler][Error at IRecipehandler.addRecipe] duplicate recipe ID {Mod, RecipeID} skipping the duplicate instance".

addShapedRecipe(...) will accept an Input of ArrayList<Object> or Object[] of formating using Strings and ItemStacks that are acctualy used in the recipe. Shaped recipes should be used much the same way as adding a shaped crafting recipe for the Crafting Table. The first several entries in the ArrayList<Object> Input or Object[] Input should be Strings that "draw" the recipe using letters to indicate what kind of ItemStack should be required for the ItemStack in that position of that row. Following the Strings that "draw" the recipe, the ArrayList<Object> Input or Object[] Input should alternate between a 1 letter String (typicaly a letter used in "drawing "the recipe) and an ItemStack (typical the ItemStack represented by the letter in "drawing" the recipe).

addShapedRecipe(...) will accept an Output of ArrayList<ItemStack> or ItemStack[] of ItemStacks that will be produced using the recipe.

addShapedRecipe(...) allows the modder to add a power requirement in the form of a set of ArrayList<Integer> Power and ArrayList<String> PowerType, or a set of int[] Power and String[] PowerType. Power is a list of power requirements that the recipe should use, and PowerType should be a list that listing the power requirement type for the  ArrayList<Integer> Power or int[] Power of the same index. The power type is typically used when multiple machines use the same recipe handler, such and example would be the Macerator from IC2 and the Pulverizer from IC2 where though the do the same thing, and thus might use the same recipe handler, the recipes would require 2 different power requirements which the machine would have to sort through.

addShapedRecipe(...) will accept an Exp of float indicating the amount of experience to be rewarded or used by a recipe.

addShapedRecipe(...) will accept a Rows of int indicating how many rows there are in the recipe. This number should match the number of Strings used to "draw" the recipe.

Examples:
//adds a shaped recipe using an ArrayList<Object> public void arrayListShapedRecipe{ /* An ArrayList cannot be directly instantiated with variables without * adding a sub-list. To get around creating the sub-list you should first * make a       * List of the same type with the desired variables. * The List should be created by putting the formatting Strings for each * row first, then alternating between a letter identifier String and the * ItemStack the letter is identifying * Item.dyePowder is an item that holds vanilla dyes as sub-items which are * identified by the metadata value in the third column of new * ItemStack(...). 1 is Rose Red, 2 is Cactus Green, 4 is Lapis Lazuli, * 11 is Dandelion Yellow, 13 is Magenta Dye, 0 is Ink Sack(cobalt dye), * 15 is Bone Meal, 14 is Orange Dye*/*/ List<Object> tempInputList = Arrays.asList("rgb", "bgr", "grb", "ymcwo"          "r", new ItemStack(Item.dyePowder, 1, 1),           "g", new ItemStack(Item.dyePowder, 1, 2),           "b", new ItemStack(Item.dyePowder, 1, 4),           "y", new ItemStack(Item.dyePowder, 1, 11),           "m", new ItemStack(Item.dyePowder, 1, 13),           "c", new ItemStack(Item.dyePowder, 1, 0),           "w", new ItemStack(Item.dyePowder, 1, 15),           "o", nwe ItemStack(Item.dyePowder, 1, 14)      // Then instantiate your ArrayList      ArrayList<Object> inputs = new ArrayList<Object>;      /* Then use the addAll(Colletion c) function to add the elements of the      * ArrayList to the ArrayList. This will work since all java lists are      * actually a subclass of Collection, so addAll will accept a List as a      * Collection */      inputs.addAll(tempInputList);      /*Create an ArrayList<ItemStack> for your outputs, this can be done using * the same method as above or by adding ItemStacks as I am going to     * below since I      * am only using 1 output for this example. */     ArrayList<ItemStack> outputs = new ArrayList<ItemStack>; outputs.add(new ItemStack(Block.obsidian)); //Create the ArrayList<Integer>, and ArrayList<String> for power usage List<Integer> tempPower = Arrays.asList(200, 1200); List<String> tempPowerType = Arrays.asList("Buildcraft Power",           "IC2 Power"); ArrayList<Integer> power = new ArrayList<Integer>; ArrayList<String> powerType = new ArrayList<String>; power.addAll(tempPower); powerType.addAll(tempPowerType); /*add the recipe to the recipe handler. Additionaly you will need to      *provide the Mod String("ModID" as an example), RecipeID String("RecipeID"     * as an example), Exp float(10f as an example), and Rows int(4 in this       * case because we registered 4 rows of inputs "rgb", "bgr", "grb", and       * "ymcwo") */ if(RecipeManager.isRecipeHandler("NameOfRecipeHandler")){ RecipeManager.getRecipeHandler("NameOfRecipeHandler").addRecipe.addShapedRecipe("ModID", "RecipeID", inputs, outputs, power,          powerType, 10f, 4); } } //adds a shaped recipe using a Object[] public void arrayShapedRecipe{ /*adds the Mod(ModID in this example and RecipeID(RecipeID in this * example) to a String[] */     String[] id = new String[]{"ModID", "RecipeID"}      /*creates a Object[] with the formatting of each row at the beginning of       * the array, then alternating between a letter identifier the ItemStack       * being identified.      * Item.dyePowder is an item that holds vanilla dyes as sub-items which are      * identified by the metadata value in the third colomn of       * new ItemStack(...). 1 is Rose Red, 2 is Cactus Green, 4 is Lapis Lazuli,      * 11 is Dandelion Yellow, 13 is Magenta Dye, 0 is Ink Sack(cobalt dye),      * 15 is Bone Meal, 14 is Orange Dye*/      Object[] inputs = new Object[]{"rgb", "bgr", "grb", "ymcwo"           "r", new ItemStack(Item.dyePowder, 1, 1),           "g", new ItemStack(Item.dyePowder, 1, 2),           "b", new ItemStack(Item.dyePowder, 1, 4),           "y", new ItemStack(Item.dyePowder, 1, 11),           "m", new ItemStack(Item.dyePowder, 1, 13), "c", new ItemStack(Item.dyePowder, 1, 0), "w", new ItemStack(Item.dyePowder, 1, 15), "o", nwe ItemStack(Item.dyePowder, 1, 14) };     // creates a ItemStack[] for the outpust ItemStack[] outputs = new Object[]{new ItemStack(Block.obsidian)}; // creates a int[] and String[] for power usage int[] power = new int[]{200, 1200}; String[] powerType = new String[]{"Buildcraft Energy", "IC2 Energy"}; /*adds the recipe to the recipe handler, raw variables include the * Exp(10f for example) and number of rows(4 since there were 4 rows added     * "rgb", "bgr", "grb", * and "ymcwo"). */     if(RecipeManager.isRecipeHandler("NameOfRecipeHandler")){ RecipeManager.getRecipeHandler("NameOfRecipeHandler").addRecipe.addShapedRecipe(id, inputs, outputs, power,          powerType, 10f, 4); } }

==void addShapedOreRecipe(String Mod, String ID, ArrayList<Object> Input, ArrayList<ItemStack> Output, ArrayList<Integer>Power, ArrayList<String> PowerType, float Exp, int Rows), addShapedOreRecipe(String[] ID, Object[] Input, ItemStack[] Output, int[] Power, String[] PowerType, float Exp, int Rows)==

addShapedOreRecipe(...) is used for adding shaped recipes using more then 1 input, with at least 1 input being a Ore Dictionary reference String.

In this mod each recipe is represented by an ID, consisting of a mod ID (Mod), that may or may not match the mod's mod ID depending on the modder's decision, and a ID for the recipe it self that must be different for each recipe the mod adds to the handler(RecipeID). When specifying the ID as a String[] you should make sure the String[] has at most a length of 2 consisting of the Mod ID as [0] and RecipeID as [1]. If an ID String[] with a length of more then 2 is recived the String[] will be trimmed to the first 2 values which will be used as the Mod ID[0] and RecipeID[1]. If a mod attempts to add 2 recipes using the same mod ID(Mod) and recipe ID(RecipeID) no recipe will be added. Such instances will be recorded in the error log as a "[RecipeHandler][Error at IRecipehandler.addRecipe] dupiclicate recipe ID {Mod, RecipeID} skipping the dupilcate instance".

addShapedOreRecipe(...) will accept an Input of ArrayList<Object> or Object[] of formating using Strings with ItemStacks and Ore Dictionary reference Strings that are acctualy used in the recipe. Shaped recipes should be used much the same way as adding a shaped crafting recipe for the Crafting Table. The first several entries in the ArrayList<Object> Input or Object[] Input should be Strings that "draw" the recipe using letters to indicate what kind of ItemStack(s) should be required for the ItemStack or Ore Dictionary reference in that position of that row. Following the Strings that "draw" the recipe, the ArrayList<Object> Input or Object[] Input should alternate between a 1 letter String (typicaly a letter used in "drawing "the recipe) and an ItemStack or Minecraft Ore Dictionary reference (typicaly the ItemStack  or Minecraft Oredictionary represted by the preceeding letter in "drawing" the recipe). A Minecraft Ore Dictionary reference is the String used to add an ItemStack to the Ore Dictionary. Full documentation on the Minecraft Fore Ore Dictionary can be found here, and a list of common Ore Dictionary references can be found here.

addShapedOreRecipe(...) will accept an Output of ArrayList<ItemStack> or ItemStack[] of ItemStacks that will be produced using the recipe.

addShapedOreRecipe(...) allows the modder to add a power requirement in the form of a set of ArrayList<Integer> Power and ArrayList<String> PowerType, or a set of int[] Power and String[] PowerType. Power is a list of power requirements that the recipe should use, and PowerType should be a list that listing the power requirement type for the  ArrayList<Integer> Power or int[] Power of the same index. The power type is typically used when multiple machines use the same recipe handler, such and example would be the Macerator from IC2 and the Pulverizer from IC2 where though the do the same thing, and thus might use the same recipe handler, the recipes would require 2 different power requirements which the machine would have to sort through.

addShapedOreRecipe(...) will accept an Exp of float indicating the amount of experience to be rewarded or used by a recipe.

addShapedOreRecipe(...) will accept a Rows of int indicating how many rows there are in the recipe. This number should match the number of Strings used to "draw" the recipe.

Examples:
//adds a shaped ore recipe using an ArrayList<Object> public void arrayListShapedRecipe{ /* An ArrayList cannot be directly instantiated with variables without * adding a sub-list. To get around creating the sub-list you should first * make a       * List of the same type with the desired variables. * The List should be created by putting the formatting Strings for each * row first, then alternating between a letter identifier String and the * ItemStack the letter is identifying * Item.dyePowder is an item that holds vanilla dyes as sub-items which are * identified by the metadata value in the third colomn of new * ItemStack(...). 1 is Rose Red, 2 is Cactus Green, 4 is Lapis Lazuli, * 11 is Dendelion Yellow, 13 is Magenta Dye, 0 is Ink Sack(cobalt dye), * 15 is Bone Meal, 14 is Orange Dye*/*/ List<Object> tempInputList = Arrays.asList("rgb", "bgr", "grb", "ymswo"          "r", "dyeRed", "g", "dyeGreen", "b", "dyeBlue", "y", "dyeYellow",           "m", "dyeMagenta", "s", new ItemStack(Block.stone), "w", "dyeWhite",           "o", "dyeOrange"); // Then instantiate your ArrayList ArrayList<Object> inputs = new ArrayList<Object>; /* Then use the addAll(Colletion c) function to add the elements of the * ArrayList to the ArrayList. This will work since all java lists are * actually a subclass of Collection, so addAll will accept a List as a     * Collection */ inputs.addAll(tempInputList); /*Create an ArrayList<ItemStack> for your outputs, this can be done using * the same method as above or by adding ItemStacks as I am going to     * below since I      * am only using 1 output for this example. */     ArrayList<ItemStack> outputs = new ArrayList<ItemStack>; outputs.add(new ItemStack(Block.obsidian)); //Create the ArrayList<Integer>, and ArrayList<String> for power usage List<Integer> tempPower = Arrays.asList(200, 1200); List<String> tempPowerType = Arrays.asList("Buildcraft Power",           "IC2 Power"); ArrayList<Integer> power = new ArrayList<Integer>; ArrayList<String> powerType = new ArrayList<String>; power.addAll(tempPower); powerType.addAll(tempPowerType); /*add the recipe to the recipe handler. Additionaly you will need to      *provide the Mod String("ModID" as an example), RecipeID String("RecipeID"     * as an example), Exp float(10f as an example), and Rows int(4 in this       * case because we registered 4 rows of inputs "rgb", "bgr", "grb", and       * "ymcwo") */ if(RecipeManager.isRecipeHandler("NameOfRecipeHandler")){ RecipeManager.getRecipeHandler("NameOfRecipeHandler").addRecipe.addShapedRecipe("ModID", "RecipeID", inputs, outputs, power,          powerType, 10f, 4); } } //adds a shaped ore recipe using a Object[] public void arrayShapedRecipe{ /*adds the Mod(ModID in this example and RecipeID(RecipeID in this * example) to a String[] */     String[] id = new String[]{"ModID", "RecipeID"}      /*creates a Object[] with the formating of each row at the begining of       * the array, then alternating between a letter identifier the ItemStack       * being identified.      * Item.dyePowder is an item that holds vanilla dyes as sub-items which are      * identified by the metadata value in the third colomn of       * new ItemStack(...). 1 is Rose Red, 2 is Cactus Green, 4 is Lapis Lazuli,      * 11 is Dendelion Yellow, 13 is Magenta Dye, 0 is Ink Sack(cobalt dye),      * 15 is Bone Meal, 14 is Orange Dye*/      Object[] inputs = new Object[]{"rgb", "bgr", "grb", "ymcwo"           "r", "dyeRed", "g", "dyeGreen", "b", "dyeBlue", "y", "dyeYellow",           "m", "dyeMagenta", "s", new ItemStack(Block.stone), "w", "dyeWhite",           "o", "dyeOrange"};      // creates a ItemStack[] for the outpust ItemStack[] outputs = new Object[]{new ItemStack(Block.obsidian)}; // creats a int[] and String[] for power usage int[] power = new int[]{200, 1200}; String[] poweType = new String[]{"Buildcraft Energy", "IC2 Energy"}; /*adds the recipe to the recipe handler, raw variables include the * Exp(10f for example) and number of rows(4 since there were 4 rows added     * "rgb", "bgr", "grb", * and "ymcwo"). */     if(RecipeManager.isRecipeHandler("NameOfRecipeHandler")){ RecipeManager.getRecipeHandler("NameOfRecipeHandler").addRecipe.addShapedRecipe(id, inputs, outputs, power,          powerType, 10f, 4); } } ==void addCustomRecipe(ArrayList<Object> Inputs, String[] ID, boolean OreRecipe ArrayList<Object> PrimaryOutputs, ArrayList<Object> SecondaryOutputs, ArrayList<Integer> SecondaryOutputChance, ArrayList<Integer> Power, ArrayList<String>PowerType, float Exp, boolean Shaped, int Rows, ArrayList AdditionalInfo)==

addCustomRecipe(...) is used for adding a complex recipe to to the reacipe handler

Inputs will accept an ArrayList<Object> containing ItemStacks, and Strings if the recipe is an Ore Recipe and/or a Shaped Recipe. If the Recipe is a Shaped Recipe then the inputs must be formatted in the same way as other shaped recipe inputs. If a Shaped Recipe is improperly formatted, or if there is no registered ItemStack for an Ore Dictionary reference String then the recipe my be unusable.

ID is a String[] containing exactly 2 Strings the Mod ID of the recipe and the Recipe ID for the Recipe. If a String[] of more then 2 Strings is passed through all string accept the first 2 will be ignored.

OreRecipe is a boolean(true or false) telling the recipe whether or not it is an Ore Recipe.

SecondaryOutput !!!Right now you can only pull out ItemStacks from the SecondaryOutput this is a bug and will be fixed in the next release. Alternatively I may be rewriting how the outputs of a recipe work.

Shaped is boolean(true or false) telling the recipe whether or not it is a Shaped Recipe

Rows IF this is a shaped recipe, this should be the number of Rows in the crafting matrix. Otherwise this should be 0.

AdditionalInfo should be an ArrayList of 2 ArrayLists. The first ArrayList should be an ArrayList<String> with the string identifying each additional piece of information. The second ArrayList will contain the actual additional info.  Example:  a recipe that requires water from a tank might require the additional information of how much water to use. In the first list this information could be labled "Water Requirements", and in the second ArrayList could contain and int of how many mili buckets are required for the recipe.

=accessRecipes:= =check=

A subclass method that creates an instance of a sub-class with methods for checking whether or not there is a recipe in the handler containing certain elements.

boolean isRecipeFor(...)
isRecipeFor(...) checks if a recipe using the given Input(s) has been registered to the IRecipeHandler. This method will check both enabled recipes and recipes that are disabled due to recipe conflicts, or config options.

boolean isActiveRecipeFor(...)
isActiveRecipeFor checks if a recipe using the given Input(s) has been registered to the IRecipeHandler and is enabled for use. Recipes disabled due to recipe conflicts, or config options will be ignored when using this method.

boolean isOutput(...)
isOutput(...) checks if a recipe using the given Output(s) has been registered to the IRecipeHandler. This method will check both enabled recipes and recipes that are disabled due to recipe conflicts, or config options.

boolean isActiveOutput(...)
isActiveRecipeFor checks if a recipe using the given Output(s) has been registered to the IRecipeHandler and is enabled for use. Recipes disabled due to recipe conflicts, or config options will be ignored when using this method.

boolean isIDRegistered(...)
isIDRegistered(...) checks if a recipe with the given mod ID and recipe ID has been registered to the IRecipeHandler. This method will check both enabled recipes and recipes that are disabled due to recipe conflicts, or config options.

=get=

A subclass method that creates an instance of a sub-class with methods for retrieving recipe data from the recipe handler.

ArrayList<ItemStack> primaryOutput(...)
Returns the primary output(s) for the enabled recipe that uses the given Input(s). In the case that multiple recipes are registered and enabled using the given Input(s) the method will return the primary output(s) for the enabled recipe that was registered first. Additionally using the method on a primary output that dose not only use ItemStacks may result in an error.

ArrayList<Object> advPrimaryOutput(...)
This method works much the same way as primaryOutput(...) but will return an ArrayList<Object> as opposed to a ArrayList<ItemStack> avoiding errors cause by having non-ItemStack primary outputs.

ArrayList<ArrayList> secondaryOutput(...)
Returns the secondary outputs for the first registered and enabled recipe that uses the given Input(s) as 2 ArrayLists. The first ArrayList is an ArrayList<Integer> containing the chance that the secondary output of the same index will spawn, presumably the Integer chance out of 100. The second ArrayList is an ArrayList<Object> containing the secondary outputs. Since all of the outputs will be returned as Objects you will need to cast the outputs to the appropriate Object type(typically an ItemStack).

ArrayList<ArrayList> power(...)
Returns the power requirements for the first registered and enabled recipe that uses the given Input(s) as 2 ArrayLists. The first ArrayList is an ArrayList<String> that denotes the kind of power required for the power requirement of the same index. The second ArrayList is an ArrayList<Integer> list the different power requirements for the recipe.

float experience(...)
Returns the experience to be rewarded or used for the first registered and enabled recipe that uses the given Input(s).

ArrayList additionalInfo(...) or ArrayList<ArrayList> additionalInfo(...)
additionalInfo(...) returns all additional info for the first registered and enabled recipe that uses the given Input(s) as 2 ArrayLists. The first ArrayList is an ArrayList<String> denoting the what kind of additional Info is present at the given index. The second ArrayList is a generic ArrayList containing additional info about a recipe. As of right now some of the variations on the method only return a generic ArrayList instead of an ArrayList<ArrayList> as such you will either need to cast the ArrayLists that will be returned as Objects to ArrayLists or cast the main ArrayList to an ArrayList<ArrayList>. This will be fixed in the next release.

String[] activeID(...)
Returns the ID of the first registered and enabled recipe that uses the given Input(s) as a String[2]. String[0] is the Mod ID used to register the recipe. String[1] is the unique recipe ID of the recipe registered by the mod.

recipeList recipeFor(...)
Returns a copy of the recipeList instance containing the recipe information for the first registered and enabled recipe using the given Input(s).

ArrayList<recipeList> allRecipesFor(...)
Returns a ArrayList containing copies of the recipeList instances containing recipes that all use the given Input(s). Since these recipes all use the same Input(s) they are considered conflicting and thus only one of them will be enabled at any given time.

ArrayList<ArrayList> allRecipes
Returns all recipes registered in the IRecipeHandler as 2 ArrayLists. The first ArrayList is an ArrayList<String[]> containing the IDs of all recipes of the same index as a String[2], String[0] being the Mod ID, and String[1] being the Recipe ID. The second ArrayList is an ArrayList<recipeList> containing copies of each recipeList instance in the IRecipeHandler.

=editRecipes:=

void addPowerReq(...)
addPowerReq(...) adds a power requirement for the recipe of the given ID(String Mod(the Mod ID used to register the recipe), and String RecipeID(the Recipe ID used to register the recipe)).

Power is the amount of power required for the recipe. PowerType is the kind of power requirement being added.

Editor is who is making this edit to the recipe.