From 3b4e3b33b630e676b44aa8ec16baf7dd11138d5c Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 26 Jan 2022 11:21:01 +1100 Subject: Add materials, add multis, just look at the diff tbh --- .../java/com/elisis/gtnhlanth/GTNHLanthanides.java | 11 + .../com/elisis/gtnhlanth/common/CommonProxy.java | 2 - .../elisis/gtnhlanth/common/register/ItemList.java | 19 + .../common/register/WerkstoffMaterialPool.java | 357 ++++++++++++- .../gtnhlanth/common/tileentity/Digester.java | 206 ++++++++ .../common/tileentity/DissolutionTank.java | 0 .../gtnhlanth/loader/MetaTileEntity_Loader.java | 5 + .../com/elisis/gtnhlanth/loader/RecipeAdder.java | 91 ++++ .../com/elisis/gtnhlanth/loader/RecipeLoader.java | 587 +++++++++++++++++++++ .../gtnhlanth/util/DescTextLocalization.java | 18 + 10 files changed, 1289 insertions(+), 7 deletions(-) create mode 100644 src/main/java/com/elisis/gtnhlanth/common/register/ItemList.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/tileentity/Digester.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/tileentity/DissolutionTank.java create mode 100644 src/main/java/com/elisis/gtnhlanth/loader/MetaTileEntity_Loader.java create mode 100644 src/main/java/com/elisis/gtnhlanth/loader/RecipeAdder.java create mode 100644 src/main/java/com/elisis/gtnhlanth/loader/RecipeLoader.java create mode 100644 src/main/java/com/elisis/gtnhlanth/util/DescTextLocalization.java (limited to 'src') diff --git a/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java b/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java index 6f22d039e5..5e900fdf55 100644 --- a/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java +++ b/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java @@ -1,7 +1,11 @@ package com.elisis.gtnhlanth; +import java.util.logging.Logger; + import com.elisis.gtnhlanth.common.CommonProxy; +import com.elisis.gtnhlanth.common.register.ItemList; import com.elisis.gtnhlanth.common.register.WerkstoffMaterialPool; +import com.elisis.gtnhlanth.loader.RecipeLoader; import com.github.bartimaeusnek.bartworks.API.WerkstoffAdderRegistry; import cpw.mods.fml.common.Mod; @@ -13,9 +17,13 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent; @Mod(modid = Tags.MODID, version = Tags.VERSION, name = Tags.MODNAME, dependencies = "required-after:IC2; " + "required-after:gregtech; " + + "required-after:bartworks; " + + "required-after:GoodGenerator; " ) public class GTNHLanthanides { + public static Logger LOG = Logger.getLogger("GTNH:Lanthanides"); + @Mod.Instance public static GTNHLanthanides instance; @@ -25,6 +33,7 @@ public class GTNHLanthanides { @EventHandler public static void preInit(FMLPreInitializationEvent e) { WerkstoffAdderRegistry.addWerkstoffAdder(new WerkstoffMaterialPool()); + ItemList.register(); proxy.preInit(e); } @@ -35,6 +44,8 @@ public class GTNHLanthanides { @EventHandler public static void postInit(FMLPostInitializationEvent e) { + RecipeLoader.loadGeneral(); + RecipeLoader.loadLanthanideRecipes(); proxy.postInit(e); } diff --git a/src/main/java/com/elisis/gtnhlanth/common/CommonProxy.java b/src/main/java/com/elisis/gtnhlanth/common/CommonProxy.java index c99a60fd79..a1022cf699 100644 --- a/src/main/java/com/elisis/gtnhlanth/common/CommonProxy.java +++ b/src/main/java/com/elisis/gtnhlanth/common/CommonProxy.java @@ -1,7 +1,5 @@ package com.elisis.gtnhlanth.common; -import java.util.logging.Logger; - import cpw.mods.fml.common.event.FMLInitializationEvent; import cpw.mods.fml.common.event.FMLPostInitializationEvent; import cpw.mods.fml.common.event.FMLPreInitializationEvent; diff --git a/src/main/java/com/elisis/gtnhlanth/common/register/ItemList.java b/src/main/java/com/elisis/gtnhlanth/common/register/ItemList.java new file mode 100644 index 0000000000..9f70c70d78 --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/register/ItemList.java @@ -0,0 +1,19 @@ +package com.elisis.gtnhlanth.common.register; + +import com.elisis.gtnhlanth.common.tileentity.Digester; + +import net.minecraft.item.ItemStack; + +public final class ItemList { + + public static ItemStack DIGESTER; + + public static void register() { + + ItemList.DIGESTER = new Digester(10500, "Digester", "Digester").getStackForm(1L); + + } + + + +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/register/WerkstoffMaterialPool.java b/src/main/java/com/elisis/gtnhlanth/common/register/WerkstoffMaterialPool.java index ec8bb8cbbf..dca342fded 100644 --- a/src/main/java/com/elisis/gtnhlanth/common/register/WerkstoffMaterialPool.java +++ b/src/main/java/com/elisis/gtnhlanth/common/register/WerkstoffMaterialPool.java @@ -3,6 +3,7 @@ package com.elisis.gtnhlanth.common.register; import static com.github.bartimaeusnek.bartworks.util.BW_Util.subscriptNumbers; import com.github.bartimaeusnek.bartworks.system.material.Werkstoff; +import com.github.bartimaeusnek.bartworks.system.material.Werkstoff.GenerationFeatures; import gregtech.api.enums.TextureSet; @@ -12,6 +13,28 @@ public class WerkstoffMaterialPool implements Runnable { private static final int offsetID = 11_000; //Misc. + public static final Werkstoff Hafnium = new Werkstoff( + new short[] {232, 224, 219}, + "Hafnium", + subscriptNumbers("Hf"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().onlyDust().addMetalItems().enforceUnification(), //Perhaps use hafnia liquid in elemental hafnium synthesis + offsetID, + TextureSet.SET_DULL + ); + + public static final Werkstoff LowPurityHafnium = new Werkstoff( + new short[] {240, 223, 208}, + "Low-Purity Hafnium", + subscriptNumbers("??Hf??"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().onlyDust(), //Perhaps use hafnia liquid in elemental hafnium synthesis + offsetID + 1, + TextureSet.SET_DULL + ); + public static final Werkstoff Hafnia = new Werkstoff( new short[] {247, 223, 203}, "Hafnia", @@ -19,10 +42,122 @@ public class WerkstoffMaterialPool implements Runnable { new Werkstoff.Stats(), Werkstoff.Types.COMPOUND, new Werkstoff.GenerationFeatures().disable().onlyDust(), //Perhaps use hafnia liquid in elemental hafnium synthesis - offsetID, + offsetID + 2, + TextureSet.SET_DULL + ); + + public static final Werkstoff HafniumTetrachloride = new Werkstoff( + new short[] {238, 247, 249}, + "Hafnium Tetrachloride", + subscriptNumbers("HfCl4"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 3, TextureSet.SET_DULL ); + public static final Werkstoff HafniumTetrachlorideSolution = new Werkstoff( + new short[] {238, 247, 249}, + "Hafnium Tetrachloride Solution", + subscriptNumbers("HfCl4"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().addCells(), + offsetID + 4, + TextureSet.SET_FLUID + ); + + public static final Werkstoff HafniumIodide = new Werkstoff( + new short[] {216, 60, 1}, + "Hafnium Iodide", + subscriptNumbers("HfI4"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 5, + TextureSet.SET_DULL + ); + + public static final Werkstoff HafniumRunoff = new Werkstoff( + new short[] {74, 65, 42}, //Literally the statistically ugliest colour + "Hafnium Runoff", + subscriptNumbers("??????"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 6, + TextureSet.SET_DULL + ); + + public static final Werkstoff Zirconium = new Werkstoff( + new short[] {225,230,225}, + "Zirconium", + subscriptNumbers("Zr"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().addMetalItems().enforceUnification(), + offsetID + 7, + TextureSet.SET_DULL + + ); + + public static final Werkstoff Zirconia = new Werkstoff( + new short[] {177,152,101}, + "Zirconia", + subscriptNumbers("ZrO2"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 8, + TextureSet.SET_DULL + + ); + + public static final Werkstoff ZirconiumTetrachloride = new Werkstoff( + new short[] {179, 164, 151}, + "Zirconium Tetrachloride", + subscriptNumbers("ZrCl4"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 9, + TextureSet.SET_DULL + ); + + public static final Werkstoff ZirconiumTetrachlorideSolution = new Werkstoff( + new short[] {179, 164, 151}, + "Zirconium Tetrachloride Solution", + subscriptNumbers("ZrCl4"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().addCells(), //Blast Furnace needs liquid input because it can't do 3 item inputs so have a shitty material + offsetID + 10, + TextureSet.SET_FLUID + ); + + public static final Werkstoff HafniaZirconiaBlend = new Werkstoff( + new short[] {247, 223, 203}, + "Hafnia-Zirconia Blend", // Maybe Hafnon?? + subscriptNumbers("??HfZr??"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 11, + TextureSet.SET_DULL + ); + + public static final Werkstoff Iodine = new Werkstoff( + new short[] {171, 40, 175}, + "Iodine", + subscriptNumbers("I"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().addCells().enforceUnification(), + offsetID + 12, + TextureSet.SET_FLUID + ); + //Lanthanide Line public static final Werkstoff MuddyRareEarthSolution = new Werkstoff( @@ -32,7 +167,7 @@ public class WerkstoffMaterialPool implements Runnable { new Werkstoff.Stats(), Werkstoff.Types.MIXTURE, new Werkstoff.GenerationFeatures().disable().addCells(), - offsetID + 1, + offsetID + 14, TextureSet.SET_FLUID ); @@ -43,7 +178,7 @@ public class WerkstoffMaterialPool implements Runnable { new Werkstoff.Stats(), Werkstoff.Types.MIXTURE, new Werkstoff.GenerationFeatures().disable().addCells(), - offsetID + 2, + offsetID + 15, TextureSet.SET_FLUID ); @@ -54,11 +189,223 @@ public class WerkstoffMaterialPool implements Runnable { new Werkstoff.Stats(), Werkstoff.Types.MIXTURE, new Werkstoff.GenerationFeatures().disable().addCells(), - offsetID + 3, + offsetID + 16, TextureSet.SET_FLUID ); - + public static final Werkstoff NitratedRareEarthConcentrate = new Werkstoff( + new short[] {250, 223, 173}, + "Nitrated Rare Earth Concentrate", + subscriptNumbers("??LaNd??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().addCells(), + offsetID + 17, + TextureSet.SET_FLUID + ); + + public static final Werkstoff NitricLeachedConcentrate = new Werkstoff( + new short[] {244, 202, 22}, + "Nitric Leached Concentrate", + subscriptNumbers("??LaNd??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().addCells(), + offsetID + 18, + TextureSet.SET_FLUID + ); + + public static final Werkstoff MonaziteSulfate = new Werkstoff( + new short[] {152, 118, 84}, + "Monazite Sulfate", + subscriptNumbers("??CeEu??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 19, + TextureSet.SET_DULL + ); + + public static final Werkstoff AcidicMonazitePowder = new Werkstoff( + new short[] {50, 23, 77}, + "Acidic Monazite Powder", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 20, + TextureSet.SET_DULL + ); + + public static final Werkstoff RareEarthFiltrate = new Werkstoff( + new short[] {72, 60, 50}, + "Rare Earth Filtrate", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 21, + TextureSet.SET_DULL + ); + + public static final Werkstoff NeutralizedRareEarthFiltrate = new Werkstoff( + new short[] {50, 23, 77}, + "Neutralized Rare Earth Filtrate", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 22, + TextureSet.SET_DULL + ); + + public static final Werkstoff RareEarthHydroxideConcentrate = new Werkstoff( + new short[] {193, 154, 107}, + "Rare Earth Hydroxide Concentrate", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 23, + TextureSet.SET_DULL + ); + + public static final Werkstoff DriedRareEarthConcentrate = new Werkstoff( + new short[] {250, 214, 165}, + "Dried Rare Earth Concentrate", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 24, + TextureSet.SET_DULL + ); + + public static final Werkstoff CeriumDioxide = new Werkstoff( + new short[] {255, 255, 255}, + "Cerium Dioxide", + subscriptNumbers("CeO2"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust().enforceUnification(), + offsetID + 25, + TextureSet.SET_DULL + ); + + public static final Werkstoff CeriumChloride = new Werkstoff( + new short[] {255, 255, 255}, + "Cerium Chloride", + subscriptNumbers("CeCl3"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 26, + TextureSet.SET_DULL + ); + + public static final Werkstoff CeriumOxalate = new Werkstoff( + new short[] {255, 255, 224}, + "Cerium Oxalate", + subscriptNumbers("Ce2(C2O4)3"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 27, + TextureSet.SET_DULL + ); + + public static final Werkstoff CeriumIIIOxide = new Werkstoff( + new short[] {255, 255, 102}, + "Cerium (III) Oxide", + subscriptNumbers("Ce2O3"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 28, + TextureSet.SET_DULL + ); + + public static final Werkstoff CeriumRichMixture = new Werkstoff( + new short[] {244, 164, 96}, + "Cerium-Rich Mixture", + subscriptNumbers("??Ce??"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 29, + TextureSet.SET_DULL + ); + + public static final Werkstoff CooledRareEarthConcentrate = new Werkstoff( + new short[] {250, 214, 165}, + "Cooled Rare Earth Concentrate", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 30, + TextureSet.SET_DULL + ); + + public static final Werkstoff RarerEarthSediment = new Werkstoff( + new short[] {250, 214, 165}, + "Rarer Earth Sediment", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 31, + TextureSet.SET_DULL + ); + + public static final Werkstoff HeterogenousHalogenicRareEarthMixture = new Werkstoff( + new short[] {250, 214, 165}, + "Heterogenous Halogenic Rare Earth Mixture", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 32, + TextureSet.SET_DULL + ); + + public static final Werkstoff SaturatedRareEarthMixture = new Werkstoff( + new short[] {250, 214, 165}, + "Saturated Rare Earth Mixture", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 33, + TextureSet.SET_DULL + ); + + public static final Werkstoff SamaricResidue = new Werkstoff( + new short[] {248, 243, 231}, + "Samaric Residue", + subscriptNumbers("??SmGd??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 34, + TextureSet.SET_DULL + ); + + public static final Werkstoff MonaziteResidue = new Werkstoff( + new short[] {64, 69, 62}, + subscriptNumbers("??ZrHfTh??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable().onlyDust(), + offsetID + 35, + TextureSet.SET_DULL + ); + + + + + + @Override public void run() { diff --git a/src/main/java/com/elisis/gtnhlanth/common/tileentity/Digester.java b/src/main/java/com/elisis/gtnhlanth/common/tileentity/Digester.java new file mode 100644 index 0000000000..655408550c --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/tileentity/Digester.java @@ -0,0 +1,206 @@ +package com.elisis.gtnhlanth.common.tileentity; + +import static com.elisis.gtnhlanth.util.DescTextLocalization.BLUEPRINT_INFO; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose; +import static gregtech.api.util.GT_StructureUtility.ofCoil; +import static gregtech.api.util.GT_StructureUtility.ofHatchAdder; + +import java.util.ArrayList; + +import org.lwjgl.input.Keyboard; + +import com.elisis.gtnhlanth.loader.RecipeAdder; +import com.elisis.gtnhlanth.util.DescTextLocalization; +import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_GUIContainer_MultiMachineEM; +import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM; +import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.HeatingCoilLevel; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_Recipe; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + + +public class Digester extends GT_MetaTileEntity_MultiblockBase_EM implements IConstructable { + + protected int casingAmount = 0; + protected int height = 0; + + private HeatingCoilLevel heatLevel; + + @SuppressWarnings("deprecation") + private IStructureDefinition multiDefinition = StructureDefinition.builder() + .addShape(mName, transpose(new String[][] { + {"-------", "-ttttt-", "-t---t-", "-t---t-", "-t---t-", "-ttttt-", "-------"}, + {"--ttt--", "-t---t-", "t-----t", "t-----t", "t-----t", "-t---t-", "--ttt--"}, + {"-tccct-", "tc---ct", "c-----c", "c-----c", "c-----c", "tc---ct", "-tccct-"}, + {"-tt~tt-", "thhhhht", "thsssht", "thsssht", "thsssht", "thhhhht", "-ttttt-"}, + + + + + + })) + .addElement('t', ofChain( + ofHatchAdder(Digester::addInputToMachineList, 47, 1), + ofHatchAdder(Digester::addOutputToMachineList, 47, 1), + ofHatchAdder(Digester::addEnergyInputToMachineList, 47, 1), + ofHatchAdder(Digester::addMaintenanceToMachineList, 47, 1), + ofHatchAdder(Digester::addMufflerToMachineList, 47, 1), + ofBlock(GregTech_API.sBlockCasings4, 0) + )) + .addElement('h', ofBlock(GregTech_API.sBlockCasings1, 11)) + .addElement('s', ofBlock(GregTech_API.sBlockCasings4, 1)) + .addElement('c', ofCoil(Digester::setCoilLevel, Digester::getCoilLevel)) + .build(); + + + //private int mHeat; + //private int mNeededHeat; + + + public Digester(String name) { + super(name); + } + + public Digester(int id, String name, String nameRegional) { + super(id, name, nameRegional); + } + + + @Override + public IStructureDefinition getStructure_EM(){ + return multiDefinition; + } + + @Override + public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + return structureCheck_EM(mName, 3, 3, 0); + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return true; + } + + public HeatingCoilLevel getCoilLevel() { + return this.heatLevel; + } + + public void setCoilLevel(HeatingCoilLevel level) { + this.heatLevel = level; + } + + @Override + public boolean checkRecipe_EM(ItemStack itemStack) { + + ArrayList tFluidInputs = this.getStoredFluids(); + FluidStack[] tFluidInputArray = tFluidInputs.toArray(new FluidStack[0]); + ArrayList tItems = this.getStoredInputs(); + long tVoltage = this.getMaxInputVoltage(); + + //Collection tRecipes = RecipeAdder.instance.DigesterRecipes.mRecipeList; + GT_Recipe tRecipe = RecipeAdder.instance.DigesterRecipes.findRecipe( + this.getBaseMetaTileEntity(), + this.doTickProfilingInThisTick, + tVoltage, + this.mOutputFluids, + this.mInventory + ); + + if (tRecipe == null) + return false; + + if (tRecipe.isRecipeInputEqual(true, tFluidInputArray, mInventory[1])) { + + this.mEfficiency = (10000 - (this.getIdealStatus() - this.getRepairStatus()) * 1000); + this.mEfficiencyIncrease = 10000; + this.calculateOverclockedNessMulti(tRecipe.mEUt, tRecipe.mDuration, 1, tVoltage); + + if (mMaxProgresstime == Integer.MAX_VALUE - 1 && this.mEUt == Integer.MAX_VALUE - 1) + return false; + + if (tRecipe.mSpecialValue > this.getCoilLevel().getHeat()) + return false; + + if (this.mEUt > 0) + this.mEUt = (-this.mEUt); + + this.mOutputFluids = new FluidStack[] { + tRecipe.getFluidOutput(0) + }; + return true; + } + return false; + } + + @Override + public int getMaxEfficiency(ItemStack itemStack) { + return 10000; + } + + @Override + public int getPollutionPerTick(ItemStack aStack) { + return 200; + } + + @Override + public Object getClientGUI(int id, InventoryPlayer playerInventory, IGregTechTileEntity metaTileEntity) { + return new GT_GUIContainer_MultiMachineEM(playerInventory, metaTileEntity, getLocalName(), "Digester.png"); + } + + @Override + public String[] getDescription() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Digester") + .addInfo("Controller block for the Digester") + .addInfo("Input ores and fluid, output water.") + .addInfo("You will need to balance the heat provided") + .addInfo("to be able to complete the recipe.") + .addInfo(BLUEPRINT_INFO) + .addSeparator() + .addController("Front bottom") + .addInputHatch("Hint block with dot 1") + .addInputBus("Hint block with dot 1") + .addOutputHatch("Hint block with dot 2") + .addOutputBus("Hint block with dot 2") + .addMaintenanceHatch("Hint block with dot 2") + .addOtherStructurePart("Neutron Accelerator", "Hint block with dot 2") + .addOtherStructurePart("Neutron Sensor", "Hint block with dot 2") + .addCasingInfo("Clean Stainless Steel Machine Casing", 7) + .toolTipFinisher("GTNH: Lanthanides"); + if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { + return tt.getInformation(); + } else { + return tt.getStructureInformation(); + } + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity arg0) { + return new Digester(this.mName); + } + + @Override + public void construct(ItemStack itemStack, boolean b) { + structureBuild_EM(mName, 3, 3, 0, b, itemStack); + + } + + @Override + public String[] getStructureDescription(ItemStack arg0) { + return DescTextLocalization.addText("UniversalChemicalFuelEngine.hint", 11); + } + +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/tileentity/DissolutionTank.java b/src/main/java/com/elisis/gtnhlanth/common/tileentity/DissolutionTank.java new file mode 100644 index 0000000000..e69de29bb2 diff --git a/src/main/java/com/elisis/gtnhlanth/loader/MetaTileEntity_Loader.java b/src/main/java/com/elisis/gtnhlanth/loader/MetaTileEntity_Loader.java new file mode 100644 index 0000000000..a2cd209a13 --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/loader/MetaTileEntity_Loader.java @@ -0,0 +1,5 @@ +package com.elisis.gtnhlanth.loader; + +public class MetaTileEntity_Loader { + +} diff --git a/src/main/java/com/elisis/gtnhlanth/loader/RecipeAdder.java b/src/main/java/com/elisis/gtnhlanth/loader/RecipeAdder.java new file mode 100644 index 0000000000..fa17bc4bdd --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/loader/RecipeAdder.java @@ -0,0 +1,91 @@ +package com.elisis.gtnhlanth.loader; + +import java.util.Collection; +import java.util.HashSet; + +import gregtech.api.util.GT_Recipe; +import net.minecraft.item.ItemStack; +import net.minecraft.util.StatCollector; +import net.minecraftforge.fluids.FluidStack; + +public class RecipeAdder { + + + + public static final RecipeAdder instance = new RecipeAdder(); + + public final DigestMap DigesterRecipes = new DigestMap( + new HashSet<>(100), + "gtnhlanth.recipe.digester", + StatCollector.translateToLocal("tile.recipe.digester"), + null, + "gtnhlanth:textures/gui/digester", + 1, 1, 1, 1, 1, + StatCollector.translateToLocal("value.digester") + ": ", //Heat Capacity + 1, + "K", + false, + true + ); + + public final DissolutionTankMap DissolutionTankRecipes = new DissolutionTankMap( + new HashSet<>(100), + "gtnhlanth.recipe.disstank", + StatCollector.translateToLocal("tile.recipe.disstank"), + null, + "gtnhlanth:textures/gui/disstank", + 1, 1, 1, 1, 1, + StatCollector.translateToLocal("value.disstank") + " ", + 1, + " EU/t", + false, + true + ); + + + public class DigestMap extends GT_Recipe.GT_Recipe_Map { + + public DigestMap(Collection 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); + + } + + public void addDigesterRecipe(FluidStack[] fluidInputs, ItemStack[] itemInputs, FluidStack fluidOutput, ItemStack[] itemOutputs, int EUt, int ticks, int heat){ + super.addRecipe(false, itemInputs, itemOutputs, null, fluidInputs, new FluidStack[]{fluidOutput}, ticks, EUt, heat); + } + + + } + + public class DissolutionTankMap extends GT_Recipe.GT_Recipe_Map { + + public DissolutionTankMap(Collection 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); + + } + + public void addDissolutionTankRecipe(FluidStack[] fluidInputs, ItemStack[] itemInputs, FluidStack fluidOutput, ItemStack[] itemOutputs, int EUt, int ticks) { + super.addRecipe(false, itemInputs, itemOutputs, null, fluidInputs, new FluidStack[] {fluidOutput}, ticks, EUt, ticks); + } + + } + +} diff --git a/src/main/java/com/elisis/gtnhlanth/loader/RecipeLoader.java b/src/main/java/com/elisis/gtnhlanth/loader/RecipeLoader.java new file mode 100644 index 0000000000..2700154bee --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/loader/RecipeLoader.java @@ -0,0 +1,587 @@ +package com.elisis.gtnhlanth.loader; + +import static goodgenerator.items.MyMaterial.naquadahEarth; + +import java.util.HashSet; + +import com.elisis.gtnhlanth.Tags; +import com.elisis.gtnhlanth.common.register.WerkstoffMaterialPool; +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; + +import goodgenerator.crossmod.LoadedList; +import goodgenerator.items.MyMaterial; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GTPP_Recipe; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gregtech.common.items.CombType; +import gregtech.loaders.misc.GT_Bees; +import gtPlusPlus.xmod.gregtech.loaders.RecipeGen_MultisUsingFluidInsteadOfCells; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; + +public class RecipeLoader { + + private static final Materials[] BLACKLIST = null; + + public static void loadGeneral() { + + /* ZIRCONIUM */ + //ZrCl4 + GT_Values.RA.addChemicalRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.Zirconia.get(OrePrefixes.dust, 1), + Materials.HydrochloricAcid.getFluid(4000), + Materials.Water.getFluid(2000), + WerkstoffMaterialPool.ZirconiumTetrachloride.get(OrePrefixes.dust, 1), + 300 + ); + + //ZrCl4-H2O + GT_Values.RA.addChemicalRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.ZirconiumTetrachloride.get(OrePrefixes.dust, 1), + Materials.Water.getFluid(1000), + WerkstoffMaterialPool.ZirconiumTetrachlorideSolution.getFluidOrGas(1000), + null, + 200 + ); + + + //Zr + GT_Values.RA.addBlastRecipe( + GT_Utility.getIntegratedCircuit(2), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Magnesium, 2), + WerkstoffMaterialPool.ZirconiumTetrachlorideSolution.getFluidOrGas(1000), + null, //No fluid output + WerkstoffMaterialPool.Zirconium.get(OrePrefixes.ingotHot, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Magnesiumchloride, 2), + 600, 1920, 4500 + ); + + + /* HAFNIUM */ + //HfCl4 + GT_Values.RA.addChemicalRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.Hafnia.get(OrePrefixes.dust, 1), + Materials.HydrochloricAcid.getFluid(4000), + Materials.Water.getFluid(2000), + WerkstoffMaterialPool.HafniumTetrachloride.get(OrePrefixes.dust, 1), + 300 + ); + + //HfCl4-H2O + GT_Values.RA.addChemicalRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.HafniumTetrachloride.get(OrePrefixes.dust, 1), + Materials.Water.getFluid(1000), + WerkstoffMaterialPool.HafniumTetrachlorideSolution.getFluidOrGas(1000), + null, + 200 + ); + + //LP-Hf + GT_Values.RA.addBlastRecipe( + GT_Utility.getIntegratedCircuit(2), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Magnesium, 2), + WerkstoffMaterialPool.HafniumTetrachlorideSolution.getFluidOrGas(1000), + null, //No fluid output + WerkstoffMaterialPool.LowPurityHafnium.get(OrePrefixes.dust, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Magnesiumchloride, 2), + 600, 1920, 2700 + ); + + //HfI4 + GT_Values.RA.addChemicalRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.LowPurityHafnium.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.Iodine.getFluidOrGas(4000), + null, + WerkstoffMaterialPool.HafniumIodide.get(OrePrefixes.dust, 1), + 300 + ); + + //Hf + GT_Values.RA.addBlastRecipe( + GT_Utility.getIntegratedCircuit(12), + WerkstoffMaterialPool.HafniumIodide.get(OrePrefixes.dust, 1), + null, + WerkstoffMaterialPool.Iodine.getFluidOrGas(4000), + WerkstoffMaterialPool.Hafnium.get(OrePrefixes.ingotHot, 1), + WerkstoffMaterialPool.HafniumRunoff.get(OrePrefixes.dustTiny, 1), + 600, 1920, 3400 + ); + + + //Zirconia-Hafnia + GT_Values.RA.addCentrifugeRecipe( + WerkstoffMaterialPool.HafniaZirconiaBlend.get(OrePrefixes.dust, 1), + null, + null, + null, + WerkstoffMaterialPool.Hafnia.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.Zirconia.get(OrePrefixes.dust, 1), + null, + null, + null, + null, + new int[] {10000, 10000}, + 600, + 1920 + ); + + + + } + + public static void loadLanthanideRecipes() { + + removeCeriumSources(); + + // Methanol + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { + MyMaterial.vanadiumPentoxide.get(OrePrefixes.dustTiny, 0) + }, + new FluidStack[] { + Materials.Methanol.getFluid(1000), + Materials.CarbonMonoxide.getFluid(2000), + Materials.Oxygen.getFluid(3000) + }, + new FluidStack[] { + MyMaterial.oxalate.getFluidOrGas(1000) + + }, + null, + 450, + 600 + ); + + // Ethanol + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { + MyMaterial.vanadiumPentoxide.get(OrePrefixes.dustTiny, 0) + }, + new FluidStack[] { + Materials.Ethanol.getFluid(1000), + Materials.CarbonMonoxide.getFluid(3000), + Materials.Oxygen.getFluid(3000) + }, + new FluidStack[] { + MyMaterial.oxalate.getFluidOrGas(1000) + }, + null, + 450, + 600 + ); + + // CeCl3 + GT_Values.RA.addChemicalRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.CeriumDioxide.get(OrePrefixes.dust, 1), + WerkstoffLoader.AmmoniumChloride.getFluidOrGas(3000), + Materials.Ammonia.getFluid(3000), + WerkstoffMaterialPool.CeriumChloride.get(OrePrefixes.dust, 1), + 300, + 450 + ); + + //GT_Values.RA.addChemicalRecipe( + // GT_Utility.getIntegratedCircuit(2), + //WerkstoffMaterialPool.CeriumDioxide + // + //) + + // Cerium Oxalate + GT_Values.RA.addChemicalRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.CeriumChloride.get(OrePrefixes.dust, 2), + MyMaterial.oxalate.getFluidOrGas(3000), + Materials.HydrochloricAcid.getFluid(6000), + WerkstoffMaterialPool.CeriumOxalate.get(OrePrefixes.dust, 1), + 300, + 450 + ); + + + // Cerium III Oxide + GT_Values.RA.addBlastRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.CeriumOxalate.get(OrePrefixes.dust, 1), + null, + Materials.Water.getFluid(2000), + WerkstoffMaterialPool.CeriumIIIOxide.get(OrePrefixes.dust, 1), + null, + 600, + 1920, + 1500 + ); + + // Cerium + GT_Values.RA.addElectrolyzerRecipe( + WerkstoffMaterialPool.CeriumIIIOxide.get(OrePrefixes.dust, 5), + null, + null, + Materials.Oxygen.getFluid(3000), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cerium, 2), + null, + null, + null, + null, + null, + new int[]{10000}, + 150, + 120 + ); + + + //CHAIN BEGIN + + RecipeAdder.instance.DigesterRecipes.addDigesterRecipe( + new FluidStack[] {Materials.NitricAcid.getFluid(350)}, + new ItemStack[] {GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Monazite, 1)}, + WerkstoffMaterialPool.MuddyRareEarthSolution.getFluidOrGas(200), + new ItemStack[] { + WerkstoffMaterialPool.HafniaZirconiaBlend.get(OrePrefixes.dustTiny, 4), + Materials.SiliconDioxide.getDustSmall(2), + WerkstoffLoader.Thorianit.get(OrePrefixes.dust, 1) + }, + 1920, + 200, + 2700 + ); + + /*RecipeAdder.instance.DissolutionTankRecipes.addDissolutionTankRecipe( + new FluidStack[] { + Materials.Water.getFluid(10000), + WerkstoffMaterialPool.MuddyRareEarthSolution.getFluidOrGas(1000) + }, + null, + WerkstoffMaterialPool.DilutedRareEarthMud.getFluidOrGas(11000), + null, + 480, + 900 + ); + */ + GT_Recipe.GT_Recipe_Map.sSifterRecipes.addRecipe( + false, + null, + new ItemStack[] { + WerkstoffMaterialPool.MonaziteSulfate.get(OrePrefixes.dust, 1), + Materials.SiliconDioxide.getDust(1), + Materials.Rutile.getDust(1), + WerkstoffLoader.RedZircon.get(OrePrefixes.dust, 1), + Materials.Ilmenite.getDust(1) + }, + null, + new int[] { + 7500, 1000, 500, 2000 + }, + new FluidStack[] { + WerkstoffMaterialPool.DilutedRareEarthMud.getFluidOrGas(1000) + }, + null, + 400, + 240, + 0 + ); + + + + + + + + + + + + + + + + + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + private static void removeCeriumSources() { + + GT_Log.out.print(Tags.MODID + ": AAAAAA"); + + HashSet remove = new HashSet<>(5000); + HashSet reAdd = new HashSet<>(5000); + + //For Crusher + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.mRecipeList) { + ItemStack input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if ((OreDictionary.getOreName(oreDictID).startsWith("ore") || OreDictionary.getOreName(oreDictID).startsWith("crushed")) && OreDictionary.getOreName(oreDictID).contains("Cerium")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Crusher done!\n"); + + //For Washer + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sOreWasherRecipes.mRecipeList) { + ItemStack input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID).startsWith("crushed") && OreDictionary.getOreName(oreDictID).contains("Cerium")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GT_Recipe.GT_Recipe_Map.sOreWasherRecipes.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sOreWasherRecipes.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sOreWasherRecipes.reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Washer done!\n"); + + //For Thermal Centrifuge + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes.mRecipeList) { + ItemStack input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID).startsWith("crushed") && OreDictionary.getOreName(oreDictID).contains("Cerium")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadahEarth.get(OrePrefixes.dust, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes.reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Thermal Centrifuge done!\n"); + + //For Centrifuge + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.mRecipeList) { + ItemStack input = null; + if (recipe.mInputs.length > 0) input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + if (input.isItemEqual(GT_Bees.combs.getStackForType(CombType.DOB))){ + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dustTiny, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + } + else for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID).startsWith("dustPureCerium") || OreDictionary.getOreName(oreDictID).startsWith("dustImpureCerium") || OreDictionary.getOreName(oreDictID).startsWith("dustSpace") || OreDictionary.getOreName(oreDictID).startsWith("dustCerium")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dustTiny, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDustSmall(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dustSmall, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Centrifuge done!\n"); + + //For Hammer + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sHammerRecipes.mRecipeList) { + ItemStack input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID).startsWith("crushed") && OreDictionary.getOreName(oreDictID).contains("Cerium")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GT_Recipe.GT_Recipe_Map.sHammerRecipes.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sHammerRecipes.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sHammerRecipes.reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Hammer done!\n"); + + if (LoadedList.GTPP) { + //For Multi Centrifuge + //Blame alk. She made some shit in it, NEI will break down if anyone modify the hash list directly. + GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT.mRecipeList.clear(); + RecipeGen_MultisUsingFluidInsteadOfCells.generateRecipesNotUsingCells(GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes, GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT); + GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT.reInit(); + + //For Simple Washer + for (GT_Recipe recipe : GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes.mRecipeList) { + ItemStack input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID).startsWith("dustImpureCerium")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes.mRecipeList.removeAll(remove); + GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes.mRecipeList.addAll(reAdd); + GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes.reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Simple Washer done!\n"); + } + + //For ByProduct List + for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sByProductList.mRecipeList) { + ItemStack input = recipe.mInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID).startsWith("ore") && OreDictionary.getOreName(oreDictID).contains("Cerium")) { + GT_Recipe tRecipe = recipe.copy(); + for (int i = 0; i < tRecipe.mOutputs.length; i ++) { + if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue; + if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1)); + } + } + if (!tRecipe.equals(recipe)){ + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + GT_Recipe.GT_Recipe_Map.sByProductList.mRecipeList.removeAll(remove); + GT_Recipe.GT_Recipe_Map.sByProductList.mRecipeList.addAll(reAdd); + GT_Recipe.GT_Recipe_Map.sByProductList.reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("ByProduct List done!\n"); + } +} + + + diff --git a/src/main/java/com/elisis/gtnhlanth/util/DescTextLocalization.java b/src/main/java/com/elisis/gtnhlanth/util/DescTextLocalization.java new file mode 100644 index 0000000000..fc01d37ec4 --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/util/DescTextLocalization.java @@ -0,0 +1,18 @@ +package com.elisis.gtnhlanth.util; + +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; + +public class DescTextLocalization { + + public static final String BLUEPRINT_INFO = "Follow the" + EnumChatFormatting.BLUE + " Structure" + EnumChatFormatting.DARK_BLUE + "Lib" + EnumChatFormatting.GRAY + " hologram projector to build the main structure."; + + public static String[] addText(String preFix, int length){ + String[] text = new String[length]; + for (int i = 0; i < length; i ++) { + text[i] = StatCollector.translateToLocal(preFix + "." + i); + } + return text; + } + +} -- cgit