diff options
Diffstat (limited to 'src/main/java/gtPlusPlus/plugin')
16 files changed, 2568 insertions, 0 deletions
diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java b/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java new file mode 100644 index 0000000000..890a9020c9 --- /dev/null +++ b/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeDefinition.java @@ -0,0 +1,49 @@ +package gtPlusPlus.plugin.agrichem; + +public enum AlgaeDefinition { + + /* + * In general, the productivity of freshwater algae is primarily limited by the availability of the nutrient + * phosphate (PO4-3), while that of marine algae is limited by nitrate (NO3-) or ammonium (NH4+). Some algal + * species, however, may have unusual nutrient requirements, and their productivity may be limited by certain + * micronutrients, such as silica, in the case of diatoms. + */ + + Euglenophyta("Euglenophyta", "Euglenoids", true, false, getRGB(147, 168, 50)), + Chrysophyta("Chrysophyta", "Golden-Brown Algae", true, true, getRGB(186, 146, 0)), + Pyrrophyta("Pyrrophyta", "Fire Algae", true, true, getRGB(250, 118, 2)), + Chlorophyta("Chlorophyta", "Green Algae", true, true, getRGB(99, 181, 62)), + Rhodophyta("Rhodophyta", "Red Algae", false, true, getRGB(153, 5, 22)), + Paeophyta("Paeophyta", "Brown Algae", false, true, getRGB(94, 78, 47)), + Xanthophyta("Xanthophyta", "Yellow-Green Algae", true, false, getRGB(118, 138, 16)); + + public final String mScientificName; + public final String mSimpleName; + public final boolean mSaltWater; + public final boolean mFreshWater; + public final int mColour; + + AlgaeDefinition(String aScientificName, String aSimpleName, boolean aFresh, boolean aSalt, int aColour) { + mScientificName = aScientificName; + mSimpleName = aSimpleName; + mFreshWater = aFresh; + mSaltWater = aSalt; + mColour = aColour; + } + + public static AlgaeDefinition getByIndex(int aIndex) { + return switch (aIndex) { + default -> Euglenophyta; + case 1 -> Chrysophyta; + case 2 -> Pyrrophyta; + case 3 -> Chlorophyta; + case 4 -> Rhodophyta; + case 5 -> Paeophyta; + case 6 -> Xanthophyta; + }; + } + + private static int getRGB(int r, int g, int b) { + return AlgaeUtils.rgbtoHexValue(r, g, b); + } +} diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java b/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java new file mode 100644 index 0000000000..4906d0483f --- /dev/null +++ b/src/main/java/gtPlusPlus/plugin/agrichem/AlgaeUtils.java @@ -0,0 +1,10 @@ +package gtPlusPlus.plugin.agrichem; + +import gtPlusPlus.core.util.Utils; + +public class AlgaeUtils { + + public static int rgbtoHexValue(final int r, final int g, final int b) { + return Utils.rgbtoHexValue(r, g, b); + } +} diff --git a/src/main/java/gtPlusPlus/plugin/agrichem/BioRecipes.java b/src/main/java/gtPlusPlus/plugin/agrichem/BioRecipes.java new file mode 100644 index 0000000000..a4bbd6e03a --- /dev/null +++ b/src/main/java/gtPlusPlus/plugin/agrichem/BioRecipes.java @@ -0,0 +1,1257 @@ +package gtPlusPlus.plugin.agrichem; + +import static gregtech.api.enums.Mods.Forestry; +import static gregtech.api.enums.Mods.Railcraft; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.distilleryRecipes; +import static gregtech.api.recipe.RecipeMaps.extractorRecipes; +import static gregtech.api.recipe.RecipeMaps.extruderRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes; +import static gregtech.api.recipe.RecipeMaps.latheRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.recipe.RecipeMaps.multiblockChemicalReactorRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT; +import static gregtech.api.util.GT_RecipeConstants.FUEL_TYPE; +import static gregtech.api.util.GT_RecipeConstants.FUEL_VALUE; +import static gregtech.api.util.GT_RecipeConstants.UniversalChemical; +import static gtPlusPlus.api.recipe.GTPPRecipeMaps.chemicalDehydratorRecipes; +import static gtPlusPlus.api.recipe.GTPPRecipeMaps.chemicalPlantRecipes; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; + +import net.minecraft.enchantment.Enchantment; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.objects.GT_ItemStack; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeConstants; +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.core.item.ModItems; +import gtPlusPlus.core.item.base.BaseItemComponent; +import gtPlusPlus.core.item.chemistry.AgriculturalChem; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.material.ALLOY; +import gtPlusPlus.core.material.MISC_MATERIALS; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.minecraft.FluidUtils; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.MaterialUtils; +import gtPlusPlus.core.util.minecraft.OreDictUtils; +import gtPlusPlus.core.util.minecraft.RecipeUtils; +import gtPlusPlus.core.util.reflect.ReflectionUtils; +import gtPlusPlus.plugin.agrichem.block.AgrichemFluids; +import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; +import gtPlusPlus.xmod.railcraft.utils.RailcraftUtils; +import ic2.core.Ic2Items; + +public class BioRecipes { + + private static Item mFert; + private static Item mDustDirt; + + private static Fluid mSalineWater; + private static Fluid mDistilledWater; + private static Fluid mThermalWater; + private static Fluid mAir; + private static Fluid mSulfuricWasteWater; + private static Fluid mAmmonia; + private static Fluid mMethanol; + private static Fluid mAceticAcid; + private static Fluid mPropionicAcid; + private static Fluid mLiquidPlastic; + private static Fluid mFermentationBase; + private static Fluid mCarbonDioxide; + private static Fluid mCarbonMonoxide; + private static Fluid mEthylene; + private static Fluid mEthanol; + private static Fluid mChlorine; + private static Fluid mHydrogen; + private static Fluid mDilutedSulfuricAcid; + private static Fluid mSulfuricAcid; + private static Fluid mUrea; + public static Fluid mFormaldehyde; + private static Fluid mLiquidResin; + private static Fluid mMethane; + private static Fluid mBenzene; + private static Fluid mEthylbenzene; + private static Fluid mStyrene; + private static Fluid mButanol; + private static Fluid mAcetone; + + private static ItemStack getGreenAlgaeRecipeChip() { + return getBioChip(4); + } + + private static ItemStack getBrownAlgaeRecipeChip() { + return getBioChip(8); + } + + private static ItemStack getGoldenBrownAlgaeRecipeChip() { + return getBioChip(12); + } + + private static ItemStack getRedAlgaeRecipeChip() { + return getBioChip(16); + } + + private static ItemStack getBioChip(int aID) { + return ItemUtils.simpleMetaStack(AgriculturalChem.mBioCircuit, aID, 0); + } + + public static void init() { + Logger.INFO("[Bio] Setting Variables"); + initRecipeVars(); + Logger.INFO("[Bio] Generating Biochip Recipes"); + recipeBioChip(); + Logger.INFO("[Bio] Generating Recipes"); + recipeAlgaeBiomass(); + Logger.INFO("[Bio] Finished with recipes"); + } + + private static void initRecipeVars() { + mFert = AgriculturalChem.dustOrganicFertilizer; + mDustDirt = AgriculturalChem.dustDirt; + + // 5.08 Salt Water Solution ;) + if (!FluidUtils.doesFluidExist("saltwater")) { + mSalineWater = FluidUtils + .generateFluidNoPrefix("saltwater", "Salt Water", 200, new short[] { 10, 30, 220, 100 }); + } else { + Materials aSaltWater = MaterialUtils.getMaterial("saltwater"); + if (aSaltWater != null) { + FluidStack aWaterStack = aSaltWater.getFluid(1); + if (aWaterStack != null) { + mSalineWater = aSaltWater.getFluid(1) + .getFluid(); + } + } + if (mSalineWater == null) { + mSalineWater = FluidUtils.getWildcardFluidStack("saltwater", 1) + .getFluid(); + } + if (ItemUtils.getItemStackOfAmountFromOreDictNoBroken("cellSaltWater", 1) == null) { + new BaseItemComponent("saltwater", "Salt Water", new short[] { 10, 30, 220 }); + } + } + + mDistilledWater = FluidUtils.getDistilledWater(1) + .getFluid(); + mThermalWater = FluidUtils.getFluidStack("ic2hotwater", 1) + .getFluid(); + mAir = FluidUtils.getFluidStack("air", 1) + .getFluid(); + mSulfuricWasteWater = FluidUtils.getFluidStack("sulfuricapatite", 1) + .getFluid(); + mAmmonia = MISC_MATERIALS.AMMONIA.getFluidStack(1) + .getFluid(); + mEthylene = FluidUtils.getFluidStack("ethylene", 1) + .getFluid(); + mEthanol = FluidUtils.getFluidStack("bioethanol", 1) + .getFluid(); + mDilutedSulfuricAcid = FluidUtils.getFluidStack("dilutedsulfuricacid", 1) + .getFluid(); + mSulfuricAcid = FluidUtils.getFluidStack("sulfuricacid", 1) + .getFluid(); + mFormaldehyde = FluidUtils.getFluidStack("fluid.formaldehyde", 1) + .getFluid(); + mMethane = FluidUtils.getFluidStack("methane", 1) + .getFluid(); + mBenzene = FluidUtils.getFluidStack("benzene", 1) + .getFluid(); + mEthylbenzene = FluidUtils.getFluidStack("fluid.ethylbenzene", 1) + .getFluid(); + mStyrene = FluidUtils.getFluidStack("styrene", 1) + .getFluid(); + mMethanol = FluidUtils.getFluidStack("methanol", 1) + .getFluid(); + mLiquidPlastic = FluidUtils.getWildcardFluidStack("plastic", 1) + .getFluid(); + mCarbonDioxide = MISC_MATERIALS.CARBON_DIOXIDE.getFluidStack(1) + .getFluid(); + mCarbonMonoxide = MISC_MATERIALS.CARBON_MONOXIDE.getFluidStack(1) + .getFluid(); + mChlorine = FluidUtils.getFluidStack("chlorine", 1) + .getFluid(); + mHydrogen = FluidUtils.getFluidStack("hydrogen", 1) + .getFluid(); + mAceticAcid = AgrichemFluids.mAceticAcid; + mPropionicAcid = AgrichemFluids.mPropionicAcid; + mUrea = AgrichemFluids.mUrea; + mLiquidResin = AgrichemFluids.mLiquidResin; + mFermentationBase = AgrichemFluids.mFermentationBase; + mButanol = AgrichemFluids.mButanol; + mAcetone = AgrichemFluids.mAcetone; + } + + private static void recipeAlgaeBiomass() { + + // TODO + // Add in recipes to get initial Biomass + + recipeGreenAlgae(); + recipeBrownAlgae(); + recipeGoldenBrownAlgae(); + recipeRedAlgae(); + recipeWoodPellets(); + recipeWoodBricks(); + recipeCellulosePulp(); + recipeCatalystCarrier(); + recipeAluminiumSilverCatalyst(); + recipeAceticAcid(); + recipePropionicAcid(); + recipeFermentationBase(); + recipeEthanol(); + recipeCelluloseFibre(); + recipeGoldenBrownCelluloseFiber(); + recipeRedCelluloseFiber(); + recipeSodiumHydroxide(); + recipeSodiumCarbonate(); + recipePelletMold(); + recipeAluminiumPellet(); + recipeAlumina(); + recipeAluminium(); + recipeLithiumChloride(); + recipeSulfuricAcid(); + recipeUrea(); + recipeRawBioResin(); + recipeLiquidResin(); + recipeCompost(); + recipeMethane(); + recipeBenzene(); + recipeStyrene(); + registerFuels(); + } + + private static void registerFuels() { + + // Burnables + ItemUtils.registerFuel(ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), 800); + ItemUtils.registerFuel(ItemUtils.getSimpleStack(AgriculturalChem.mWoodBrick, 1), 4800); + + // Combustion Fuels + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getItemStackOfAmountFromOreDict("cellButanol", 1)) + .metadata(FUEL_VALUE, 400) + .metadata(FUEL_TYPE, 0) + .duration(0) + .eut(0) + .addTo(GT_RecipeConstants.Fuel); + } + + private static void recipeGreenAlgae() { + // Compost + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 4)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + // Turn into Cellulose + GT_Values.RA.stdBuilder() + .itemInputs(getGreenAlgaeRecipeChip(), ItemUtils.getSimpleStack(AgriculturalChem.mGreenAlgaeBiosmass, 10)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 5)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(16) + .addTo(assemblerRecipes); + } + + private static void recipeBrownAlgae() { + // Compost + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 2)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + // Alginic acid + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 10)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mAlginicAcid, 2)) + .duration(2 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(extractorRecipes); + + // Lithium Chloride + GT_Values.RA.stdBuilder() + .itemInputs(getBrownAlgaeRecipeChip(), ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 20)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mLithiumChloride, 5)) + .duration(6 * SECONDS) + .eut(TierEU.RECIPE_MV) + .metadata(COIL_HEAT, 1200) + .addTo(blastFurnaceRecipes); + + // Sodium Carbonate + GT_Values.RA.stdBuilder() + .itemInputs(getBrownAlgaeRecipeChip(), ItemUtils.getSimpleStack(AgriculturalChem.mBrownAlgaeBiosmass, 40)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mSodiumCarbonate, 20)) + .fluidInputs(FluidUtils.getDistilledWater(2000)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + } + + private static void recipeGoldenBrownAlgae() { + // Compost + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, 1)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + // Turn into Cellulose + GT_Values.RA.stdBuilder() + .itemInputs( + getGoldenBrownAlgaeRecipeChip(), + ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownAlgaeBiosmass, 10)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 5)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + } + + private static void recipeRedAlgae() { + // Compost + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, 1)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 2)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + // Turn into Cellulose + GT_Values.RA.stdBuilder() + .itemInputs(getRedAlgaeRecipeChip(), ItemUtils.getSimpleStack(AgriculturalChem.mRedAlgaeBiosmass, 10)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mRedCelluloseFiber, 5)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_HV / 2) + .addTo(assemblerRecipes); + } + + private static void recipeCelluloseFibre() { + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 8), + ItemUtils.getSimpleStack(AgriculturalChem.mAlginicAcid, 2)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCellulosePulp, 10)) + .duration(10 * SECONDS) + .eut(16) + .addTo(UniversalChemical); + + // Craft into Wood Pellets + GT_Values.RA.stdBuilder() + .itemInputs(getBioChip(2), ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 12)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 24)) + .duration(2 * SECONDS + 8 * TICKS) + .eut(8) + .addTo(assemblerRecipes); + + // Methanol Extraction + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 12)) + .fluidOutputs(Materials.Methanol.getFluid(1000L)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_LV) + .addTo(fluidExtractionRecipes); + + // Compost + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 3)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 1)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + // Plastic + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(16), ItemUtils.getSimpleStack(AgriculturalChem.mCellulosePulp, 4), }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mAceticAcid, 500), + FluidUtils.getFluidStack(BioRecipes.mPropionicAcid, 500), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mLiquidPlastic, (1000)), }, + 10 * 20, + 240, + 2); + } + + private static void recipeWoodPellets() { + // Shapeless Recipe + RecipeUtils.addShapelessGregtechRecipe( + new ItemStack[] { ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1), + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1) }, + ItemUtils.getSimpleStack(AgriculturalChem.mWoodBrick, 2)); + + // Extruder Recipe + GT_Values.RA.stdBuilder() + .itemInputs( + ItemUtils.getSimpleStack(AgriculturalChem.mCelluloseFiber, 12), + ItemUtils.getSimpleStack(AgriculturalChem.mPelletMold, 0)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 3)) + .duration(10 * SECONDS) + .eut(16) + .addTo(extruderRecipes); + + // Assembly Recipe + GT_Values.RA.stdBuilder() + .itemInputs(getBioChip(2), ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 8)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mWoodBrick, 2)) + .duration(5 * SECONDS) + .eut(8) + .addTo(assemblerRecipes); + + // CO2 + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 1)) + .fluidOutputs(FluidUtils.getFluidStack(mCarbonDioxide, 70)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(fluidExtractionRecipes); + + // Add Charcoal Recipe + if (Railcraft.isModLoaded()) { + RailcraftUtils.addCokeOvenRecipe( + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 2), + true, + true, + ItemUtils.getItemStackOfAmountFromOreDict("gemCharcoal", 3), + GT_Values.NF, + 1200); + } + CORE.RA.addCokeOvenRecipe( + ItemUtils.getSimpleStack(AgriculturalChem.mWoodPellet, 2), + getBioChip(3), + null, + GT_Values.NF, + ItemUtils.getItemStackOfAmountFromOreDict("gemCharcoal", 3), + 120, + 16); + } + + private static void recipeWoodBricks() { + + // Assembler Recipe + GT_Values.RA.stdBuilder() + .itemInputs(getBioChip(3), ItemUtils.getOrePrefixStack(OrePrefixes.dust, Materials.Wood, 50)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mWoodBrick, 1)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + } + + private static void recipeCellulosePulp() { + + // Assembler Recipe + GT_Values.RA.stdBuilder() + .itemInputs(getBioChip(2), ItemUtils.getSimpleStack(AgriculturalChem.mCellulosePulp, 4)) + .itemOutputs(ItemUtils.getSimpleStack(Items.paper, 4)) + .duration(2 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + } + + private static void recipeCatalystCarrier() { + // Assembler Recipe + GT_Values.RA.stdBuilder() + .itemInputs( + getBioChip(20), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Steel, 8L), + GT_OreDictUnificator.get(OrePrefixes.wireFine, Materials.Copper, 4L), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Tin, 6L)) + .itemOutputs(CI.getEmptyCatalyst(1)) + .duration(5 * MINUTES) + .eut(16) + .addTo(assemblerRecipes); + } + + private static void recipeAluminiumSilverCatalyst() { + // Assembler Recipe + GT_Values.RA.stdBuilder() + .itemInputs( + getBioChip(4), + CI.getEmptyCatalyst(10), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Aluminium, 4L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Silver, 4L)) + .itemOutputs(CI.getGreenCatalyst(10)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + } + + private static void recipeAceticAcid() { + + // CH4O + CO = C2H4O2 + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { CI.getGreenCatalyst(0) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mMethanol, 700), + FluidUtils.getFluidStack(BioRecipes.mCarbonMonoxide, 700), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mAceticAcid, 700), }, + 120 * 20, + 60, + 1); + + GT_Values.RA.stdBuilder() + .itemInputs(CI.getNumberedBioCircuit(14)) + .fluidInputs(FluidUtils.getFluidStack(mFermentationBase, 1000)) + .fluidOutputs(FluidUtils.getFluidStack(mAceticAcid, 1000)) + .itemOutputs(ItemUtils.getSimpleStack(AgriculturalChem.mCompost, 2)) + .duration(60 * SECONDS) + .eut(16) + .noOptimize() + .addTo(chemicalDehydratorRecipes); + } + + public static final HashSet<GT_ItemStack> mFruits = new HashSet<>(); + public static final HashSet<GT_ItemStack> mVege = new HashSet<>(); + public static final HashSet<GT_ItemStack> mNuts = new HashSet<>(); + public static final HashSet<GT_ItemStack> mSeeds = new HashSet<>(); + + public static final AutoMap<ItemStack> mList_Master_FruitVege = new AutoMap<>(); + public static final AutoMap<ItemStack> mList_Master_Seeds = new AutoMap<>(); + + private static void processFermentationOreDict() { + processOreDictEntry("listAllfruit", mFruits); + processOreDictEntry("listAllFruit", mFruits); + processOreDictEntry("listAllveggie", mVege); + processOreDictEntry("listAllVeggie", mVege); + processOreDictEntry("listAllnut", mNuts); + processOreDictEntry("listAllNut", mNuts); + processOreDictEntry("listAllseed", mSeeds); + processOreDictEntry("listAllSeed", mSeeds); + + if (!mFruits.isEmpty()) { + for (GT_ItemStack g : mFruits) { + mList_Master_FruitVege.put(g.toStack()); + } + } + if (!mVege.isEmpty()) { + for (GT_ItemStack g : mVege) { + mList_Master_FruitVege.put(g.toStack()); + } + } + if (!mNuts.isEmpty()) { + for (GT_ItemStack g : mNuts) { + mList_Master_FruitVege.put(g.toStack()); + } + } + if (!mSeeds.isEmpty()) { + for (GT_ItemStack g : mSeeds) { + mList_Master_Seeds.put(g.toStack()); + } + } + } + + // Make Fermentation + private static void processOreDictEntry(String aOreName, HashSet<GT_ItemStack> mfruits2) { + ArrayList<ItemStack> aTemp = OreDictionary.getOres(aOreName); + if (!aTemp.isEmpty()) { + for (ItemStack stack : aTemp) { + mfruits2.add(new GT_ItemStack(stack)); + } + } + } + + private static void recipeFermentationBase() { + processFermentationOreDict(); + AutoMap<ItemStack> aFruitVege = mList_Master_FruitVege; + AutoMap<ItemStack> aSeeds = mList_Master_Seeds; + ArrayList<ItemStack> aMap = OreDictionary.getOres("cropSugarbeet"); + for (ItemStack a : aFruitVege) { + if (aMap.contains(a)) { + continue; + } + if (ItemUtils.checkForInvalidItems(a)) { + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(2), ItemUtils.getSimpleStack(a, 10) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 1000), }, + 30 * 20, + 2, + 0); + } + } + for (ItemStack a : aSeeds) { + if (ItemUtils.checkForInvalidItems(a)) { + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(3), ItemUtils.getSimpleStack(a, 20) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 1000), }, + 30 * 20, + 2, + 0); + } + } + + // Sugar Cane + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(4), ItemUtils.getSimpleStack(Items.reeds, 32) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 1000), }, + 30 * 20, + 30, + 0); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(5), ItemUtils.getSimpleStack(Items.reeds, 32), + ItemUtils.getSimpleStack(ModItems.dustCalciumCarbonate, 2) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mThermalWater, 2000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 2000), }, + 10 * 20, + 30, + 0); + + // Sugar Beet + if (OreDictUtils.containsValidEntries("cropSugarbeet")) { + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(4), ItemUtils.getItemStackOfAmountFromOreDict("cropSugarbeet", 4), }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 1000), }, + 30 * 20, + 30, + 0); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { getBioChip(5), ItemUtils.getItemStackOfAmountFromOreDict("cropSugarbeet", 4), + ItemUtils.getSimpleStack(ModItems.dustCalciumCarbonate, 2) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mThermalWater, 2000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 2000), }, + 10 * 20, + 30, + 0); + } + + // Produce Acetone, Butanol and Ethanol + GT_Values.RA.stdBuilder() + .itemInputs( + getBioChip(5), + ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 6), + ItemUtils.getSimpleStack(AgriculturalChem.mRedCelluloseFiber, 16)) + .fluidInputs(FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 48000)) + .fluidOutputs( + FluidUtils.getFluidStack(BioRecipes.mButanol, 18000), + FluidUtils.getFluidStack(BioRecipes.mAcetone, 9000), + FluidUtils.getFluidStack(BioRecipes.mEthanol, 3000)) + .duration(100 * SECONDS) + .eut(32) + .specialValue(1) + .noOptimize() + .addTo(chemicalPlantRecipes); + } + + private static void recipePropionicAcid() { + // C2H4 + CO + H2O = C3H6O2 + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { CI.getGreenCatalyst(0) }, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mEthylene, 1000), + FluidUtils.getFluidStack(BioRecipes.mCarbonMonoxide, 1000), + FluidUtils.getFluidStack(BioRecipes.mDistilledWater, 1000), }, + new ItemStack[] {}, + new FluidStack[] { FluidUtils.getFluidStack(BioRecipes.mPropionicAcid, 1000), }, + 10 * 20, + 60, + 1); + } + + private static void recipeEthanol() { + + GT_Values.RA.stdBuilder() + .itemInputs(BioRecipes.getBioChip(2)) + .fluidInputs(FluidUtils.getFluidStack(BioRecipes.mFermentationBase, 1000)) + .fluidOutputs(FluidUtils.getFluidStack(BioRecipes.mEthanol, 100)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_MV / 2) + .addTo(distilleryRecipes); + } + + private static void recipeGoldenBrownCelluloseFiber() { + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mGoldenBrownCelluloseFiber, 5)) + .fluidOutputs(Materials.Ammonia.getGas(500)) + .duration(15 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(fluidExtractionRecipes); + } + + private static void recipeRedCelluloseFiber() { + GT_Values.RA.stdBuilder() + .itemInputs(ItemUtils.getSimpleStack(AgriculturalChem.mRedCelluloseFiber, 3)) + .itemOutputs(ItemUtils.getSimpleStack(ModItems.dustCalciumCarbonate, 5)) + |