+ Gave Fission Fuels their own NEI handler, which allows 9 input fluids.

% Moved Fission Fuel recipe map to it's own class, specially for the NEI handler.

^ Updated CodeChickenCore-1.7.10-1.0.6.44-dev.jar to CodeChickenCore-1.7.10-1.0.7.47-dev.jar.
^ Updated CodeChickenLib-1.7.10-1.1.3.136-dev.jar to CodeChickenLib-1.7.10-1.1.3.140-dev.jar.
^ Updated NotEnoughItems-1.7.10-1.0.4.107-dev.jar to NotEnoughItems-1.7.10-1.0.5.120-dev.jar.

1 files changed, 263 insertions, 0 deletions

diff --git a/src/Java/gregtech/api/util/CustomRecipeMap.java b/src/Java/gregtech/api/util/CustomRecipeMap.java
new file mode 100644
index 0000000000..3434239ca7
--- /dev/null
+++ b/src/Java/gregtech/api/util/CustomRecipeMap.java
@@ -0,0 +1,263 @@
+package gregtech.api.util;
+
+import static gregtech.api.enums.GT_Values.*;
+import gregtech.api.GregTech_API;
+import gregtech.api.interfaces.tileentity.IHasWorldObjectAndCoords;
+import gregtech.api.objects.GT_ItemStack;
+
+import java.util.*;
+
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+
+public class CustomRecipeMap/* extends GT_Recipe_Map*/{
+        /**
+         * Contains all Recipe Maps
+         */
+        public static final Collection<CustomRecipeMap> sMappings = new ArrayList<CustomRecipeMap>();
+
+        //public static final CustomRecipeMap sOreWasherRecipes = new GT_Recipe_Map_OreWasher(new HashSet<GT_Recipe>(0), "ic.recipe.orewasher", "Ore Washer", "ic2.blockOreWashingPlant", RES_PATH_GUI + "basicmachines/OreWasher", 1, 3, 1, 1, 1, E, 1, E, true, false);
+      //Fission Fuel Plant Recipes
+      	public static final CustomRecipeMap sFissionFuelProcessing = new CustomRecipeMap(new HashSet<GT_Recipe>(50), "gt.recipe.fissionfuel", "Fission Fuel Processing", null, RES_PATH_GUI + "basicmachines/LFTR", 0, 0, 0, 9, 1, E, 1, E, true, true);
+      		
+        /**
+         * HashMap of Recipes based on their Items
+         */
+        public final Map<GT_ItemStack, Collection<GT_Recipe>> mRecipeItemMap = new HashMap<GT_ItemStack, Collection<GT_Recipe>>();
+        /**
+         * HashMap of Recipes based on their Fluids
+         */
+        public final Map<Fluid, Collection<GT_Recipe>> mRecipeFluidMap = new HashMap<Fluid, Collection<GT_Recipe>>();
+        /**
+         * The List of all Recipes
+         */
+        public final Collection<GT_Recipe> mRecipeList;
+        /**
+         * String used as an unlocalised Name.
+         */
+        public final String mUnlocalizedName;
+        /**
+         * String used in NEI for the Recipe Lists. If null it will use the unlocalised Name instead
+         */
+        public final String mNEIName;
+        /**
+         * GUI used for NEI Display. Usually the GUI of the Machine itself
+         */
+        public final String mNEIGUIPath;
+        public final String mNEISpecialValuePre, mNEISpecialValuePost;
+        public final int mUsualInputCount, mUsualOutputCount, mNEISpecialValueMultiplier, mMinimalInputItems, mMinimalInputFluids, mAmperage;
+        public final boolean mNEIAllowed, mShowVoltageAmperageInNEI;
+
+        /**
+         * Initialises a new type of Recipe Handler.
+         *
+         * @param aRecipeList                a List you specify as Recipe List. Usually just an ArrayList with a pre-initialised Size.
+         * @param aUnlocalizedName           the unlocalised Name of this Recipe Handler, used mainly for NEI.
+         * @param aLocalName                 the displayed Name inside the NEI Recipe GUI.
+         * @param aNEIGUIPath                the displayed GUI Texture, usually just a Machine GUI. Auto-Attaches ".png" if forgotten.
+         * @param aUsualInputCount           the usual amount of Input Slots this Recipe Class has.
+         * @param aUsualOutputCount          the usual amount of Output Slots this Recipe Class has.
+         * @param aNEISpecialValuePre        the String in front of the Special Value in NEI.
+         * @param aNEISpecialValueMultiplier the Value the Special Value is getting Multiplied with before displaying
+         * @param aNEISpecialValuePost       the String after the Special Value. Usually for a Unit or something.
+         * @param aNEIAllowed                if NEI is allowed to display this Recipe Handler in general.
+         */
+        public CustomRecipeMap(Collection<GT_Recipe> aRecipeList, String aUnlocalizedName, String aLocalName, String aNEIName, String aNEIGUIPath, int aUsualInputCount, int aUsualOutputCount, int aMinimalInputItems, int aMinimalInputFluids, int aAmperage, String aNEISpecialValuePre, int aNEISpecialValueMultiplier, String aNEISpecialValuePost, boolean aShowVoltageAmperageInNEI, boolean aNEIAllowed) {
+            //super(aRecipeList, aUnlocalizedName, aLocalName, aNEIName, aNEIGUIPath, aUsualInputCount, aUsualOutputCount, aMinimalInputItems, aMinimalInputFluids, aAmperage, aNEISpecialValuePre, aNEISpecialValueMultiplier, aNEISpecialValuePost, aShowVoltageAmperageInNEI, aNEIAllowed);
+        	sMappings.add(this);
+            mNEIAllowed = aNEIAllowed;
+            mShowVoltageAmperageInNEI = aShowVoltageAmperageInNEI;
+            mRecipeList = aRecipeList;
+            mNEIName = aNEIName == null ? aUnlocalizedName : aNEIName;
+            mNEIGUIPath = aNEIGUIPath.endsWith(".png") ? aNEIGUIPath : aNEIGUIPath + ".png";
+            mNEISpecialValuePre = aNEISpecialValuePre;
+            mNEISpecialValueMultiplier = aNEISpecialValueMultiplier;
+            mNEISpecialValuePost = aNEISpecialValuePost;
+            mAmperage = aAmperage;
+            mUsualInputCount = aUsualInputCount;
+            mUsualOutputCount = aUsualOutputCount;
+            mMinimalInputItems = aMinimalInputItems;
+            mMinimalInputFluids = aMinimalInputFluids;
+            GregTech_API.sFluidMappings.add(mRecipeFluidMap);
+            GregTech_API.sItemStackMappings.add(mRecipeItemMap);
+            GT_LanguageManager.addStringLocalization(mUnlocalizedName = aUnlocalizedName, aLocalName);
+        }
+
+        public GT_Recipe addRecipe(boolean aOptimize, ItemStack[] aInputs, ItemStack[] aOutputs, Object aSpecial, int[] aOutputChances, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, int aDuration, int aEUt, int aSpecialValue) {
+            return addRecipe(new GT_Recipe(aOptimize, aInputs, aOutputs, aSpecial, aOutputChances, aFluidInputs, aFluidOutputs, aDuration, aEUt, aSpecialValue));
+        }
+
+        public GT_Recipe addRecipe(int[] aOutputChances, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, int aDuration, int aEUt, int aSpecialValue) {
+            return addRecipe(new GT_Recipe(false, null, null, null, aOutputChances, aFluidInputs, aFluidOutputs, aDuration, aEUt, aSpecialValue), false, false, false);
+        }
+
+        public GT_Recipe addRecipe(boolean aOptimize, ItemStack[] aInputs, ItemStack[] aOutputs, Object aSpecial, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, int aDuration, int aEUt, int aSpecialValue) {
+            return addRecipe(new GT_Recipe(aOptimize, aInputs, aOutputs, aSpecial, null, aFluidInputs, aFluidOutputs, aDuration, aEUt, aSpecialValue));
+        }
+
+        public GT_Recipe addRecipe(GT_Recipe aRecipe) {
+            return addRecipe(aRecipe, true, false, false);
+        }
+
+        protected GT_Recipe addRecipe(GT_Recipe aRecipe, boolean aCheckForCollisions, boolean aFakeRecipe, boolean aHidden) {
+            aRecipe.mHidden = aHidden;
+            aRecipe.mFakeRecipe = aFakeRecipe;
+            if (aRecipe.mFluidInputs.length < mMinimalInputFluids && aRecipe.mInputs.length < mMinimalInputItems)
+                return null;
+            if (aCheckForCollisions && findRecipe(null, false, Long.MAX_VALUE, aRecipe.mFluidInputs, aRecipe.mInputs) != null)
+                return null;
+            return add(aRecipe);
+        }
+
+        /**
+         * Only used for fake Recipe Handlers to show something in NEI, do not use this for adding actual Recipes! findRecipe wont find fake Recipes, containsInput WILL find fake Recipes
+         */
+        public GT_Recipe addFakeRecipe(boolean aCheckForCollisions, ItemStack[] aInputs, ItemStack[] aOutputs, Object aSpecial, int[] aOutputChances, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, int aDuration, int aEUt, int aSpecialValue) {
+            return addFakeRecipe(aCheckForCollisions, new GT_Recipe(false, aInputs, aOutputs, aSpecial, aOutputChances, aFluidInputs, aFluidOutputs, aDuration, aEUt, aSpecialValue));
+        }
+
+        /**
+         * Only used for fake Recipe Handlers to show something in NEI, do not use this for adding actual Recipes! findRecipe wont find fake Recipes, containsInput WILL find fake Recipes
+         */
+        public GT_Recipe addFakeRecipe(boolean aCheckForCollisions, ItemStack[] aInputs, ItemStack[] aOutputs, Object aSpecial, FluidStack[] aFluidInputs, FluidStack[] aFluidOutputs, int aDuration, int aEUt, int aSpecialValue) {
+            return addFakeRecipe(aCheckForCollisions, new GT_Recipe(false, aInputs, aOutputs, aSpecial, null, aFluidInputs, aFluidOutputs, aDuration, aEUt, aSpecialValue));
+        }
+
+        /**
+         * Only used for fake Recipe Handlers to show something in NEI, do not use this for adding actual Recipes! findRecipe wont find fake Recipes, containsInput WILL find fake Recipes
+         */
+        public GT_Recipe addFakeRecipe(boolean aCheckForCollisions, GT_Recipe aRecipe) {
+            return addRecipe(aRecipe, aCheckForCollisions, true, false);
+        }
+
+        public GT_Recipe add(GT_Recipe aRecipe) {
+            mRecipeList.add(aRecipe);
+            for (FluidStack aFluid : aRecipe.mFluidInputs)
+                if (aFluid != null) {
+                    Collection<GT_Recipe> tList = mRecipeFluidMap.get(aFluid.getFluid());
+                    if (tList == null) mRecipeFluidMap.put(aFluid.getFluid(), tList = new HashSet<GT_Recipe>(1));
+                    tList.add(aRecipe);
+                }
+            return addToItemMap(aRecipe);
+        }
+
+        public void reInit() {
+            Map<GT_ItemStack, Collection<GT_Recipe>> tMap = mRecipeItemMap;
+            if (tMap != null) tMap.clear();
+            for (GT_Recipe tRecipe : mRecipeList) {
+                GT_OreDictUnificator.setStackArray(true, tRecipe.mInputs);
+                GT_OreDictUnificator.setStackArray(true, tRecipe.mOutputs);
+                if (tMap != null) addToItemMap(tRecipe);
+            }
+        }
+
+        /**
+         * @return if this Item is a valid Input for any for the Recipes
+         */
+        public boolean containsInput(ItemStack aStack) {
+            return aStack != null && (mRecipeItemMap.containsKey(new GT_ItemStack(aStack)) || mRecipeItemMap.containsKey(new GT_ItemStack(GT_Utility.copyMetaData(W, aStack))));
+        }
+
+        /**
+         * @return if this Fluid is a valid Input for any for the Recipes
+         */
+        public boolean containsInput(FluidStack aFluid) {
+            return aFluid != null && containsInput(aFluid.getFluid());
+        }
+
+        /**
+         * @return if this Fluid is a valid Input for any for the Recipes
+         */
+        public boolean containsInput(Fluid aFluid) {
+            return aFluid != null && mRecipeFluidMap.containsKey(aFluid);
+        }
+
+        public GT_Recipe findRecipe(IHasWorldObjectAndCoords aTileEntity, boolean aNotUnificated, long aVoltage, FluidStack[] aFluids, ItemStack... aInputs) {
+            return findRecipe(aTileEntity, null, aNotUnificated, aVoltage, aFluids, null, aInputs);
+        }
+
+        public GT_Recipe findRecipe(IHasWorldObjectAndCoords aTileEntity, GT_Recipe aRecipe, boolean aNotUnificated, long aVoltage, FluidStack[] aFluids, ItemStack... aInputs) {
+            return findRecipe(aTileEntity, aRecipe, aNotUnificated, aVoltage, aFluids, null, aInputs);
+        }
+
+        /**
+         * finds a Recipe matching the aFluid and ItemStack Inputs.
+         *
+         * @param aTileEntity    an Object representing the current coordinates of the executing Block/Entity/Whatever. This may be null, especially during Startup.
+         * @param aRecipe        in case this is != null it will try to use this Recipe first when looking things up.
+         * @param aNotUnificated if this is T the Recipe searcher will unificate the ItemStack Inputs
+         * @param aVoltage       Voltage of the Machine or Long.MAX_VALUE if it has no Voltage
+         * @param aFluids        the Fluid Inputs
+         * @param aSpecialSlot   the content of the Special Slot, the regular Manager doesn't do anything with this, but some custom ones do.
+         * @param aInputs        the Item Inputs
+         * @return the Recipe it has found or null for no matching Recipe
+         */
+        public GT_Recipe findRecipe(IHasWorldObjectAndCoords aTileEntity, GT_Recipe aRecipe, boolean aNotUnificated, long aVoltage, FluidStack[] aFluids, ItemStack aSpecialSlot, ItemStack... aInputs) {
+            // No Recipes? Well, nothing to be found then.
+            if (mRecipeList.isEmpty()) return null;
+
+            // Some Recipe Classes require a certain amount of Inputs of certain kinds. Like "at least 1 Fluid + 1 Stack" or "at least 2 Stacks" before they start searching for Recipes.
+            // This improves Performance massively, especially if people leave things like Circuits, Molds or Shapes in their Machines to select Sub Recipes.
+            if (GregTech_API.sPostloadFinished) {
+                if (mMinimalInputFluids > 0) {
+                    if (aFluids == null) return null;
+                    int tAmount = 0;
+                    for (FluidStack aFluid : aFluids) if (aFluid != null) tAmount++;
+                    if (tAmount < mMinimalInputFluids) return null;
+                }
+                if (mMinimalInputItems > 0) {
+                    if (aInputs == null) return null;
+                    int tAmount = 0;
+                    for (ItemStack aInput : aInputs) if (aInput != null) tAmount++;
+                    if (tAmount < mMinimalInputItems) return null;
+                }
+            }
+
+            // Unification happens here in case the Input isn't already unificated.
+            if (aNotUnificated) aInputs = GT_OreDictUnificator.getStackArray(true, (Object[]) aInputs);
+
+            // Check the Recipe which has been used last time in order to not have to search for it again, if possible.
+            if (aRecipe != null)
+                if (!aRecipe.mFakeRecipe && aRecipe.mCanBeBuffered && aRecipe.isRecipeInputEqual(false, true, aFluids, aInputs))
+                    return aRecipe.mEnabled && aVoltage * mAmperage >= aRecipe.mEUt ? aRecipe : null;
+
+            // Now look for the Recipes inside the Item HashMaps, but only when the Recipes usually have Items.
+            if (mUsualInputCount > 0 && aInputs != null) for (ItemStack tStack : aInputs)
+                if (tStack != null) {
+                    Collection<GT_Recipe>
+                            tRecipes = mRecipeItemMap.get(new GT_ItemStack(tStack));
+                    if (tRecipes != null) for (GT_Recipe tRecipe : tRecipes)
+                        if (!tRecipe.mFakeRecipe && tRecipe.isRecipeInputEqual(false, true, aFluids, aInputs))
+                            return tRecipe.mEnabled && aVoltage * mAmperage >= tRecipe.mEUt ? tRecipe : null;
+                    tRecipes = mRecipeItemMap.get(new GT_ItemStack(GT_Utility.copyMetaData(W, tStack)));
+                    if (tRecipes != null) for (GT_Recipe tRecipe : tRecipes)
+                        if (!tRecipe.mFakeRecipe && tRecipe.isRecipeInputEqual(false, true, aFluids, aInputs))
+                            return tRecipe.mEnabled && aVoltage * mAmperage >= tRecipe.mEUt ? tRecipe : null;
+                }
+
+            // If the minimal Amount of Items for the Recipe is 0, then it could be a Fluid-Only Recipe, so check that Map too.
+            if (mMinimalInputItems == 0 && aFluids != null) for (FluidStack aFluid : aFluids)
+                if (aFluid != null) {
+                    Collection<GT_Recipe>
+                            tRecipes = mRecipeFluidMap.get(aFluid.getFluid());
+                    if (tRecipes != null) for (GT_Recipe tRecipe : tRecipes)
+                        if (!tRecipe.mFakeRecipe && tRecipe.isRecipeInputEqual(false, true, aFluids, aInputs))
+                            return tRecipe.mEnabled && aVoltage * mAmperage >= tRecipe.mEUt ? tRecipe : null;
+                }
+
+            // And nothing has been found.
+            return null;
+        }
+
+        protected GT_Recipe addToItemMap(GT_Recipe aRecipe) {
+            for (ItemStack aStack : aRecipe.mInputs)
+                if (aStack != null) {
+                    GT_ItemStack tStack = new GT_ItemStack(aStack);
+                    Collection<GT_Recipe> tList = mRecipeItemMap.get(tStack);
+                    if (tList == null) mRecipeItemMap.put(tStack, tList = new HashSet<GT_Recipe>(1));
+                    tList.add(aRecipe);
+                }
+            return aRecipe;
+        }
+    }
\ No newline at end of file