From 0908735fc15396f8313d7643e952c1f9ce124d53 Mon Sep 17 00:00:00 2001 From: Alkalus Date: Tue, 31 Mar 2020 12:33:16 +0100 Subject: + Added Carbon Disulfide. + Added Hydrogen Sulfide if it doesn't exist. + Added Sodium Ethoxide. + Added Potassium Hydroxide. + Added Sodium Ethyl Xanthate. + Added Potassium Ethyl Xanthate. + Added Base work for Froth Flotation Multi. --- .../core/item/chemistry/GenericChem.java | 163 ++++++++++++++++++++- .../chemistry/general/ItemGenericChemBase.java | 6 +- 2 files changed, 167 insertions(+), 2 deletions(-) (limited to 'src/Java/gtPlusPlus/core/item') diff --git a/src/Java/gtPlusPlus/core/item/chemistry/GenericChem.java b/src/Java/gtPlusPlus/core/item/chemistry/GenericChem.java index ff55326031..bdcf4f09d9 100644 --- a/src/Java/gtPlusPlus/core/item/chemistry/GenericChem.java +++ b/src/Java/gtPlusPlus/core/item/chemistry/GenericChem.java @@ -3,6 +3,7 @@ package gtPlusPlus.core.item.chemistry; import static gtPlusPlus.core.lib.CORE.GTNH; import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; import gregtech.api.enums.TextureSet; import gregtech.api.util.GT_Utility; import gtPlusPlus.api.objects.minecraft.ItemPackage; @@ -19,6 +20,7 @@ import gtPlusPlus.core.recipe.common.CI; import gtPlusPlus.core.util.Utils; import gtPlusPlus.core.util.minecraft.FluidUtils; import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.core.util.minecraft.MaterialUtils; import gtPlusPlus.plugin.agrichem.BioRecipes; import gtPlusPlus.plugin.agrichem.block.AgrichemFluids; import gtPlusPlus.xmod.gregtech.api.enums.GregtechItemList; @@ -37,6 +39,7 @@ public class GenericChem extends ItemPackage { private static boolean usingGregtechNitricOxide = false; private static boolean usingGregtechNitrogenDioxide = false; + private static boolean usingGregtechHydricSulfur = false; /** * Materials @@ -94,6 +97,8 @@ public class GenericChem extends ItemPackage { public static Fluid Lithium_Peroxide; public static Fluid Nitric_Oxide; public static Fluid Nitrogen_Dioxide; + public static Fluid Carbon_Disulfide; + public static Fluid Hydrogen_Sulfide; /** * Items @@ -115,6 +120,11 @@ public class GenericChem extends ItemPackage { public static ItemStack mMillingBallAlumina; public static ItemStack mMillingBallSoapstone; + + public static ItemStack mSodiumEthoxide; + public static ItemStack mSodiumEthylXanthate; + public static ItemStack mPotassiumEthylXanthate; + public static ItemStack mPotassiumHydroxide; @@ -149,6 +159,10 @@ public class GenericChem extends ItemPackage { mPinkCatalyst = ItemUtils.simpleMetaStack(mGenericChemItem1, 6, 1); mMillingBallAlumina = ItemUtils.simpleMetaStack(mGenericChemItem1, 7, 1); mMillingBallSoapstone = ItemUtils.simpleMetaStack(mGenericChemItem1, 8, 1); + mSodiumEthoxide = ItemUtils.simpleMetaStack(mGenericChemItem1, 9, 1); + mSodiumEthylXanthate = ItemUtils.simpleMetaStack(mGenericChemItem1, 10, 1); + mPotassiumEthylXanthate = ItemUtils.simpleMetaStack(mGenericChemItem1, 11, 1); + mPotassiumHydroxide = ItemUtils.simpleMetaStack(mGenericChemItem1, 12, 1); } @@ -163,6 +177,10 @@ public class GenericChem extends ItemPackage { ItemUtils.addItemToOreDictionary(mPinkCatalyst, "catalystPlatinumRhodium"); ItemUtils.addItemToOreDictionary(mMillingBallAlumina, "millingballAlumina"); ItemUtils.addItemToOreDictionary(mMillingBallSoapstone, "millingballSoapstone"); + ItemUtils.addItemToOreDictionary(mSodiumEthoxide, "dustSodiumEthoxide"); + ItemUtils.addItemToOreDictionary(mSodiumEthylXanthate, "dustSodiumEthylXanthate"); + ItemUtils.addItemToOreDictionary(mPotassiumEthylXanthate, "dustPotassiumEthylXanthate"); + ItemUtils.addItemToOreDictionary(mPotassiumHydroxide, "dustPotassiumHydroxide"); } @@ -241,8 +259,15 @@ public class GenericChem extends ItemPackage { //Lithium Peroxide - 2 LiOOH → Li2O2 + H2O2 + 2 H2O Lithium_Peroxide = FluidUtils.generateFluidNonMolten("LithiumPeroxide", "Lithium Peroxide", 446, new short[]{135, 135, 135, 100}, null, null); + Carbon_Disulfide = FluidUtils.generateFluidNoPrefix("CarbonDisulfide", "Carbon Disulfide", 350, new short[]{175, 175, 175, 100}); - + if (FluidRegistry.isFluidRegistered("fluid.liquid_hydricsulfur") || MaterialUtils.doesMaterialExist("HydricSulfide")) { + usingGregtechHydricSulfur = true; + } + else { + Hydrogen_Sulfide = FluidUtils.generateFluidNoPrefix("HydrogenSulfide", "Hydrogen Sulfide", 446, new short[]{240, 130, 30, 100}); + } + } @Override @@ -281,17 +306,153 @@ public class GenericChem extends ItemPackage { if (!usingGregtechNitrogenDioxide) { recipeNitrogenDioxide(); } + if (!usingGregtechHydricSulfur) { + recipeHydricSulfur(); + } + else { + Hydrogen_Sulfide = FluidRegistry.getFluid("fluid.liquid_hydricsulfur"); + } // Add recipes if we are not using GT's fluid. if (!FluidRegistry.isFluidRegistered("hydrochloricacid_gt5u")) { recipeHydrochloricAcid(); } + + recipeCarbonDisulfide(); + recipeEthylXanthates(); + recipePotassiumHydroxide(); + registerFuels(); return true; } + private void recipePotassiumHydroxide() { + //Ca(OH)2 + K2CO3 → CaCO3 + 2 KOH + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedCircuit(18), + ELEMENT.getInstance().POTASSIUM.getDust(4), + ELEMENT.getInstance().CARBON.getDust(2), + ItemUtils.getItemStackOfAmountFromOreDict("dustCalciumHydroxide", 2), + }, + new FluidStack[] { + FluidUtils.getFluidStack("oxygen", 6000), + }, + new ItemStack[] { + ItemUtils.getItemStackOfAmountFromOreDict("dustCalciumCarbonate", 2), + ItemUtils.getSimpleStack(mPotassiumHydroxide, 4) + + }, + new FluidStack[] { + + }, + 20 *60 * 2, + 120, + 2); + + } + + + private void recipeEthylXanthates() { + + //Potassium ethyl xanthate - CH3CH2OH + CS2 + KOH → CH3CH2OCS2K + H2O + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedCircuit(17), + ItemUtils.getItemStackOfAmountFromOreDict("dustCalciumHydroxide", 2), + }, + new FluidStack[] { + FluidUtils.getFluidStack(BioRecipes.mEthanol, 1000), + FluidUtils.getFluidStack(Carbon_Disulfide, 1000), + }, + new ItemStack[] { + ItemUtils.getSimpleStack(mPotassiumEthylXanthate, 1) + }, + new FluidStack[] { + FluidUtils.getWater(1000) + }, + 20 *60, + 120, + 2); + + //Sodium ethyl xanthate - CH3CH2ONa + CS2 → CH3CH2OCS2Na + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedCircuit(17), + ItemUtils.getSimpleStack(mSodiumEthoxide, 1) + }, + new FluidStack[] { + FluidUtils.getFluidStack(Carbon_Disulfide, 1000), + }, + new ItemStack[] { + ItemUtils.getSimpleStack(mPotassiumEthylXanthate, 1) + }, + new FluidStack[] { + + }, + 20 *60, + 120, + 2); + + } + + + private void recipeHydricSulfur() { + + ItemStack aCellHydricSulfide = ItemUtils.getItemStackOfAmountFromOreDict("cellHydrogenSulfide", 1); + GT_Values.RA.addChemicalRecipe( ELEMENT.getInstance().SULFUR.getDust(1), GT_Utility.getIntegratedCircuit(1), ELEMENT.getInstance().HYDROGEN.getFluid(2000), FluidUtils.getFluidStack(Hydrogen_Sulfide, 3000), GT_Values.NI, 60, 8); + GT_Values.RA.addChemicalRecipeForBasicMachineOnly(ELEMENT.getInstance().SULFUR.getDust(1), CI.emptyCells(3), ELEMENT.getInstance().HYDROGEN.getFluid(2000), GT_Values.NF, ItemUtils.getSimpleStack(aCellHydricSulfide, 3), GT_Values.NI, 60, 8); + + } + + + private void recipeCarbonDisulfide() { + + CORE.RA.addBlastRecipe( + new ItemStack[] { + CI.getNumberedCircuit(20), + ItemUtils.getItemStackOfAmountFromOreDict("fuelCoke", 8), + ItemUtils.getItemStackOfAmountFromOreDict("dustSulfur", 16) + }, + new FluidStack[] { + + }, + new ItemStack[] { + ItemUtils.getItemStackOfAmountFromOreDict("dustDarkAsh", 1) + }, + new FluidStack[] { + FluidUtils.getFluidStack(Carbon_Disulfide, 4000) + }, + 20 *60 * 10, + 30, + 1500); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedCircuit(20), + ItemUtils.getSimpleStack(mBrownCatalyst, 0), + ItemUtils.getItemStackOfAmountFromOreDict("dustSulfur", 4) + }, + new FluidStack[] { + FluidUtils.getFluidStack(CoalTar.Coal_Gas, 1000), + }, + new ItemStack[] { + + }, + new FluidStack[] { + FluidUtils.getFluidStack(Carbon_Disulfide, 2000), + FluidUtils.getFluidStack(Hydrogen_Sulfide, 4000) + }, + 20 *60 * 5, + 30, + 2); + + + } + + private static void registerFuels() { // Burnables diff --git a/src/Java/gtPlusPlus/core/item/chemistry/general/ItemGenericChemBase.java b/src/Java/gtPlusPlus/core/item/chemistry/general/ItemGenericChemBase.java index 7fb5f207f6..0863faa38d 100644 --- a/src/Java/gtPlusPlus/core/item/chemistry/general/ItemGenericChemBase.java +++ b/src/Java/gtPlusPlus/core/item/chemistry/general/ItemGenericChemBase.java @@ -19,7 +19,7 @@ public class ItemGenericChemBase extends Item { final protected IIcon base[]; - final private int aMetaSize = 9; + final private int aMetaSize = 13; /* * 0 - Red Metal Catalyst //FeCu @@ -31,6 +31,10 @@ public class ItemGenericChemBase extends Item { * 6 - Pink Metal Catalyst //PtRh * 7 - Alumina Grinding Ball * 8 - Soapstone Grinding Ball + * 9 - Sodium Ethoxide // 2 Sodium + 1 Ethanol | 2 C2H5OH + 2 Na → 2 C2H5ONa + H2 + * 10 - Sodium Ethyl Xanthate //CH3CH2ONa + CS2 → CH3CH2OCS2Na + * 11 - Potassium Ethyl Xanthate //CH3CH2OH + CS2 + KOH → CH3CH2OCS2K + H2O + * 12 - Potassium Hydroxide // KOH */ public ItemGenericChemBase() { -- cgit From 09b08b073aea41bfbdf189c88cc722912952ea6d Mon Sep 17 00:00:00 2001 From: Alkalus Date: Tue, 31 Mar 2020 13:05:04 +0100 Subject: $ minor recipe fixes. --- .../core/item/chemistry/GenericChem.java | 52 ++++++++++++++++++---- 1 file changed, 43 insertions(+), 9 deletions(-) (limited to 'src/Java/gtPlusPlus/core/item') diff --git a/src/Java/gtPlusPlus/core/item/chemistry/GenericChem.java b/src/Java/gtPlusPlus/core/item/chemistry/GenericChem.java index bdcf4f09d9..488151a773 100644 --- a/src/Java/gtPlusPlus/core/item/chemistry/GenericChem.java +++ b/src/Java/gtPlusPlus/core/item/chemistry/GenericChem.java @@ -1,9 +1,7 @@ package gtPlusPlus.core.item.chemistry; -import static gtPlusPlus.core.lib.CORE.GTNH; - import gregtech.api.enums.GT_Values; -import gregtech.api.enums.Materials; +import gregtech.api.enums.ItemList; import gregtech.api.enums.TextureSet; import gregtech.api.util.GT_Utility; import gtPlusPlus.api.objects.minecraft.ItemPackage; @@ -28,6 +26,7 @@ import net.minecraft.init.Items; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidContainerRegistry; import net.minecraftforge.fluids.FluidRegistry; import net.minecraftforge.fluids.FluidStack; @@ -263,6 +262,21 @@ public class GenericChem extends ItemPackage { if (FluidRegistry.isFluidRegistered("fluid.liquid_hydricsulfur") || MaterialUtils.doesMaterialExist("HydricSulfide")) { usingGregtechHydricSulfur = true; + Fluid aFluid = null; + if (ItemUtils.doesItemListEntryExist("sHydricSulfur")) { + ItemStack aListItem = ItemUtils.getValueOfItemList("sHydricSulfur", 1, (ItemList) null); + if (aListItem != null) { + FluidStack aFluidStack = FluidContainerRegistry.getFluidForFilledItem(aListItem); + if (aFluidStack != null) { + aFluid = aFluidStack.getFluid(); + } + + } + } + if (aFluid == null) { + aFluid = FluidUtils.getWildcardFluidStack("liquid_hydricsulfur", 1000).getFluid(); + } + Hydrogen_Sulfide = aFluid; } else { Hydrogen_Sulfide = FluidUtils.generateFluidNoPrefix("HydrogenSulfide", "Hydrogen Sulfide", 446, new short[]{240, 130, 30, 100}); @@ -309,15 +323,13 @@ public class GenericChem extends ItemPackage { if (!usingGregtechHydricSulfur) { recipeHydricSulfur(); } - else { - Hydrogen_Sulfide = FluidRegistry.getFluid("fluid.liquid_hydricsulfur"); - } // Add recipes if we are not using GT's fluid. if (!FluidRegistry.isFluidRegistered("hydrochloricacid_gt5u")) { recipeHydrochloricAcid(); } + recipeSodiumEthoxide(); recipeCarbonDisulfide(); recipeEthylXanthates(); recipePotassiumHydroxide(); @@ -328,6 +340,29 @@ public class GenericChem extends ItemPackage { } + private void recipeSodiumEthoxide() { + //2 C2H5OH + 2 Na → 2 C2H5ONa + H2 + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedCircuit(16), + ELEMENT.getInstance().SODIUM.getDust(2) + }, + new FluidStack[] { + FluidUtils.getFluidStack(BioRecipes.mEthanol, 1000), + }, + new ItemStack[] { + ItemUtils.getSimpleStack(mSodiumEthoxide, 2) + + }, + new FluidStack[] { + ELEMENT.getInstance().HYDROGEN.getFluid(2000) + }, + 20 *20, + 120, + 2); + } + + private void recipePotassiumHydroxide() { //Ca(OH)2 + K2CO3 → CaCO3 + 2 KOH CORE.RA.addChemicalPlantRecipe( @@ -348,7 +383,7 @@ public class GenericChem extends ItemPackage { new FluidStack[] { }, - 20 *60 * 2, + 20 *30, 120, 2); @@ -387,7 +422,7 @@ public class GenericChem extends ItemPackage { FluidUtils.getFluidStack(Carbon_Disulfide, 1000), }, new ItemStack[] { - ItemUtils.getSimpleStack(mPotassiumEthylXanthate, 1) + ItemUtils.getSimpleStack(mSodiumEthylXanthate, 1) }, new FluidStack[] { @@ -412,7 +447,6 @@ public class GenericChem extends ItemPackage { CORE.RA.addBlastRecipe( new ItemStack[] { - CI.getNumberedCircuit(20), ItemUtils.getItemStackOfAmountFromOreDict("fuelCoke", 8), ItemUtils.getItemStackOfAmountFromOreDict("dustSulfur", 16) }, -- cgit From 2c4a94b808c61d66163d9969017c2819ddb2c5ae Mon Sep 17 00:00:00 2001 From: Alkalus Date: Tue, 31 Mar 2020 16:35:15 +0100 Subject: + Added a Pine Tree. + Oredict BoP Pinecone if it exists. $ Fixed Algae Farm controller recipe. $ Fixed bug where getOrePrefixStack(rod) would return null. $ Fixed a bug where getItemStackFromFQRN didn't work correctly. --- .../core/item/chemistry/AgriculturalChem.java | 7 + .../core/item/chemistry/MilledOreProcessing.java | 184 +++++++++++++++++++-- 2 files changed, 180 insertions(+), 11 deletions(-) (limited to 'src/Java/gtPlusPlus/core/item') diff --git a/src/Java/gtPlusPlus/core/item/chemistry/AgriculturalChem.java b/src/Java/gtPlusPlus/core/item/chemistry/AgriculturalChem.java index 3f02ca898d..e11b163753 100644 --- a/src/Java/gtPlusPlus/core/item/chemistry/AgriculturalChem.java +++ b/src/Java/gtPlusPlus/core/item/chemistry/AgriculturalChem.java @@ -110,6 +110,7 @@ public class AgriculturalChem extends ItemPackage { * 21 - Lithium Chloride * 22 - Pellet Mold * 23 - Clean Aluminium Mix + * 24 - Pinecone */ public static ItemStack mAlgaeBiosmass; @@ -136,6 +137,8 @@ public class AgriculturalChem extends ItemPackage { public static ItemStack mLithiumChloride; public static ItemStack mPelletMold; public static ItemStack mCleanAluminiumMix; + public static ItemStack mPinecone; + public static ItemStack mCrushedPine; @Override @@ -205,6 +208,8 @@ public class AgriculturalChem extends ItemPackage { mLithiumChloride = ItemUtils.simpleMetaStack(mAgrichemItem1, 21, 1); mPelletMold = ItemUtils.simpleMetaStack(mAgrichemItem1, 22, 1); mCleanAluminiumMix = ItemUtils.simpleMetaStack(mAgrichemItem1, 23, 1); + mPinecone = ItemUtils.simpleMetaStack(mAgrichemItem1, 24, 1); + mCrushedPine = ItemUtils.simpleMetaStack(mAgrichemItem1, 25, 1); ItemUtils.addItemToOreDictionary(mGreenAlgaeBiosmass, "biomassGreenAlgae"); ItemUtils.addItemToOreDictionary(mBrownAlgaeBiosmass, "biomassBrownAlgae"); @@ -231,6 +236,8 @@ public class AgriculturalChem extends ItemPackage { ItemUtils.addItemToOreDictionary(mSodiumHydroxide, "dustSodiumHydroxide"); ItemUtils.addItemToOreDictionary(mSodiumCarbonate, "dustSodiumCarbonate"); ItemUtils.addItemToOreDictionary(mLithiumChloride, "dustLithiumChloride"); + ItemUtils.addItemToOreDictionary(mPinecone, "pinecone"); + ItemUtils.addItemToOreDictionary(mCrushedPine, "crushedPineMaterial"); //Handle GT NaOH dusts List NaOHSmall = OreDictionary.getOres("dustSmallSodiumHydroxide_GT5U", false); diff --git a/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java b/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java index 426f48ecf9..86ffe49eed 100644 --- a/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java +++ b/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java @@ -1,46 +1,61 @@ package gtPlusPlus.core.item.chemistry; +import gregtech.api.enums.GT_Values; import gregtech.api.enums.Materials; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.AutoMap; import gtPlusPlus.api.objects.minecraft.ItemPackage; import gtPlusPlus.core.item.base.ore.BaseItemMilledOre; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.lib.LoadedMods; +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.NBTUtils; +import gtPlusPlus.xmod.bop.HANDLER_BiomesOPlenty; +import gtPlusPlus.xmod.bop.blocks.BOP_Block_Registrator; import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; public class MilledOreProcessing extends ItemPackage { /** * Fluids */ - + public static Fluid ZincFlotationFroth; public static Fluid CopperFlotationFroth; public static Fluid NickelFlotationFroth; public static Fluid PlatinumFlotationFroth; public static Fluid PentlanditeFlotationFroth; - - + + public static Fluid PineOil; + + /** * Items */ // Zinc, Iron, Indium, Germanium public static Item milledSphalerite; - + // Copper, Iron, Cadmium, Indium public static Item milledChalcopyrite; - + // Nickel, Cobalt, Rhodium, Ruthenium public static Item milledNickel; - + // Platinum, Rhodium, Selenium, Tellurium public static Item milledPlatinum; // Iron, Nickel, Promethium, Hafnium public static Item milledPentlandite; - + @Override public void items() { @@ -50,7 +65,7 @@ public class MilledOreProcessing extends ItemPackage { milledNickel = BaseItemMilledOre.generate(Materials.Nickel, MaterialUtils.getVoltageForTier(4)); milledPlatinum = BaseItemMilledOre.generate(Materials.Platinum, MaterialUtils.getVoltageForTier(5)); milledPentlandite = BaseItemMilledOre.generate(Materials.Pentlandite, MaterialUtils.getVoltageForTier(5)); - + } @Override @@ -60,7 +75,7 @@ public class MilledOreProcessing extends ItemPackage { @Override public void fluids() { - + short[] aZincFrothRGB = Materials.Sphalerite.mRGBa; ZincFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.zincflotation", "Zinc Froth", 32 + 175, new short[] { aZincFrothRGB[0], aZincFrothRGB[1], aZincFrothRGB[2], 100 }, true); short[] aCopperFrothRGB = Materials.Chalcopyrite.mRGBa; @@ -72,9 +87,11 @@ public class MilledOreProcessing extends ItemPackage { short[] aPentlanditeFrothRGB = Materials.Pentlandite.mRGBa; PentlanditeFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.pentlanditeflotation", "Pentlandite Froth", 32 + 175, new short[] { aPentlanditeFrothRGB[0], aPentlanditeFrothRGB[1], aPentlanditeFrothRGB[2], 100 }, true); + PineOil = FluidUtils.generateFluidNoPrefix("pineoil", "Pine Oil", 32 + 175, new short[] { 250, 200, 60, 100 }, true); + } - - + + public MilledOreProcessing() { super(); @@ -98,6 +115,7 @@ public class MilledOreProcessing extends ItemPackage { 30 * 20, 30);*/ + } @Override @@ -108,6 +126,150 @@ public class MilledOreProcessing extends ItemPackage { @Override public boolean generateRecipes() { addMiscRecipes(); + addPineOilExtraction(); return true; } + + private void addPineOilExtraction() { + AutoMap aLogs = new AutoMap(); + AutoMap aLeaves = new AutoMap(); + AutoMap aSaplings = new AutoMap(); + AutoMap aPinecones = new AutoMap(); + + ItemStack aCrushedPine = ItemUtils.getSimpleStack(AgriculturalChem.mCrushedPine, 1); + + aLogs.add(ItemUtils.getSimpleStack(BOP_Block_Registrator.log_Pine)); + aLeaves.add(ItemUtils.getSimpleStack(BOP_Block_Registrator.leaves_Pine)); + aSaplings.add(ItemUtils.getSimpleStack(BOP_Block_Registrator.sapling_Pine)); + aPinecones.add(ItemUtils.getSimpleStack(AgriculturalChem.mPinecone, 1)); + + if (LoadedMods.BiomesOPlenty) { + aLogs.add(HANDLER_BiomesOPlenty.getStack(HANDLER_BiomesOPlenty.logs4, 0, 1)); + aLeaves.add(HANDLER_BiomesOPlenty.getStack(HANDLER_BiomesOPlenty.colorizedLeaves2, 1, 1)); + aSaplings.add(HANDLER_BiomesOPlenty.getStack(HANDLER_BiomesOPlenty.colorizedSaplings, 5, 1)); + aPinecones.add(ItemUtils.simpleMetaStack(HANDLER_BiomesOPlenty.mPineCone, 13, 1)); + } + if (LoadedMods.Forestry) { + ItemStack aForestryLog = ItemUtils.getItemStackFromFQRN("Forestry:logs", 1); + if (aForestryLog != null) { + aForestryLog.setItemDamage(20); // Set to Pine + aLogs.add(aForestryLog); + } + ItemStack aForestryLeaves = ItemUtils.getItemStackFromFQRN("Forestry:leaves", 1); + if (aForestryLeaves != null) { + NBTUtils.setString(aForestryLeaves, "species", "forestry.treePine"); // Set to Pine + aLeaves.add(aForestryLeaves); + } + } + + for (ItemStack aLog : aLogs) { + addRecipe(aLog, ItemUtils.getSimpleStack(aCrushedPine, 16), new int[] {10000, 7500, 5000, 2500}, 10, 120); + } + for (ItemStack aLeaf : aLeaves) { + addRecipe(aLeaf, ItemUtils.getSimpleStack(aCrushedPine, 2), new int[] {5000, 5000, 2500, 2500}, 10, 30); + } + for (ItemStack aSapling : aSaplings) { + addRecipe(aSapling, ItemUtils.getSimpleStack(aCrushedPine, 4), new int[] {7500, 7500, 2500, 2500}, 10, 60); + } + for (ItemStack aCone : aPinecones) { + addRecipe(aCone, ItemUtils.getSimpleStack(aCrushedPine, 1), new int[] {7500, 7500, 5000, 2500}, 10, 60); + } + + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedBioCircuit(16), + ItemUtils.getSimpleStack(aCrushedPine, 64) + }, + new FluidStack[] { + FluidUtils.getSteam(5000), + }, + new ItemStack[] { + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyAsh", 5), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyAsh", 5), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyDarkAsh", 5), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyDarkAsh", 5) + }, + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 1000) + }, + new int[] { + 2000, 2000, 2000, 2000 + }, + 20 *60, + 120, + 2); + + CORE.RA.addChemicalPlantRecipe( + new ItemStack[] { + CI.getNumberedBioCircuit(18), + ItemUtils.getSimpleStack(aCrushedPine, 64) + }, + new FluidStack[] { + FluidUtils.getSuperHeatedSteam(5000), + }, + new ItemStack[] { + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyAsh", 5), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyAsh", 5), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyDarkAsh", 5), + ItemUtils.getItemStackOfAmountFromOreDict("dustTinyDarkAsh", 5) + }, + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 2000) + }, + new int[] { + 3000, 3000, 3000, 3000 + }, + 20 *60, + 120, + 3); + + } + + public boolean addRecipe(ItemStack aInput, ItemStack aOutput1, int[] aChances, int aTime, int aEU) { + aOutput1 = GT_OreDictUnificator.get(true, aOutput1); + ItemStack aOutputs[] = new ItemStack[4]; + for (int i=0;i aCleanedItems = new AutoMap(); + for (ItemStack checkStack : input) { + if (ItemUtils.checkForInvalidItems(checkStack)) { + aCleanedItems.put(checkStack); + } + } + ItemStack[] aOutput = new ItemStack[aCleanedItems.size()]; + for (int i=0;i Date: Sat, 4 Apr 2020 16:57:56 +0100 Subject: + Added a new base bus type. + Added the Ball Housing bus. + Added the Catalyst Housing bus. + Added the Reinforced Engine Casing. + Made the Flotation Cell Regulator actually load. $ Fixed Tooltips on Milling Balls & Catalysts. $ Added improved item handling for Milling Balls. $ Added improved item handling for Catalysts. --- .../core/item/chemistry/MilledOreProcessing.java | 1 - .../chemistry/general/ItemGenericChemBase.java | 191 +++++++++++++++++++-- 2 files changed, 175 insertions(+), 17 deletions(-) (limited to 'src/Java/gtPlusPlus/core/item') diff --git a/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java b/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java index 86ffe49eed..3583ddca3f 100644 --- a/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java +++ b/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java @@ -1,6 +1,5 @@ package gtPlusPlus.core.item.chemistry; -import gregtech.api.enums.GT_Values; import gregtech.api.enums.Materials; import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_Utility; diff --git a/src/Java/gtPlusPlus/core/item/chemistry/general/ItemGenericChemBase.java b/src/Java/gtPlusPlus/core/item/chemistry/general/ItemGenericChemBase.java index 0863faa38d..ed17f8547a 100644 --- a/src/Java/gtPlusPlus/core/item/chemistry/general/ItemGenericChemBase.java +++ b/src/Java/gtPlusPlus/core/item/chemistry/general/ItemGenericChemBase.java @@ -3,6 +3,8 @@ package gtPlusPlus.core.item.chemistry.general; import java.util.List; import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.util.GT_Utility; +import gtPlusPlus.core.item.chemistry.GenericChem; import gtPlusPlus.core.lib.CORE; import gtPlusPlus.core.util.minecraft.ItemUtils; import net.minecraft.client.renderer.texture.IIconRegister; @@ -12,6 +14,8 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.EnumRarity; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.IIcon; import net.minecraft.world.World; @@ -47,6 +51,14 @@ public class ItemGenericChemBase extends Item { GameRegistry.registerItem(this, this.getUnlocalizedName()); } + @Override + public int getItemStackLimit(ItemStack stack) { + if (ItemUtils.isMillingBall(stack)) { + return 16; + } + return super.getItemStackLimit(stack); + } + @Override public boolean isDamageable() { return false; @@ -67,17 +79,6 @@ public class ItemGenericChemBase extends Item { return super.getItemStackDisplayName(aStack); } - @Override - public void addInformation(ItemStack aStack, EntityPlayer p_77624_2_, List aList, boolean p_77624_4_) { - try { - - } - catch (Throwable t) { - t.printStackTrace(); - } - super.addInformation(aStack, p_77624_2_, aList, p_77624_4_); - } - @Override public EnumRarity getRarity(ItemStack p_77613_1_) { return EnumRarity.common; @@ -115,11 +116,6 @@ public class ItemGenericChemBase extends Item { return stack.getItemDamage(); } - @Override - public boolean showDurabilityBar(ItemStack stack) { - return false; - } - @Override public int getItemEnchantability() { return 0; @@ -165,4 +161,167 @@ public class ItemGenericChemBase extends Item { } + + @Override + public double getDurabilityForDisplay(ItemStack aStack) { + if (ItemUtils.isMillingBall(aStack)) { + if (aStack.getTagCompound() == null || aStack.getTagCompound().hasNoTags()){ + createMillingBallNBT(aStack); + } + double currentDamage = getMillingBallDamage(aStack); + double durabilitypercent = currentDamage / 100; + return durabilitypercent; + } + else if (ItemUtils.isCatalyst(aStack)) { + if (aStack.getTagCompound() == null || aStack.getTagCompound().hasNoTags()){ + createCatalystNBT(aStack); + } + double currentDamage = getCatalystDamage(aStack); + double durabilitypercent = currentDamage / 100; + return durabilitypercent; + } + else { + return 1D; + } + } + + @SuppressWarnings("unchecked") + @Override + public void addInformation(ItemStack aStack, EntityPlayer player, List list, boolean bool) { + boolean aHasSpecialTooltips = false; + int aMaxDamage = 0; + int aDamageSegment = 0; + int aDam = 0; + EnumChatFormatting durability = EnumChatFormatting.GRAY; + if (ItemUtils.isMillingBall(aStack)) { + list.add(EnumChatFormatting.GRAY+"Tumble Tumble Tumble"); + aMaxDamage = getMillingBallMaxDamage(aStack); + aDamageSegment = aMaxDamage / 5; + aDam = aMaxDamage-getMillingBallDamage(aStack); + aHasSpecialTooltips = true; + } + if (ItemUtils.isCatalyst(aStack)) { + list.add(EnumChatFormatting.GRAY+"Active Reaction Agent"); + aMaxDamage = getCatalystMaxDamage(aStack); + aDamageSegment = aMaxDamage / 5; + aDam = aMaxDamage-getCatalystDamage(aStack); + aHasSpecialTooltips = true; + } + if (aHasSpecialTooltips) { + if (aDam > aDamageSegment * 4){ + durability = EnumChatFormatting.GRAY; + } + else if (aDam > aDamageSegment * 3){ + durability = EnumChatFormatting.GREEN; + } + else if (aDam > aDamageSegment * 2){ + durability = EnumChatFormatting.YELLOW; + } + else if (aDam > aDamageSegment){ + durability = EnumChatFormatting.GOLD; + } + else if (aDam > 0){ + durability = EnumChatFormatting.RED; + } + list.add(durability+""+(aDam)+EnumChatFormatting.GRAY+" / "+aMaxDamage); + } + super.addInformation(aStack, player, list, bool); + } + + @Override + public boolean showDurabilityBar(ItemStack aStack) { + if (ItemUtils.isMillingBall(aStack)) { + int aDam = getMillingBallDamage(aStack); + if (aDam > 0) { + return true; + } + } + else if (ItemUtils.isCatalyst(aStack)) { + int aDam = getCatalystDamage(aStack); + if (aDam > 0) { + return true; + } + } + return false; + } + + public static boolean createMillingBallNBT(ItemStack rStack){ + final NBTTagCompound tagMain = new NBTTagCompound(); + final NBTTagCompound tagNBT = new NBTTagCompound(); + tagNBT.setLong("Damage", 0); + tagNBT.setLong("MaxDamage", getMaxBallDurability(rStack)); + tagMain.setTag("MillingBall", tagNBT); + rStack.setTagCompound(tagMain); + return true; + } + + public static int getMillingBallDamage(ItemStack aStack) { + if (aStack.getTagCompound() == null || aStack.getTagCompound().hasNoTags()) { + createMillingBallNBT(aStack); + } + NBTTagCompound aNBT = aStack.getTagCompound(); + return aNBT.getCompoundTag("MillingBall").getInteger("Damage"); + } + + public static int getMillingBallMaxDamage(ItemStack aStack) { + if (aStack.getTagCompound() == null || aStack.getTagCompound().hasNoTags()) { + createMillingBallNBT(aStack); + } + NBTTagCompound aNBT = aStack.getTagCompound(); + return aNBT.getCompoundTag("MillingBall").getInteger("MaxDamage"); + } + + public static void setMillingBallDamage(ItemStack aStack,int aAmount) { + NBTTagCompound aNBT = aStack.getTagCompound(); + aNBT = aNBT.getCompoundTag("MillingBall"); + aNBT.setInteger("Damage", aAmount); + } + + public static int getMaxBallDurability(ItemStack aStack) { + if (GT_Utility.areStacksEqual(aStack, GenericChem.mMillingBallAlumina, true)) { + return 100; + } + if (GT_Utility.areStacksEqual(aStack, GenericChem.mMillingBallSoapstone, true)) { + return 50; + } + return 0; + } + + public static boolean createCatalystNBT(ItemStack rStack){ + final NBTTagCompound tagMain = new NBTTagCompound(); + final NBTTagCompound tagNBT = new NBTTagCompound(); + tagNBT.setLong("Damage", 0); + tagNBT.setLong("MaxDamage", getMaxCatalystDurability(rStack)); + tagMain.setTag("catalyst", tagNBT); + rStack.setTagCompound(tagMain); + return true; + } + + public static int getCatalystDamage(ItemStack aStack) { + if (aStack.getTagCompound() == null || aStack.getTagCompound().hasNoTags()) { + createCatalystNBT(aStack); + } + NBTTagCompound aNBT = aStack.getTagCompound(); + return aNBT.getCompoundTag("catalyst").getInteger("Damage"); + } + + public static int getCatalystMaxDamage(ItemStack aStack) { + if (aStack.getTagCompound() == null || aStack.getTagCompound().hasNoTags()) { + createCatalystNBT(aStack); + } + NBTTagCompound aNBT = aStack.getTagCompound(); + return aNBT.getCompoundTag("catalyst").getInteger("MaxDamage"); + } + + public static void setCatalystDamage(ItemStack aStack,int aAmount) { + NBTTagCompound aNBT = aStack.getTagCompound(); + aNBT = aNBT.getCompoundTag("catalyst"); + aNBT.setInteger("Damage", aAmount); + } + + public static int getMaxCatalystDurability(ItemStack aStack) { + return 50; + } + + } -- cgit From baf1f6ff533b9ada00aeb7de98dd0bdaf5c28e10 Mon Sep 17 00:00:00 2001 From: Alkalus Date: Sat, 11 Apr 2020 22:40:18 +0100 Subject: + Added more milled materials. + Added proper structure for Flotation Cells. + Added all milled materials to flotation cell recipes. + Added Human meat drops for dead players. + Added Slicing mode for ICM. % Changed getVoltageForTier to be a switch case. % Stopped download of cape list in dev environment. $ Adjusted how Fusion MK4 injects power, it now pulls the voltage of the hatch. $ Fixed Fake Player Handling. --- .../core/item/chemistry/MilledOreProcessing.java | 214 ++++++++++++++++++++- 1 file changed, 204 insertions(+), 10 deletions(-) (limited to 'src/Java/gtPlusPlus/core/item') diff --git a/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java b/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java index 3583ddca3f..1de58c36aa 100644 --- a/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java +++ b/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java @@ -27,12 +27,18 @@ public class MilledOreProcessing extends ItemPackage { * Fluids */ - public static Fluid ZincFlotationFroth; - public static Fluid CopperFlotationFroth; + public static Fluid SphaleriteFlotationFroth; + public static Fluid ChalcopyriteFlotationFroth; public static Fluid NickelFlotationFroth; public static Fluid PlatinumFlotationFroth; public static Fluid PentlanditeFlotationFroth; + public static Fluid RedstoneFlotationFroth; + public static Fluid SpessartineFlotationFroth; + public static Fluid GrossularFlotationFroth; + public static Fluid AlmandineFlotationFroth; + public static Fluid PyropeFlotationFroth; + public static Fluid PineOil; @@ -54,16 +60,40 @@ public class MilledOreProcessing extends ItemPackage { // Iron, Nickel, Promethium, Hafnium public static Item milledPentlandite; - + + + + + // Redstone, Ruby, Chrome, Firestone + public static Item milledRedstone; + + // Manganese, Aluminium, ???, ??? + public static Item milledSpessartine; + + // Calcium, Aluminium, ???, ??? + public static Item milledGrossular; + + // Iron, Aluminium, Magnesium, Ytterbium + public static Item milledAlmandine; + + // Magnesium, Aluminium, Chrome, Manganese + public static Item milledPyrope; + @Override public void items() { - milledSphalerite = BaseItemMilledOre.generate(Materials.Sphalerite, MaterialUtils.getVoltageForTier(5)); - milledChalcopyrite = BaseItemMilledOre.generate(Materials.Chalcopyrite, MaterialUtils.getVoltageForTier(4)); - milledNickel = BaseItemMilledOre.generate(Materials.Nickel, MaterialUtils.getVoltageForTier(4)); - milledPlatinum = BaseItemMilledOre.generate(Materials.Platinum, MaterialUtils.getVoltageForTier(5)); - milledPentlandite = BaseItemMilledOre.generate(Materials.Pentlandite, MaterialUtils.getVoltageForTier(5)); + milledSphalerite = BaseItemMilledOre.generate(Materials.Sphalerite, MaterialUtils.getVoltageForTier(6)); + milledChalcopyrite = BaseItemMilledOre.generate(Materials.Chalcopyrite, MaterialUtils.getVoltageForTier(5)); + milledNickel = BaseItemMilledOre.generate(Materials.Nickel, MaterialUtils.getVoltageForTier(5)); + milledPlatinum = BaseItemMilledOre.generate(Materials.Platinum, MaterialUtils.getVoltageForTier(6)); + milledPentlandite = BaseItemMilledOre.generate(Materials.Pentlandite, MaterialUtils.getVoltageForTier(6)); + + milledRedstone = BaseItemMilledOre.generate(Materials.Redstone, MaterialUtils.getVoltageForTier(5)); + milledSpessartine = BaseItemMilledOre.generate(Materials.Spessartine, MaterialUtils.getVoltageForTier(6)); + milledGrossular = BaseItemMilledOre.generate(Materials.Grossular, MaterialUtils.getVoltageForTier(6)); + milledAlmandine = BaseItemMilledOre.generate(Materials.Almandine, MaterialUtils.getVoltageForTier(6)); + milledPyrope = BaseItemMilledOre.generate(Materials.Pyrope, MaterialUtils.getVoltageForTier(4)); } @@ -76,9 +106,9 @@ public class MilledOreProcessing extends ItemPackage { public void fluids() { short[] aZincFrothRGB = Materials.Sphalerite.mRGBa; - ZincFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.zincflotation", "Zinc Froth", 32 + 175, new short[] { aZincFrothRGB[0], aZincFrothRGB[1], aZincFrothRGB[2], 100 }, true); + SphaleriteFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.zincflotation", "Sphalerite Froth", 32 + 175, new short[] { aZincFrothRGB[0], aZincFrothRGB[1], aZincFrothRGB[2], 100 }, true); short[] aCopperFrothRGB = Materials.Chalcopyrite.mRGBa; - CopperFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.copperflotation", "Copper Froth", 32 + 175, new short[] { aCopperFrothRGB[0], aCopperFrothRGB[1], aCopperFrothRGB[2], 100 }, true); + ChalcopyriteFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.copperflotation", "Chalcopyrite Froth", 32 + 175, new short[] { aCopperFrothRGB[0], aCopperFrothRGB[1], aCopperFrothRGB[2], 100 }, true); short[] aNickelFrothRGB = Materials.Nickel.mRGBa; NickelFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.nickelflotation", "Nickel Froth", 32 + 175, new short[] { aNickelFrothRGB[0], aNickelFrothRGB[1], aNickelFrothRGB[2], 100 }, true); short[] aPlatinumFrothRGB = Materials.Platinum.mRGBa; @@ -86,6 +116,18 @@ public class MilledOreProcessing extends ItemPackage { short[] aPentlanditeFrothRGB = Materials.Pentlandite.mRGBa; PentlanditeFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.pentlanditeflotation", "Pentlandite Froth", 32 + 175, new short[] { aPentlanditeFrothRGB[0], aPentlanditeFrothRGB[1], aPentlanditeFrothRGB[2], 100 }, true); + short[] aRedstoneFrothRGB = Materials.Redstone.mRGBa; + RedstoneFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.redstoneflotation", "Redstone Froth", 32 + 175, new short[] { aRedstoneFrothRGB[0], aRedstoneFrothRGB[1], aRedstoneFrothRGB[2], 100 }, true); + short[] aSpessartineFrothRGB = Materials.Spessartine.mRGBa; + SpessartineFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.spessartineflotation", "Spessartine Froth", 32 + 175, new short[] { aSpessartineFrothRGB[0], aSpessartineFrothRGB[1], aSpessartineFrothRGB[2], 100 }, true); + short[] aGrossularFrothRGB = Materials.Grossular.mRGBa; + GrossularFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.grossularflotation", "Grossular Froth", 32 + 175, new short[] { aGrossularFrothRGB[0], aGrossularFrothRGB[1], aGrossularFrothRGB[2], 100 }, true); + short[] aAlmandineFrothRGB = Materials.Almandine.mRGBa; + AlmandineFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.almandineflotation", "Almandine Froth", 32 + 175, new short[] { aAlmandineFrothRGB[0], aAlmandineFrothRGB[1], aAlmandineFrothRGB[2], 100 }, true); + short[] aPyropeFrothRGB = Materials.Pyrope.mRGBa; + PyropeFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.pyropeflotation", "Pyrope Froth", 32 + 175, new short[] { aPyropeFrothRGB[0], aPyropeFrothRGB[1], aPyropeFrothRGB[2], 100 }, true); + + PineOil = FluidUtils.generateFluidNoPrefix("pineoil", "Pine Oil", 32 + 175, new short[] { 250, 200, 60, 100 }, true); } @@ -126,8 +168,160 @@ public class MilledOreProcessing extends ItemPackage { public boolean generateRecipes() { addMiscRecipes(); addPineOilExtraction(); + addFlotationRecipes1(); + addFlotationRecipes2(); return true; } + + private void addFlotationRecipes2() { + + // Redstone + CORE.RA.addFlotationRecipe( + Materials.Redstone, + ItemUtils.getSimpleStack(GenericChem.mSodiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 3000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(RedstoneFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(5) + ); + + // Spessartine + CORE.RA.addFlotationRecipe( + Materials.Spessartine, + ItemUtils.getSimpleStack(GenericChem.mPotassiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 5000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(SpessartineFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(6) + ); + + // Grossular + CORE.RA.addFlotationRecipe( + Materials.Grossular, + ItemUtils.getSimpleStack(GenericChem.mPotassiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 5000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(GrossularFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(6) + ); + + // Almandine + CORE.RA.addFlotationRecipe( + Materials.Almandine, + ItemUtils.getSimpleStack(GenericChem.mSodiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 4000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(AlmandineFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(5) + ); + + // Pyrope + CORE.RA.addFlotationRecipe( + Materials.Pyrope, + ItemUtils.getSimpleStack(GenericChem.mSodiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 2000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(PyropeFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(4) + ); + + } + + private void addFlotationRecipes1() { + + // Sphalerite + CORE.RA.addFlotationRecipe( + Materials.Sphalerite, + ItemUtils.getSimpleStack(GenericChem.mSodiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 4000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(SphaleriteFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(6) + ); + + // Chalcopyrite + CORE.RA.addFlotationRecipe( + Materials.Chalcopyrite, + ItemUtils.getSimpleStack(GenericChem.mSodiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 4000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(ChalcopyriteFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(5) + ); + + // Nickel + CORE.RA.addFlotationRecipe( + Materials.Nickel, + ItemUtils.getSimpleStack(GenericChem.mPotassiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 5000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(NickelFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(5) + ); + + // Platinum + CORE.RA.addFlotationRecipe( + Materials.Platinum, + ItemUtils.getSimpleStack(GenericChem.mPotassiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 5000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(PlatinumFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(6) + ); + + + // Pentlandite + CORE.RA.addFlotationRecipe( + Materials.Pentlandite, + ItemUtils.getSimpleStack(GenericChem.mSodiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 4000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(PentlanditeFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(6) + ); + + + } private void addPineOilExtraction() { AutoMap aLogs = new AutoMap(); -- cgit From 064fda35b848c8e9dfc29d7af761a5de32a26dd1 Mon Sep 17 00:00:00 2001 From: Alkalus Date: Sun, 12 Apr 2020 00:23:10 +0100 Subject: + Added Dehydration of Flotation Slurries to the Vacuum Furnace. --- .../core/item/chemistry/MilledOreProcessing.java | 496 +++++++++++++++++---- 1 file changed, 404 insertions(+), 92 deletions(-) (limited to 'src/Java/gtPlusPlus/core/item') diff --git a/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java b/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java index 1de58c36aa..7ce6259840 100644 --- a/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java +++ b/src/Java/gtPlusPlus/core/item/chemistry/MilledOreProcessing.java @@ -1,14 +1,21 @@ package gtPlusPlus.core.item.chemistry; +import java.util.HashMap; + import gregtech.api.enums.Materials; import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_Utility; import gtPlusPlus.api.objects.Logger; import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.api.objects.data.Pair; +import gtPlusPlus.api.objects.data.Quad; import gtPlusPlus.api.objects.minecraft.ItemPackage; import gtPlusPlus.core.item.base.ore.BaseItemMilledOre; import gtPlusPlus.core.lib.CORE; import gtPlusPlus.core.lib.LoadedMods; +import gtPlusPlus.core.material.ELEMENT; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.material.NONMATERIAL; import gtPlusPlus.core.recipe.common.CI; import gtPlusPlus.core.util.minecraft.FluidUtils; import gtPlusPlus.core.util.minecraft.ItemUtils; @@ -20,6 +27,7 @@ import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidStack; +import scala.xml.dtd.ELEMENTS; public class MilledOreProcessing extends ItemPackage { @@ -60,25 +68,25 @@ public class MilledOreProcessing extends ItemPackage { // Iron, Nickel, Promethium, Hafnium public static Item milledPentlandite; - - - - - // Redstone, Ruby, Chrome, Firestone + + + + + // Redstone, Chrome, Firestone, Dysprosium public static Item milledRedstone; - // Manganese, Aluminium, ???, ??? + // Manganese, Aluminium, Osmium, Strontium public static Item milledSpessartine; - - // Calcium, Aluminium, ???, ??? + + // Calcium, Aluminium, Tungsten, Thallium public static Item milledGrossular; - - // Iron, Aluminium, Magnesium, Ytterbium + + // Aluminium, Magnesium, Yttrium, Ytterbium public static Item milledAlmandine; - - // Magnesium, Aluminium, Chrome, Manganese + + // Magnesium, Manganese, Borax, Rhenium public static Item milledPyrope; - + @Override public void items() { @@ -127,7 +135,7 @@ public class MilledOreProcessing extends ItemPackage { short[] aPyropeFrothRGB = Materials.Pyrope.mRGBa; PyropeFlotationFroth = FluidUtils.generateFluidNoPrefix("froth.pyropeflotation", "Pyrope Froth", 32 + 175, new short[] { aPyropeFrothRGB[0], aPyropeFrothRGB[1], aPyropeFrothRGB[2], 100 }, true); - + PineOil = FluidUtils.generateFluidNoPrefix("pineoil", "Pine Oil", 32 + 175, new short[] { 250, 200, 60, 100 }, true); } @@ -141,20 +149,94 @@ public class MilledOreProcessing extends ItemPackage { private static void addMiscRecipes() { - /*GT_Values.RA.addCentrifugeRecipe( - CI.getNumberedBioCircuit(10), - GT_Values.NI, - FluidUtils.getFluidStack(MilledOreProcessing.ZincFlotationFroth, 1000), - FluidUtils.getWater(500), - ELEMENT.getInstance().IRON.getSmallDust(1), - ELEMENT.getInstance().COPPER.getSmallDust(1), - ELEMENT.getInstance().TIN.getSmallDust(1), - ELEMENT.getInstance().SULFUR.getSmallDust(1), - ELEMENT.getInstance().NICKEL.getTinyDust(1), - ELEMENT.getInstance().LEAD.getTinyDust(1), - new int[] { 3000, 3000, 2000, 2000, 1000, 1000 }, - 30 * 20, - 30);*/ + /* + * First 5 + */ + + //milledSphalerite + registerOreDataForMilledType( + SphaleriteFlotationFroth, + ELEMENT.getInstance().ZINC, 180, + ELEMENT.getInstance().IRON, 120, + ELEMENT.getInstance().INDIUM, 20, + ELEMENT.getInstance().GERMANIUM, 6 + ); + //milledChalcopyrite + registerOreDataForMilledType( + ChalcopyriteFlotationFroth, + ELEMENT.getInstance().COPPER, 180, + ELEMENT.getInstance().IRON, 120, + ELEMENT.getInstance().CADMIUM, 30, + ELEMENT.getInstance().INDIUM, 5 + ); + //milledNickel + registerOreDataForMilledType( + NickelFlotationFroth, + ELEMENT.getInstance().NICKEL, 150, + ELEMENT.getInstance().COBALT, 120, + ELEMENT.getInstance().RHODIUM, 16, + ELEMENT.getInstance().RUTHENIUM, 8 + ); + //milledPlatinum + registerOreDataForMilledType( + PlatinumFlotationFroth, + ELEMENT.getInstance().PLATINUM, 120, + ELEMENT.getInstance().RHODIUM, 45, + ELEMENT.getInstance().SELENIUM, 24, + ELEMENT.getInstance().TELLURIUM, 4 + ); + //milledPentlandite + registerOreDataForMilledType( + PentlanditeFlotationFroth, + ELEMENT.getInstance().IRON, 150, + ELEMENT.getInstance().NICKEL, 100, + ELEMENT.getInstance().PROMETHIUM, 12, + ELEMENT.getInstance().HAFNIUM, 5 + ); + + /* + * Second 5 + */ + //milledRedstone + registerOreDataForMilledType( + RedstoneFlotationFroth, + NONMATERIAL.REDSTONE, 300, + ELEMENT.getInstance().CHROMIUM, 60, + MaterialUtils.generateMaterialFromGtENUM(Materials.Firestone), 30, + ELEMENT.getInstance().DYSPROSIUM, 8 + ); + //milledSpessartine + registerOreDataForMilledType( + SpessartineFlotationFroth, + ELEMENT.getInstance().MANGANESE, 150, + ELEMENT.getInstance().ALUMINIUM, 90, + ELEMENT.getInstance().OSMIUM, 20, + ELEMENT.getInstance().STRONTIUM, 10 + ); + //milledGrossular + registerOreDataForMilledType( + GrossularFlotationFroth, + ELEMENT.getInstance().CALCIUM, 180, + ELEMENT.getInstance().ALUMINIUM, 60, + ELEMENT.getInstance().TUNGSTEN, 30, + ELEMENT.getInstance().THALLIUM, 5 + ); + //milledAlmandine + registerOreDataForMilledType( + AlmandineFlotationFroth, + ELEMENT.getInstance().ALUMINIUM, 150, + ELEMENT.getInstance().MAGNESIUM, 50, + ELEMENT.getInstance().YTTRIUM, 15, + ELEMENT.getInstance().YTTERBIUM, 5 + ); + //milledPyrope + registerOreDataForMilledType( + PyropeFlotationFroth, + ELEMENT.getInstance().MAGNESIUM, 110, + ELEMENT.getInstance().MANGANESE, 70, + MaterialUtils.generateMaterialFromGtENUM(Materials.Borax), 16, + ELEMENT.getInstance().RHENIUM, 4 + ); } @@ -170,85 +252,172 @@ public class MilledOreProcessing extends ItemPackage { addPineOilExtraction(); addFlotationRecipes1(); addFlotationRecipes2(); + addVacuumFurnaceRecipes(); return true; } - - private void addFlotationRecipes2() { + + private void addVacuumFurnaceRecipes() { + int aCircuitID = 1; - // Redstone - CORE.RA.addFlotationRecipe( - Materials.Redstone, - ItemUtils.getSimpleStack(GenericChem.mSodiumEthylXanthate, 1), + CORE.RA.addVacuumFurnaceRecipe( + new ItemStack[] { + CI.getNumberedCircuit(aCircuitID++) + }, new FluidStack[] { - FluidUtils.getFluidStack(PineOil, 3000), + FluidUtils.getFluidStack(SphaleriteFlotationFroth, 4000) + }, + getOutputsFromMap(SphaleriteFlotationFroth), + new FluidStack[] { + FluidUtils.getFluidStack(AgriculturalChem.RedMud, 2000), + FluidUtils.getWater(2000) }, + 20 * 120, + MaterialUtils.getVoltageForTier(6), + 5500); + CORE.RA.addVacuumFurnaceRecipe( + new ItemStack[] { + CI.getNumberedCircuit(aCircuitID++) + }, new FluidStack[] { - FluidUtils.getFluidStack(RedstoneFlotationFroth, 1000) + FluidUtils.getFluidStack(ChalcopyriteFlotationFroth, 4000) }, - 20 * 1200, - MaterialUtils.getVoltageForTier(5) - ); + getOutputsFromMap(ChalcopyriteFlotationFroth), + new FluidStack[] { + FluidUtils.getFluidStack(AgriculturalChem.RedMud, 2000), + FluidUtils.getWater(2000) + }, + 20 * 120, + MaterialUtils.getVoltageForTier(5), + 4500); - // Spessartine - CORE.RA.addFlotationRecipe( - Materials.Spessartine, - ItemUtils.getSimpleStack(GenericChem.mPotassiumEthylXanthate, 1), + CORE.RA.addVacuumFurnaceRecipe( + new ItemStack[] { + CI.getNumberedCircuit(aCircuitID++) + }, new FluidStack[] { - FluidUtils.getFluidStack(PineOil, 5000), + FluidUtils.getFluidStack(NickelFlotationFroth, 4000) + }, + getOutputsFromMap(NickelFlotationFroth), + new FluidStack[] { + FluidUtils.getFluidStack(AgriculturalChem.RedMud, 2000), + FluidUtils.getWater(2000) }, + 20 * 120, + MaterialUtils.getVoltageForTier(5), + 4500); + CORE.RA.addVacuumFurnaceRecipe( + new ItemStack[] { + CI.getNumberedCircuit(aCircuitID++) + }, new FluidStack[] { - FluidUtils.getFluidStack(SpessartineFlotationFroth, 1000) + FluidUtils.getFluidStack(PlatinumFlotationFroth, 4000) }, - 20 * 1200, - MaterialUtils.getVoltageForTier(6) - ); - - // Grossular - CORE.RA.addFlotationRecipe( - Materials.Grossular, - ItemUtils.getSimpleStack(GenericChem.mPotassiumEthylXanthate, 1), + getOutputsFromMap(PlatinumFlotationFroth), new FluidStack[] { - FluidUtils.getFluidStack(PineOil, 5000), + FluidUtils.getFluidStack(AgriculturalChem.RedMud, 2000), + FluidUtils.getWater(2000) }, + 20 * 120, + MaterialUtils.getVoltageForTier(6), + 5500); + CORE.RA.addVacuumFurnaceRecipe( + new ItemStack[] { + CI.getNumberedCircuit(aCircuitID++) + }, new FluidStack[] { - FluidUtils.getFluidStack(GrossularFlotationFroth, 1000) + FluidUtils.getFluidStack(PentlanditeFlotationFroth, 4000) }, - 20 * 1200, - MaterialUtils.getVoltageForTier(6) - ); + getOutputsFromMap(PentlanditeFlotationFroth), + new FluidStack[] { + FluidUtils.getFluidStack(AgriculturalChem.RedMud, 2000), + FluidUtils.getWater(2000) + }, + 20 * 120, + MaterialUtils.getVoltageForTier(6), + 5500); - // Almandine - CORE.RA.addFlotationRecipe( - Materials.Almandine, - ItemUtils.getSimpleStack(GenericChem.mSodiumEthylXanthate, 1), + + + CORE.RA.addVacuumFurnaceRecipe( + new ItemStack[] { + CI.getNumberedCircuit(aCircuitID++) + }, new FluidStack[] { - FluidUtils.getFluidStack(PineOil, 4000), + FluidUtils.getFluidStack(RedstoneFlotationFroth, 4000) + }, + getOutputsFromMap(RedstoneFlotationFroth), + new FluidStack[] { + FluidUtils.getFluidStack(AgriculturalChem.RedMud, 2000), + FluidUtils.getWater(2000) + }, + 20 * 120, + MaterialUtils.getVoltageForTier(5), + 4500); + CORE.RA.addVacuumFurnaceRecipe( + new ItemStack[] { + CI.getNumberedCircuit(aCircuitID++) + }, + new FluidStack[] { + FluidUtils.getFluidStack(SpessartineFlotationFroth, 4000) + }, + getOutputsFromMap(SpessartineFlotationFroth), + new FluidStack[] { + FluidUtils.getFluidStack(AgriculturalChem.RedMud, 2000), + FluidUtils.getWater(2000) }, + 20 * 120, + MaterialUtils.getVoltageForTier(6), + 5500); + CORE.RA.addVacuumFurnaceRecipe( + new ItemStack[] { + CI.getNumberedCircuit(aCircuitID++) + }, new FluidStack[] { - FluidUtils.getFluidStack(AlmandineFlotationFroth, 1000) + FluidUtils.getFluidStack(GrossularFlotationFroth, 4000) }, - 20 * 1200, - MaterialUtils.getVoltageForTier(5) - ); - - // Pyrope - CORE.RA.addFlotationRecipe( - Materials.Pyrope, - ItemUtils.getSimpleStack(GenericChem.mSodiumEthylXanthate, 1), + getOutputsFromMap(GrossularFlotationFroth), new FluidStack[] { - FluidUtils.getFluidStack(PineOil, 2000), + FluidUtils.getFluidStack(AgriculturalChem.RedMud, 2000), + FluidUtils.getWater(2000) }, + 20 * 120, + MaterialUtils.getVoltageForTier(6), + 5500); + CORE.RA.addVacuumFurnaceRecipe( + new ItemStack[] { + CI.getNumberedCircuit(aCircuitID++) + }, new FluidStack[] { - FluidUtils.getFluidStack(PyropeFlotationFroth, 1000) + FluidUtils.getFluidStack(AlmandineFlotationFroth, 4000) }, - 20 * 1200, - MaterialUtils.getVoltageForTier(4) - ); + getOutputsFromMap(AlmandineFlotationFroth), + new FluidStack[] { + FluidUtils.getFluidStack(AgriculturalChem.RedMud, 2000), + FluidUtils.getWater(2000) + }, + 20 * 120, + MaterialUtils.getVoltageForTier(6), + 5500); + CORE.RA.addVacuumFurnaceRecipe( + new ItemStack[] { + CI.getNumberedCircuit(aCircuitID++) + }, + new FluidStack[] { + FluidUtils.getFluidStack(PyropeFlotationFroth, 4000) + }, + getOutputsFromMap(PyropeFlotationFroth), + new FluidStack[] { + FluidUtils.getFluidStack(AgriculturalChem.RedMud, 2000), + FluidUtils.getWater(2000) + }, + 20 * 120, + MaterialUtils.getVoltageForTier(4), + 3500); } private void addFlotationRecipes1() { - + // Sphalerite CORE.RA.addFlotationRecipe( Materials.Sphalerite, @@ -262,7 +431,7 @@ public class MilledOreProcessing extends ItemPackage { 20 * 1200, MaterialUtils.getVoltageForTier(6) ); - + // Chalcopyrite CORE.RA.addFlotationRecipe( Materials.Chalcopyrite, @@ -276,7 +445,7 @@ public class MilledOreProcessing extends ItemPackage { 20 * 1200, MaterialUtils.getVoltageForTier(5) ); - + // Nickel CORE.RA.addFlotationRecipe( Materials.Nickel, @@ -290,7 +459,7 @@ public class MilledOreProcessing extends ItemPackage { 20 * 1200, MaterialUtils.getVoltageForTier(5) ); - + // Platinum CORE.RA.addFlotationRecipe( Materials.Platinum, @@ -304,8 +473,8 @@ public class MilledOreProcessing extends ItemPackage { 20 * 1200, MaterialUtils.getVoltageForTier(6) ); - - + + // Pentlandite CORE.RA.addFlotationRecipe( Materials.Pentlandite, @@ -320,7 +489,80 @@ public class MilledOreProcessing extends ItemPackage { MaterialUtils.getVoltageForTier(6) ); - + } + + private void addFlotationRecipes2() { + + // Redstone + CORE.RA.addFlotationRecipe( + Materials.Redstone, + ItemUtils.getSimpleStack(GenericChem.mSodiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 3000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(RedstoneFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(5) + ); + + // Spessartine + CORE.RA.addFlotationRecipe( + Materials.Spessartine, + ItemUtils.getSimpleStack(GenericChem.mPotassiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 5000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(SpessartineFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(6) + ); + + // Grossular + CORE.RA.addFlotationRecipe( + Materials.Grossular, + ItemUtils.getSimpleStack(GenericChem.mPotassiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 5000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(GrossularFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(6) + ); + + // Almandine + CORE.RA.addFlotationRecipe( + Materials.Almandine, + ItemUtils.getSimpleStack(GenericChem.mSodiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 4000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(AlmandineFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(5) + ); + + // Pyrope + CORE.RA.addFlotationRecipe( + Materials.Pyrope, + ItemUtils.getSimpleStack(GenericChem.mSodiumEthylXanthate, 1), + new FluidStack[] { + FluidUtils.getFluidStack(PineOil, 2000), + }, + new FluidStack[] { + FluidUtils.getFluidStack(PyropeFlotationFroth, 1000) + }, + 20 * 1200, + MaterialUtils.getVoltageForTier(4) + ); + } private void addPineOilExtraction() { @@ -354,7 +596,7 @@ public class MilledOreProcessing extends ItemPackage { aLeaves.add(aForestryLeaves); } } - + for (ItemStack aLog : aLogs) { addRecipe(aLog, ItemUtils.getSimpleStack(aCrushedPine, 16), new int[] {10000, 7500, 5000, 2500}, 10, 120); } @@ -367,7 +609,7 @@ public class MilledOreProcessing extends ItemPackage { for (ItemStack aCone : aPinecones) { addRecipe(aCone, ItemUtils.getSimpleStack(aCrushedPine, 1), new int[] {7500, 7500, 5000, 2500}, 10, 60); } - + CORE.RA.addChemicalPlantRecipe( new ItemStack[] { @@ -387,12 +629,12 @@ public class MilledOreProcessing extends ItemPackage { FluidUtils.getFluidStack(PineOil, 1000) }, new int[] { - 2000, 2000, 2000, 2000 + 2000, 2000, 2000, 2000 }, 20 *60, 120, 2); - + CORE.RA.addChemicalPlantRecipe( new ItemStack[] { CI.getNumberedBioCircuit(18), @@ -411,7 +653,7 @@ public class MilledOreProcessing extends ItemPackage { FluidUtils.getFluidStack(PineOil, 2000) }, new int[] { - 3000, 3000, 3000, 3000 + 3000, 3000, 3000, 3000 }, 20 *60, 120, @@ -429,18 +671,18 @@ public class MilledOreProcessing extends ItemPackage { if ((GT_Utility.isStackInvalid(aInput)) || (GT_Utility.isStackInvalid(aOutput1) || (GT_Utility.getContainerItem(aInput, false) != null))) { return false; } - + return CORE.RA.addChemicalPlantRecipe( new ItemStack[] { CI.getNumberedBioCircuit(14), aInput }, new FluidStack[] { - + }, aOutputs, new FluidStack[] { - + }, aChances, aTime * 20, @@ -465,4 +707,74 @@ public class MilledOreProcessing extends ItemPackage { } return aOutput; } + + private static final HashMap, Pair, Pair, Pair>> aMilledFluidMap = new HashMap, Pair, Pair, Pair>>(); + + public static void registerOreDataForMilledType(Fluid aMilledFluid, Materials aOutput1, int aPerc1, Materials aOutput2, int aPerc2, Materials aOutput3, int aPerc3, Materials aOutput4, int aPerc4) { + registerOreDataForMilledType(aMilledFluid, MaterialUtils.generateMaterialFromGtENUM(aOutput1), aPerc1, MaterialUtils.generateMaterialFromGtENUM(aOutput2), aPerc2, MaterialUtils.generateMaterialFromGtENUM(aOutput3), aPerc3, MaterialUtils.generateMaterialFromGtENUM(aOutput4), aPerc4); + } + + public static void registerOreDataForMilledType(Fluid aMilledFluid, Material aOutput1, int aPerc1, Material aOutput2, int aPerc2, Material aOutput3, int aPerc3, Material aOutput4, int aPerc4) { + + Pair aFluidOutput1 = new Pair