diff options
Diffstat (limited to 'lath/src/main')
19 files changed, 7270 insertions, 0 deletions
diff --git a/lath/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java b/lath/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java new file mode 100644 index 0000000000..944e36d0bc --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java @@ -0,0 +1,97 @@ +package com.elisis.gtnhlanth; + +import java.util.Arrays; +import java.util.logging.Logger; + +import net.minecraftforge.oredict.OreDictionary; + +import com.elisis.gtnhlanth.common.CommonProxy; +import com.elisis.gtnhlanth.common.register.BotWerkstoffMaterialPool; +import com.elisis.gtnhlanth.common.register.LanthItemList; +import com.elisis.gtnhlanth.common.register.WerkstoffMaterialPool; +import com.elisis.gtnhlanth.loader.BotRecipes; +import com.elisis.gtnhlanth.loader.RecipeLoader; +import com.github.bartimaeusnek.bartworks.API.WerkstoffAdderRegistry; +import com.github.bartimaeusnek.bartworks.system.material.Werkstoff; + +import cpw.mods.fml.common.Mod; +import cpw.mods.fml.common.Mod.EventHandler; +import cpw.mods.fml.common.SidedProxy; +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLLoadCompleteEvent; +import cpw.mods.fml.common.event.FMLPostInitializationEvent; +import cpw.mods.fml.common.event.FMLPreInitializationEvent; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_Log; + +@Mod( + modid = Tags.MODID, + version = Tags.VERSION, + name = Tags.MODNAME, + dependencies = "required-after:IC2; " + "required-after:gregtech; " + + "required-after:bartworks; " + + "required-after:GoodGenerator; " + + "before:miscutils; ") +public class GTNHLanthanides { + + public static Logger LOG = Logger.getLogger("GTNH:Lanthanides"); + + @Mod.Instance + public static GTNHLanthanides instance; + + @SidedProxy( + clientSide = "com.elisis.gtnhlanth.client.ClientProxy", + serverSide = "com.elisis.gtnhlanth.common.CommonProxy") + public static CommonProxy proxy; + + @EventHandler + public static void preInit(FMLPreInitializationEvent e) { + WerkstoffAdderRegistry.addWerkstoffAdder(new WerkstoffMaterialPool()); + WerkstoffAdderRegistry.addWerkstoffAdder(new BotWerkstoffMaterialPool()); + LanthItemList.register(); + // GregTech_API.sAfterGTPostload.add(new ZPMRubberChanges()); + proxy.preInit(e); + } + + @EventHandler + public static void init(FMLInitializationEvent e) { + proxy.init(e); + WerkstoffMaterialPool.runInit(); + } + + @EventHandler + public static void postInit(FMLPostInitializationEvent e) { + RecipeLoader.loadGeneral(); + RecipeLoader.loadLanthanideRecipes(); + RecipeLoader.addRandomChemCrafting(); + BotRecipes.addGTRecipe(); + // RecipeLoader.loadZylonRecipes(); + proxy.postInit(e); + // GT_Log.out.print(FluidRegistry.getFluid("Sodium Tungstate").getName()); + + GT_Log.out.print( + Arrays.toString( + Werkstoff.werkstoffNameHashMap.keySet() + .toArray())); + GT_Log.out.print( + Arrays.toString( + Werkstoff.werkstoffHashMap.keySet() + .toArray())); + + GT_Log.out.print( + "HMMM " + Arrays.toString( + OreDictionary + .getOreIDs(WerkstoffMaterialPool.DephosphatedSamariumConcentrate.get(OrePrefixes.dust, 1)))); + } + + @EventHandler + public static void onModLoadingComplete(FMLLoadCompleteEvent e) { + GT_Log.out.print("AAAAAAAAAAAAAA"); + // + GT_Log.out.print("We are done loading"); + BotRecipes.removeRecipes(); + RecipeLoader.removeCeriumSources(); + + GT_Log.out.print("blah blah " + WerkstoffMaterialPool.PTMEGElastomer.hasGenerationFeature(OrePrefixes.ingot)); + } +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/Tags.java b/lath/src/main/java/com/elisis/gtnhlanth/Tags.java new file mode 100644 index 0000000000..93666809ba --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/Tags.java @@ -0,0 +1,9 @@ +package com.elisis.gtnhlanth; + +public class Tags { + + public static final String MODID = "GRADLETOKEN_MODID"; + public static final String MODNAME = "GRADLETOKEN_MODNAME"; + public static final String VERSION = "GRADLETOKEN_VERSION"; + public static final String GROUPNAME = "GRADLETOKEN_GROUPNAME"; +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/api/recipe/LanthanidesRecipeMaps.java b/lath/src/main/java/com/elisis/gtnhlanth/api/recipe/LanthanidesRecipeMaps.java new file mode 100644 index 0000000000..4bf100b1d4 --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/api/recipe/LanthanidesRecipeMaps.java @@ -0,0 +1,25 @@ +package com.elisis.gtnhlanth.api.recipe; + +import gregtech.api.gui.modularui.GT_UITextures; +import gregtech.api.recipe.RecipeMap; +import gregtech.api.recipe.RecipeMapBackend; +import gregtech.api.recipe.RecipeMapBuilder; +import gregtech.nei.formatter.HeatingCoilSpecialValueFormatter; +import gregtech.nei.formatter.SimpleSpecialValueFormatter; + +public class LanthanidesRecipeMaps { + + public static final RecipeMap<RecipeMapBackend> digesterRecipes = RecipeMapBuilder.of("gtnhlanth.recipe.digester") + .maxIO(1, 1, 1, 1) + .minInputs(1, 1) + .progressBar(GT_UITextures.PROGRESSBAR_ARROW_MULTIPLE) + .neiSpecialInfoFormatter(HeatingCoilSpecialValueFormatter.INSTANCE) + .build(); + public static final RecipeMap<RecipeMapBackend> dissolutionTankRecipes = RecipeMapBuilder + .of("gtnhlanth.recipe.disstank") + .maxIO(2, 3, 2, 1) + .minInputs(1, 1) + .progressBar(GT_UITextures.PROGRESSBAR_ARROW_MULTIPLE) + .neiSpecialInfoFormatter(new SimpleSpecialValueFormatter("value.disstank")) + .build(); +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/client/ClientProxy.java b/lath/src/main/java/com/elisis/gtnhlanth/client/ClientProxy.java new file mode 100644 index 0000000000..4420975173 --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/client/ClientProxy.java @@ -0,0 +1,6 @@ +package com.elisis.gtnhlanth.client; + +import com.elisis.gtnhlanth.common.CommonProxy; + +public class ClientProxy extends CommonProxy { +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/common/CommonProxy.java b/lath/src/main/java/com/elisis/gtnhlanth/common/CommonProxy.java new file mode 100644 index 0000000000..6e77ba200f --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/common/CommonProxy.java @@ -0,0 +1,14 @@ +package com.elisis.gtnhlanth.common; + +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLPostInitializationEvent; +import cpw.mods.fml.common.event.FMLPreInitializationEvent; + +public class CommonProxy { + + public void preInit(FMLPreInitializationEvent e) {} + + public void init(FMLInitializationEvent e) {} + + public void postInit(FMLPostInitializationEvent e) {} +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/common/register/BotWerkstoffMaterialPool.java b/lath/src/main/java/com/elisis/gtnhlanth/common/register/BotWerkstoffMaterialPool.java new file mode 100644 index 0000000000..3c52faaf64 --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/common/register/BotWerkstoffMaterialPool.java @@ -0,0 +1,98 @@ +package com.elisis.gtnhlanth.common.register; + +import static com.github.bartimaeusnek.bartworks.system.material.Werkstoff.Types.*; +import static com.github.bartimaeusnek.bartworks.util.BW_Util.subscriptNumbers; +import static gregtech.api.enums.Materials.*; +import static gregtech.api.enums.TextureSet.*; + +import com.github.bartimaeusnek.bartworks.system.material.Werkstoff; +import com.github.bartimaeusnek.bartworks.util.Pair; + +/* + * Originally authored by botn365 under the MIT License. See BotdustriesLICENSE + */ +@SuppressWarnings("unchecked") +public class BotWerkstoffMaterialPool implements Runnable { + + public static final Werkstoff TungsticAcid = new Werkstoff( + new short[] { 0xf5, 0xf1, 0x16 }, + "Tungstic Acid", + new Werkstoff.Stats(), + COMPOUND, + new Werkstoff.GenerationFeatures().onlyDust() + .enforceUnification(), + 29900, + SET_SHINY, + new Pair<>(Hydrogen, 2), + new Pair<>(Tungsten, 1), + new Pair<>(Oxygen, 4)); + public static final Werkstoff TungstenTrioxide = new Werkstoff( + new short[] { 0x0f, 0x5, 0x16 }, + "Tungsten Trioxide", + new Werkstoff.Stats(), + COMPOUND, + new Werkstoff.GenerationFeatures().onlyDust() + .enforceUnification(), + 29901, + SET_SHINY, + new Pair<>(Tungsten, 1), + new Pair<>(Oxygen, 3)); + public static final Werkstoff AmmoniumNitrate = new Werkstoff( + new short[] { 0x81, 0xcc, 0x00 }, + "Ammonium Nitrate", + new Werkstoff.Stats(), + COMPOUND, + new Werkstoff.GenerationFeatures().onlyDust(), + 29903, + SET_FINE, + new Pair<>(Nitrogen, 1), + new Pair<>(Hydrogen, 4), + new Pair<>(Nitrogen, 1), + new Pair<>(Oxygen, 3)); + public static final Werkstoff SodiumTungstate = new Werkstoff( + new short[] { 0xc, 0xed, 0xd7, 0 }, + "Sodium Tungstate", + subscriptNumbers("Na2WO4"), + new Werkstoff.Stats(), + COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + 29904, + SET_FINE); + public static final Werkstoff Phosgene = new Werkstoff( + new short[] { 0x15, 0xa1, 0x1a }, + "Phosgene", + subscriptNumbers("COCl2"), + new Werkstoff.Stats(), + COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + 29905, + SET_FINE); + public static final Werkstoff OXylene = new Werkstoff( + new short[] { 0x88, 0x94, 0xa8 }, + "O-Xylene", + subscriptNumbers("C8H10"), + new Werkstoff.Stats().setGas(true), + COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + 29915, + SET_FINE); + public static final Werkstoff Nitromethane = new Werkstoff( + new short[] { 0x87, 0x7d, 0x60 }, + "Nitromethane", + subscriptNumbers("CH3NO2"), + new Werkstoff.Stats(), + COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + 29914, + SET_METALLIC); + + @Override + public void run() { + // TODO Auto-generated method stub + + } +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/common/register/LanthItemList.java b/lath/src/main/java/com/elisis/gtnhlanth/common/register/LanthItemList.java new file mode 100644 index 0000000000..69aa026e47 --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/common/register/LanthItemList.java @@ -0,0 +1,19 @@ +package com.elisis.gtnhlanth.common.register; + +import net.minecraft.item.ItemStack; + +import com.elisis.gtnhlanth.common.tileentity.Digester; +import com.elisis.gtnhlanth.common.tileentity.DissolutionTank; + +public final class LanthItemList { + + public static ItemStack DIGESTER; + public static ItemStack DISSOLUTION_TANK; + + public static void register() { + + LanthItemList.DIGESTER = new Digester(10500, "Digester", "Digester").getStackForm(1L); + LanthItemList.DISSOLUTION_TANK = new DissolutionTank(10501, "Dissolution Tank", "Dissolution Tank") + .getStackForm(1L); + } +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/common/register/WerkstoffMaterialPool.java b/lath/src/main/java/com/elisis/gtnhlanth/common/register/WerkstoffMaterialPool.java new file mode 100644 index 0000000000..9f788c1b92 --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/common/register/WerkstoffMaterialPool.java @@ -0,0 +1,1919 @@ +package com.elisis.gtnhlanth.common.register; + +import static com.github.bartimaeusnek.bartworks.util.BW_Util.subscriptNumbers; + +import java.util.Arrays; + +import com.github.bartimaeusnek.bartworks.system.material.Werkstoff; +import com.github.bartimaeusnek.bartworks.util.Pair; + +import gregtech.api.enums.Materials; +import gregtech.api.enums.TextureSet; + +@SuppressWarnings({ "unchecked" }) +public class WerkstoffMaterialPool implements Runnable { + + private static final int offsetID = 11_000; + private static final int offsetID2 = 11_100; + private static final int offsetID3 = 11_300; + private static final int offsetID4 = 11_400; + private static final int offsetID5 = 11_460; + + /* + * public static final Werkstoff __ = new Werkstoff( new short[] {_, _, _}, "__", new Werkstoff.Stats(), + * Werkstoff.Types.MIXTURE, new Werkstoff.GenerationFeatures().disable(), offsetID_, TextureSet.SET_DULL ); + */ + + // Misc. + public static final Werkstoff Hafnium = new Werkstoff( + new short[] { 232, 224, 219 }, + "Hafnium", + subscriptNumbers("Hf"), + new Werkstoff.Stats(), + Werkstoff.Types.ELEMENT, + 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", + subscriptNumbers("HfO2"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), // Perhaps use hafnia liquid in elemental hafnium + // synthesis + 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().setBlastFurnace(true), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust() + .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().setProtons(53) + .setMass(127) + .setSublimation(true) + .setBoilingPoint(484) + .setGas(true), + Werkstoff.Types.ELEMENT, + new Werkstoff.GenerationFeatures().disable() + .onlyDust() + .addCells() + .enforceUnification(), + offsetID + 12, + TextureSet.SET_FLUID); + + // Lanthanide Line + public static final Werkstoff MuddyRareEarthMonaziteSolution = new Werkstoff( + new short[] { 111, 78, 55 }, + "Muddy Monazite Rare Earth Solution", + subscriptNumbers("??LaNdZr??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID + 14, + TextureSet.SET_FLUID); + + public static final Werkstoff DilutedRareEarthMonaziteMud = new Werkstoff( + new short[] { 160, 120, 90 }, + "Diluted Monazite Rare Earth Mud", + subscriptNumbers("??LaNdHf??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID + 15, + TextureSet.SET_FLUID); + + public static final Werkstoff DilutedMonaziteSulfate = new Werkstoff( + new short[] { 237, 201, 175 }, + "Diluted Monazite Sulfate", + subscriptNumbers("??LaNd??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID + 16, + TextureSet.SET_FLUID); + + public static final Werkstoff NitratedRareEarthMonaziteConcentrate = new Werkstoff( + new short[] { 250, 223, 173 }, + "Nitrogenated Monazite 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 NitricMonaziteLeachedConcentrate = new Werkstoff( + new short[] { 244, 202, 22 }, + "Nitric Monazite 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 MonaziteRareEarthFiltrate = new Werkstoff( + new short[] { 72, 60, 50 }, + "Monazite Rare Earth Filtrate", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 21, + TextureSet.SET_DULL); + + public static final Werkstoff NeutralizedMonaziteRareEarthFiltrate = new Werkstoff( + new short[] { 50, 23, 77 }, + "Neutralized Monazite Rare Earth Filtrate", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 22, + TextureSet.SET_DULL); + + public static final Werkstoff MonaziteRareEarthHydroxideConcentrate = new Werkstoff( + new short[] { 193, 154, 107 }, + "Monazite 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 DriedMonaziteRareEarthConcentrate = new Werkstoff( + new short[] { 250, 214, 165 }, + "Dried Monazite 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().setElektrolysis(true), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 28, + TextureSet.SET_DULL, + Arrays.asList(Materials.Cerium, Materials.Oxygen), + new Pair<>(Materials.Cerium, 2), + new Pair<>(Materials.Oxygen, 3)); + + 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 CooledMonaziteRareEarthConcentrate = new Werkstoff( + new short[] { 250, 214, 165 }, + "Cooled Monazite Rare Earth Concentrate", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 30, + TextureSet.SET_DULL); + + public static final Werkstoff MonaziteRarerEarthSediment = new Werkstoff( + new short[] { 250, 214, 165 }, + "MonaziteRarer Earth Sediment", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 31, + TextureSet.SET_DULL); + + public static final Werkstoff MonaziteHeterogenousHalogenicRareEarthMixture = new Werkstoff( + new short[] { 250, 214, 165 }, + "Heterogenous Halogenic Monazite Rare Earth Mixture", + subscriptNumbers("????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 32, + TextureSet.SET_DULL); + + public static final Werkstoff SaturatedMonaziteRareEarthMixture = new Werkstoff( + new short[] { 250, 214, 165 }, + "Saturated Monazite Rare Earth", + 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 AmmoniumNitrate = new Werkstoff( + new short[] { 255, 255, 255 }, + "Ammonium Nitrate Solution", + subscriptNumbers("NH4NO3"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID + 36, + TextureSet.SET_FLUID); + + public static final Werkstoff ThoriumPhosphateCake = new Werkstoff( + new short[] { 188, 143, 143 }, + "Thorium-Phosphate Cake", + subscriptNumbers("??ThP??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 37, + TextureSet.SET_DULL); + + public static final Werkstoff ThoriumPhosphateConcentrate = new Werkstoff( + new short[] { 217, 144, 88 }, + "Thorium-Phosphate Concentrate", + subscriptNumbers("??ThP??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 38, + TextureSet.SET_DULL); + + public static final Werkstoff UraniumFiltrate = new Werkstoff( + new short[] { 190, 240, 94 }, + "UraniumFiltrate", + subscriptNumbers("??U??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 39, + TextureSet.SET_DULL); + + public static final Werkstoff NeutralizedUraniumFiltrate = new Werkstoff( + new short[] { 217, 120, 88 }, + "Neutralized Uranium Filtrate", + subscriptNumbers("??U??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 40, + TextureSet.SET_DULL); + + public static final Werkstoff SeaweedAsh = new Werkstoff( + new short[] { 70, 75, 71 }, + "Seaweed Ash", + new Werkstoff.Stats(), + Werkstoff.Types.BIOLOGICAL, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 41, + TextureSet.SET_DULL); + + public static final Werkstoff SeaweedConcentrate = new Werkstoff( + new short[] { 70, 100, 71 }, + "Seaweed Concentrate", + subscriptNumbers("??I??"), + new Werkstoff.Stats(), + Werkstoff.Types.BIOLOGICAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID + 42, + TextureSet.SET_FLUID); + + public static final Werkstoff PotassiumPermanganate = new Werkstoff( + new short[] { 165, 50, 138 }, + "Potassium Permanganate", + subscriptNumbers("KMnO4"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 43, + TextureSet.SET_DULL); + + public static final Werkstoff PotassiumPermanganateSolution = new Werkstoff( + new short[] { 165, 50, 138 }, + "Potassium Permanganate Solution", + subscriptNumbers("KMnO4"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID + 44, + TextureSet.SET_FLUID); + + public static final Werkstoff SeaweedByproducts = new Werkstoff( + new short[] { 125, 50, 138 }, + "Seaweed Byproducts", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID + 45, + TextureSet.SET_FLUID); + + public static final Werkstoff NitricLeachedMonaziteMixture = new Werkstoff( + new short[] { 125, 50, 138 }, + "Nitric-Leached Monazite Mixture", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID + 46, + TextureSet.SET_FLUID); + + public static final Werkstoff EuropiumOxide = new Werkstoff( + new short[] { 255, 255, 255 }, + "Europium Oxide", + subscriptNumbers("EuO"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 47, + TextureSet.SET_DULL); + + public static final Werkstoff EuropiumSulfide = new Werkstoff( + new short[] { 5, 0, 5 }, + "Europium Sulfide", + subscriptNumbers("EuS"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 48, + TextureSet.SET_DULL); + + public static final Werkstoff UnknownBlend = new Werkstoff( + new short[] { 0, 0, 5 }, + "UnknownBlend", + subscriptNumbers("?????"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 49, + TextureSet.SET_DULL); + + public static final Werkstoff EuropiumIIIOxide = new Werkstoff( + new short[] { 255, 230, 255 }, + "Europium III Oxide", + subscriptNumbers("Eu2O3"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID + 50, + TextureSet.SET_DULL); + + // TODO + + // BASTNASITE + public static final Werkstoff MuddyRareEarthBastnasiteSolution = new Werkstoff( + new short[] { 205, 133, 63 }, + "Muddy Bastnasite Rare Earth Solution", + subscriptNumbers("??LaCeY??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID2, + TextureSet.SET_FLUID); + /* + * public static final Werkstoff FluorosilicicAcid = new Werkstoff( new short[] {205, 133, 63}, + * "Hexafluorosilicic Acid", subscriptNumbers("H2SiF6"), new Werkstoff.Stats(), Werkstoff.Types.COMPOUND, new + * Werkstoff.GenerationFeatures().disable().addCells(), offsetID2 + 1, TextureSet.SET_FLUID ); + */ + public static final Werkstoff SodiumFluorosilicate = new Werkstoff( + new short[] { 205, 133, 63 }, + "Sodiumfluorosilicate", + subscriptNumbers("Na2SiF6"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID2 + 2, + TextureSet.SET_FLUID); + + public static final Werkstoff SteamCrackedBasnasiteSolution = new Werkstoff( + new short[] { 205, 133, 63 }, + "Steam-Cracked Bastnasite Mud", + subscriptNumbers("??LaCeY??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID2 + 3, + TextureSet.SET_FLUID); + + public static final Werkstoff ConditionedBastnasiteMud = new Werkstoff( + new short[] { 205, 133, 63 }, + "Conditioned Bastnasite Mud", + subscriptNumbers("??LaCeY??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID2 + 4, + TextureSet.SET_FLUID); + + public static final Werkstoff DiltedRareEarthBastnasiteMud = new Werkstoff( + new short[] { 205, 133, 63 }, + "Diluted Bastnasite Mud", + subscriptNumbers("??LaCeY??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID2 + 5, + TextureSet.SET_FLUID); + + public static final Werkstoff FilteredBastnasiteMud = new Werkstoff( + new short[] { 205, 133, 63 }, + "Filtered Bastnasite Mud", + subscriptNumbers("??LaCeY??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID2 + 6, + TextureSet.SET_FLUID); + + public static final Werkstoff BastnasiteRareEarthOxidePowder = new Werkstoff( + new short[] { 205, 133, 63 }, + "Bastnasite Rare Earth Oxides", + subscriptNumbers("??LaCeY??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 7, + TextureSet.SET_DULL); + + public static final Werkstoff LeachedBastnasiteRareEarthOxides = new Werkstoff( + new short[] { 205, 133, 63 }, + "Acid-Leached Bastnasite Rare Earth Oxides", + subscriptNumbers("??LaCeY??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 8, + TextureSet.SET_DULL); + + public static final Werkstoff Gangue = new Werkstoff( + new short[] { 0, 0, 0 }, + "Gangue", + subscriptNumbers("Useless..."), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 9, + TextureSet.SET_DULL); + // TODO: Deal with colouring + public static final Werkstoff RoastedRareEarthOxides = new Werkstoff( + new short[] { 160, 82, 45 }, + "Roasted Rare Earth Oxides", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 10, + TextureSet.SET_DULL); + + public static final Werkstoff WetRareEarthOxides = new Werkstoff( + new short[] { 160, 82, 49 }, + "Wet Rare Earth Oxides", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 11, + TextureSet.SET_DULL); + + public static final Werkstoff CeriumOxidisedRareEarthOxides = new Werkstoff( + new short[] { 160, 82, 49 }, + "Cerium-Oxidised Rare Earth Oxides", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 12, + TextureSet.SET_DULL); + + public static final Werkstoff BastnasiteRarerEarthOxides = new Werkstoff( + new short[] { 160, 82, 49 }, + "Bastnasite Rarer Earth Oxides", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 13, + TextureSet.SET_DULL); + + public static final Werkstoff NitratedBastnasiteRarerEarthOxides = new Werkstoff( + new short[] { 160, 90, 60 }, + "Nitrogenated Bastnasite Rarer Earth Oxides", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID2 + 14, + TextureSet.SET_DULL); + + public static final Werkstoff SaturatedBastnasiteRarerEarthOxides = new Werkstoff( + new short[] { 170, 90, 60 }, + "Bastnasite Rarer Earth Oxide Suspension", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID2 + 15, + TextureSet.SET_DULL); + + public static final Werkstoff SamaricRareEarthConcentrate = new Werkstoff( + new short[] { 170, 90, 60 }, + "Samaric Rare Earth Concentrate", + subscriptNumbers("??SmHoTb??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 16, + TextureSet.SET_DULL); + + public static final Werkstoff NeodymicRareEarthConcentrate = new Werkstoff( + new short[] { 170, 90, 60 }, + "Neodymium Rare Earth Concentrate", + subscriptNumbers("??LaNdPr??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 17, + TextureSet.SET_DULL); + public static final Werkstoff LanthaniumChloride = new Werkstoff( + new short[] { 82, 112, 102 }, + "Lanthanium Chloride", + subscriptNumbers("LaCl3"), + new Werkstoff.Stats().setElektrolysis(true), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 21, + TextureSet.SET_DULL, + Arrays.asList(Materials.Lanthanum, Materials.Chlorine), + new Pair<>(Materials.Lanthanum, 1), + new Pair<>(Materials.Chlorine, 3)); + + public static final Werkstoff NeodymiumOxide = new Werkstoff( + new short[] { 82, 112, 102 }, + "Neodymium Oxide", + subscriptNumbers("Nd2O3"), + new Werkstoff.Stats().setElektrolysis(true), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 22, + TextureSet.SET_DULL, + Arrays.asList(Materials.Neodymium, Materials.Oxygen), + new Pair<>(Materials.Neodymium, 2), + new Pair<>(Materials.Oxygen, 3)); + + public static final Werkstoff FluorinatedSamaricConcentrate = new Werkstoff( + new short[] { 255, 182, 193 }, + "Fluorinated Samaric Concentrate", + subscriptNumbers("??SmHo??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 23, + TextureSet.SET_DULL); + + public static final Werkstoff CalciumFluoride = new Werkstoff( + new short[] { 255, 250, 250 }, + "Calcium Fluoride", + subscriptNumbers("CaF2"), + new Werkstoff.Stats().setElektrolysis(true), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust() + .addMolten() + .addCells(), + offsetID2 + 24, + TextureSet.SET_DULL, + Arrays.asList(Materials.Calcium, Materials.Fluorine), + new Pair<>(Materials.Calcium, 1), + new Pair<>(Materials.Fluorine, 2)); + + public static final Werkstoff SamariumTerbiumMixture = new Werkstoff( + new short[] { 223, 182, 193 }, + "Samarium-Terbium Mixture", + subscriptNumbers("??SmTb??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 25, + TextureSet.SET_DULL); + + public static final Werkstoff NitratedSamariumTerbiumMixture = new Werkstoff( + new short[] { 223, 182, 193 }, + "Nitrogenated Samarium-Terbium Mixture", + subscriptNumbers("??SmTb??NH4NO3"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 26, + TextureSet.SET_DULL); + + public static final Werkstoff TerbiumNitrate = new Werkstoff( + new short[] { 167, 252, 0 }, + "Terbium Nitrate", + subscriptNumbers("TbNO3"), + new Werkstoff.Stats().setElektrolysis(true), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 27, + TextureSet.SET_DULL, + Arrays.asList(Materials.Terbium, Materials.Nitrogen, Materials.Oxygen), + new Pair<>(Materials.Terbium, 1), + new Pair<>(Materials.Nitrogen, 1), + new Pair<>(Materials.Oxygen, 3)); + + public static final Werkstoff SamariumOreConcentrate = new Werkstoff( + new short[] { 255, 200, 230 }, + "Samarium Ore Concentrate", + subscriptNumbers("??Sm??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 28, + TextureSet.SET_DULL); + + public static final Werkstoff DephosphatedSamariumConcentrate = new Werkstoff( + new short[] { 255, 170, 220 }, + "Dephosphated Samarium Concentrate", + subscriptNumbers("??Sm??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID2 + 29, + TextureSet.SET_DULL); + + // Weird/Exciting Chemicals + public static final Werkstoff Tetrahydrofuran = new Werkstoff( + new short[] { 222, 165, 164 }, + "Tetrahydrofuran", + subscriptNumbers("(CH2)4O"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID3, + TextureSet.SET_FLUID); + + // 1,4-Butanediol + public static final Werkstoff Butanediol = new Werkstoff( + new short[] { 185, 78, 72 }, + "1,4-Butanediol", + subscriptNumbers("HO(CH2)4OH"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID3 + 1, + TextureSet.SET_FLUID); + + // Acidicised 1,4-Butanediol + public static final Werkstoff AcidicButanediol = new Werkstoff( + new short[] { 255, 239, 213 }, + "Acidicised 1,4-Butanediol", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID3 + 2, + TextureSet.SET_FLUID); + + // Tellurium-Molybdenum-Oxide Catalyst + public static final Werkstoff MoTeOCatalyst = new Werkstoff( + new short[] { 238, 131, 238 }, + "Tellurium-Molybdenum-Oxide Catalyst", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID3 + 3, + TextureSet.SET_DULL); + + // Tellurium Oxide + public static final Werkstoff TelluriumIVOxide = new Werkstoff( + new short[] { 229, 199, 187 }, + "Tellurium (IV) Oxide", + subscriptNumbers("TeO2"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID3 + 4, + TextureSet.SET_DULL); + + public static final Werkstoff MolybdenumIVOxide = new Werkstoff( + new short[] { 52, 53, 57 }, + "Molybdenum (IV) Oxide", + subscriptNumbers("MoO2"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID3 + 5, + TextureSet.SET_DULL); + + public static final Werkstoff Polytetrahydrofuran = new Werkstoff( + new short[] { 192, 128, 129 }, + "Polytetrahydrofuran", + subscriptNumbers("(C4H8O)OH2"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust() + .addCells(), + offsetID3 + 6, + TextureSet.SET_DULL); + + public static final Werkstoff TungstophosphoricAcid = new Werkstoff( + new short[] { 223, 255, 0 }, + "Tungstophosphoric Acid", + subscriptNumbers("H3PW12O40"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID3 + 7, + TextureSet.SET_FLUID); + + public static final Werkstoff TolueneDiisocyanate = new Werkstoff( + new short[] { 255, 255, 102 }, + "Toluene Diisocyanate", + subscriptNumbers("CH3C6H3(NCO)2"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID3 + 8, + TextureSet.SET_FLUID); + + public static final Werkstoff Dinitrotoluene = new Werkstoff( + new short[] { 216, 191, 216 }, + "Dinitrotoluene", + subscriptNumbers("C7H6N2O4"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID3 + 9, + TextureSet.SET_FLUID); + + public static final Werkstoff Diaminotoluene = new Werkstoff( + new short[] { 227, 218, 201 }, + "Diaminotoluene", + subscriptNumbers("C6H3(NH2)2CH3"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID3 + 10, + TextureSet.SET_FLUID); + + public static final Werkstoff TolueneTetramethylDiisocyanate = new Werkstoff( + new short[] { 255, 255, 255 }, + "Toluene Tetramethyl Diisocyanate", + subscriptNumbers("(CONH)2(C6H4)2CH2(C4O)"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID3 + 11, + TextureSet.SET_FLUID); + + public static final Werkstoff PTMEGElastomer = new Werkstoff( + new short[] { 248, 248, 255 }, + "PTMEG Elastomer", + new Werkstoff.Stats().setMeltingPoint(600) + .setMeltingVoltage(64), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust() + .addMolten() + .addMetalItems(), + offsetID3 + 12, + TextureSet.SET_DULL); + + public static final Werkstoff PotassiumChlorate = new Werkstoff( + new short[] { 240, 255, 255 }, + "Potassium Chlorate", + subscriptNumbers("KClO3"), + new Werkstoff.Stats(), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust() + .addMolten(), + offsetID3 + 14, + TextureSet.SET_DULL); + + public static final Werkstoff DilutedAcetone = new Werkstoff( + new short[] { 254, 254, 250 }, + "Diluted Acetone", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID3 + 16, + TextureSet.SET_FLUID); + + // TODO Samarium Processing Line Material regist + + public static final Werkstoff MuddySamariumRareEarthSolution = new Werkstoff( + new short[] { 226, 180, 108 }, + "Muddy Samarium Rare Earth Solution", + subscriptNumbers("???Sm???"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID5 + 1, + TextureSet.SET_FLUID); + + public static final Werkstoff SamariumRareEarthMud = new Werkstoff( + new short[] { 226, 180, 128 }, + "Samarium Rare Earth Mud", + subscriptNumbers("??Sm??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID5 + 2, + TextureSet.SET_FLUID); + + public static final Werkstoff DilutedSamariumRareEarthSolution = new Werkstoff( + new short[] { 226, 180, 148 }, + "Diluted Samarium Rare Earth Solution", + subscriptNumbers("?Sm?"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID5 + 3, + TextureSet.SET_FLUID); + + public static final Werkstoff SamariumOxalate = new Werkstoff( + new short[] { 248, 248, 180 }, + "Samarium(III) Oxalate", + subscriptNumbers("?Sm2(C2O4)3"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID5 + 4, + TextureSet.SET_DULL); + + public static final Werkstoff SamariumChloride = new Werkstoff( + new short[] { 248, 248, 120 }, + "Samarium(III)-Chloride", + subscriptNumbers("SmCI3"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust() + .addMolten(), + offsetID5 + 5, + TextureSet.SET_DULL); + + public static final Werkstoff SamariumChlorideSodiumChlorideBlend = new Werkstoff( + new short[] { 255, 200, 230 }, + "Samarium Chloride-Sodium Chloride Blend", + subscriptNumbers("?SmCl3NaCl"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID5 + 6, + TextureSet.SET_DULL); + + public static final Werkstoff ImpureLanthanumChloride = new Werkstoff( + new short[] { 90, 100, 30 }, + "Impure Lanthanum Chloride", + subscriptNumbers("?LaCl3"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID5 + 7, + TextureSet.SET_DULL); + + public static final Werkstoff SamariumOxide = new Werkstoff( + new short[] { 223, 182, 193 }, + "Samarium Oxide", + subscriptNumbers("Sm2O3"), + new Werkstoff.Stats().setElektrolysis(true), + Werkstoff.Types.COMPOUND, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID5 + 8, + TextureSet.SET_DULL, + Arrays.asList(Materials.Samarium, Materials.Oxygen), + new Pair<>(Materials.Samarium, 2), + new Pair<>(Materials.Oxygen, 3)); + + public static final Werkstoff ChlorinatedRareEarthConcentrate = new Werkstoff( + new short[] { 130, 80, 60 }, + "Chlorinated Rare Earth Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID5 + 9, + TextureSet.SET_FLUID); + + public static final Werkstoff ChlorinatedRareEarthEnrichedSolution = new Werkstoff( + new short[] { 130, 90, 60 }, + "Chlorinated Rare Earth Enriched Solution", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID5 + 10, + TextureSet.SET_FLUID); + + public static final Werkstoff ChlorinatedRareEarthDilutedSolution = new Werkstoff( + new short[] { 216, 180, 100 }, + "Chlorinated Rare Earth Diluted Solution", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID5 + 11, + TextureSet.SET_FLUID); + + public static final Werkstoff RarestEarthResidue = new Werkstoff( + new short[] { 224, 211, 211 }, + "Rarest Earth Residue", + subscriptNumbers("???"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID5 + 12, + TextureSet.SET_DULL); + + // TODO reg Lanth Ore Concentrate + /** + * Extracted Nano Resin Lanthanum1.2 Praseodymium3.4 Cerium5.6 Neodymium7.8 Promethium9.10 Samarium11.12 √ + * Europium13.14 Gadolinium15.16 Terbium17.18 Dysprosium19.20 Holmium21.22 Erbium23.24 Thulium25.26 Ytterbium27.28 + * Lutetium29.30 + */ + + public static final Werkstoff LanthanumExtractingNanoResin = new Werkstoff( + new short[] { 50, 80, 40 }, + "Lanthanum Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 1, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledLanthanumExtractingNanoResin = new Werkstoff( + new short[] { 128, 128, 80 }, + "Filled Lanthanum Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 2, + TextureSet.SET_FLUID); + + public static final Werkstoff PraseodymiumExtractingNanoResin = new Werkstoff( + new short[] { 80, 192, 130 }, + "Praseodymium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 3, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledPraseodymiumExtractingNanoResin = new Werkstoff( + new short[] { 140, 192, 130 }, + "Filled Praseodymium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 4, + TextureSet.SET_FLUID); + + public static final Werkstoff CeriumExtractingNanoResin = new Werkstoff( + new short[] { 80, 240, 160 }, + "Cerium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 5, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledCeriumExtractingNanoResin = new Werkstoff( + new short[] { 160, 240, 180 }, + "Filled Cerium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 6, + TextureSet.SET_FLUID); + + public static final Werkstoff NeodymiumExtractingNanoResin = new Werkstoff( + new short[] { 128, 140, 128 }, + "Neodymium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 7, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledNeodymiumExtractingNanoResin = new Werkstoff( + new short[] { 150, 150, 150 }, + "Filled Neodymium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 8, + TextureSet.SET_FLUID); + + public static final Werkstoff PromethiumExtractingNanoResin = new Werkstoff( + new short[] { 110, 255, 60 }, + "Promethium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 9, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledPromethiumExtractingNanoResin = new Werkstoff( + new short[] { 150, 255, 140 }, + "Filled Promethium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 10, + TextureSet.SET_FLUID); + + public static final Werkstoff SamariumExtractingNanoResin = new Werkstoff( + new short[] { 255, 240, 100 }, + "Samarium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 11, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledSamariumExtractingNanoResin = new Werkstoff( + new short[] { 255, 240, 196 }, + "Filled Samarium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 12, + TextureSet.SET_FLUID); + + public static final Werkstoff EuropiumExtractingNanoResin = new Werkstoff( + new short[] { 240, 160, 240 }, + "Europium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 13, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledEuropiumExtractingNanoResin = new Werkstoff( + new short[] { 240, 200, 240 }, + "Filled Europium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 14, + TextureSet.SET_FLUID); + + public static final Werkstoff GadoliniumExtractingNanoResin = new Werkstoff( + new short[] { 120, 255, 80 }, + "Gadolinium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 15, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledGadoliniumExtractingNanoResin = new Werkstoff( + new short[] { 160, 255, 140 }, + "Filled Gadolinium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 16, + TextureSet.SET_FLUID); + + public static final Werkstoff TerbiumExtractingNanoResin = new Werkstoff( + new short[] { 200, 200, 200 }, + "Terbium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 17, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledTerbiumExtractingNanoResin = new Werkstoff( + new short[] { 255, 255, 255 }, + "Filled Terbium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 18, + TextureSet.SET_FLUID); + + public static final Werkstoff DysprosiumExtractingNanoResin = new Werkstoff( + new short[] { 110, 240, 180 }, + "Dysprosium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 19, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledDysprosiumExtractingNanoResin = new Werkstoff( + new short[] { 150, 240, 180 }, + "Filled Dysprosium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 20, + TextureSet.SET_FLUID); + + public static final Werkstoff HolmiumExtractingNanoResin = new Werkstoff( + new short[] { 16, 16, 216 }, + "Holmium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 21, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledHolmiumExtractingNanoResin = new Werkstoff( + new short[] { 60, 90, 255 }, + "Filled Holmium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 22, + TextureSet.SET_FLUID); + + public static final Werkstoff ErbiumExtractingNanoResin = new Werkstoff( + new short[] { 200, 160, 80 }, + "Erbium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 23, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledErbiumExtractingNanoResin = new Werkstoff( + new short[] { 233, 170, 100 }, + "Filled Erbium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 24, + TextureSet.SET_FLUID); + + public static final Werkstoff ThuliumExtractingNanoResin = new Werkstoff( + new short[] { 128, 178, 255 }, + "Thulium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 25, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledThuliumExtractingNanoResin = new Werkstoff( + new short[] { 160, 200, 255 }, + "Filled Thulium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 26, + TextureSet.SET_FLUID); + + public static final Werkstoff YtterbiumExtractingNanoResin = new Werkstoff( + new short[] { 0, 255, 0 }, + "Ytterbium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 27, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledYtterbiumExtractingNanoResin = new Werkstoff( + new short[] { 100, 255, 100 }, + "Filled Ytterbium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 28, + TextureSet.SET_FLUID); + + public static final Werkstoff LutetiumExtractingNanoResin = new Werkstoff( + new short[] { 230, 16, 230 }, + "Lutetium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 29, + TextureSet.SET_FLUID); + + public static final Werkstoff FilledLutetiumExtractingNanoResin = new Werkstoff( + new short[] { 240, 100, 240 }, + "Filled Lutetium Extracting Nano Resin", + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 30, + TextureSet.SET_FLUID); + + // enum Lanthanides { + // Lanthanum, + // Praseodymium, + // Cerium, + // Neodymium, + // Promethium, + // Samarium, + // Europium, + // Gadolinium, + // Terbium, + // Dysprosium, + // Holmium, + // Erbium, + // Thulium, + // Ytterbium, + // Lutetium + // } + + // Lanthanides Chloride Concentrate + // Lanthanum + public static final Werkstoff LanthanumChlorideConcentrate = new Werkstoff( + new short[] { 128, 128, 80 }, + "Lanthanum Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 31, + TextureSet.SET_FLUID); + + // Praseodymium + public static final Werkstoff PraseodymiumChlorideConcentrate = new Werkstoff( + new short[] { 140, 192, 130 }, + "Praseodymium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 32, + TextureSet.SET_FLUID); + + // Cerium + public static final Werkstoff CeriumChlorideConcentrate = new Werkstoff( + new short[] { 160, 240, 180 }, + "Cerium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 33, + TextureSet.SET_FLUID); + + // Neodymium + public static final Werkstoff NeodymiumChlorideConcentrate = new Werkstoff( + new short[] { 150, 150, 150 }, + "Neodymium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 34, + TextureSet.SET_FLUID); + + // + public static final Werkstoff PromethiumChlorideConcentrate = new Werkstoff( + new short[] { 150, 255, 140 }, + "Promethium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 35, + TextureSet.SET_FLUID); + + // + public static final Werkstoff SamariumChlorideConcentrate = new Werkstoff( + new short[] { 255, 240, 196 }, + "Samarium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 36, + TextureSet.SET_FLUID); + + // + public static final Werkstoff EuropiumChlorideConcentrate = new Werkstoff( + new short[] { 240, 200, 240 }, + "Europium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 37, + TextureSet.SET_FLUID); + + // + public static final Werkstoff GadoliniumChlorideConcentrate = new Werkstoff( + new short[] { 160, 255, 140 }, + "Gadolinium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 38, + TextureSet.SET_FLUID); + + // + public static final Werkstoff TerbiumChlorideConcentrate = new Werkstoff( + new short[] { 255, 255, 255 }, + "Terbium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 39, + TextureSet.SET_FLUID); + + // + public static final Werkstoff DysprosiumChlorideConcentrate = new Werkstoff( + new short[] { 150, 240, 180 }, + "Dysprosium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 40, + TextureSet.SET_FLUID); + + // + public static final Werkstoff HolmiumChlorideConcentrate = new Werkstoff( + new short[] { 60, 90, 255 }, + "Holmium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 41, + TextureSet.SET_FLUID); + + // + public static final Werkstoff ErbiumChlorideConcentrate = new Werkstoff( + new short[] { 233, 170, 100 }, + "Erbium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 42, + TextureSet.SET_FLUID); + + // + public static final Werkstoff ThuliumChlorideConcentrate = new Werkstoff( + new short[] { 160, 200, 255 }, + "Thulium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 43, + TextureSet.SET_FLUID); + + // + public static final Werkstoff YtterbiumChlorideConcentrate = new Werkstoff( + new short[] { 100, 255, 100 }, + "Ytterbium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 44, + TextureSet.SET_FLUID); + + // + public static final Werkstoff LutetiumChlorideConcentrate = new Werkstoff( + new short[] { 240, 100, 240 }, + "Lutetium Chloride Concentrate", + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .addCells(), + offsetID4 + 45, + TextureSet.SET_FLUID); + + // Lanthanides Ore Concentrate + + // Lanthanum + public static final Werkstoff LanthanumOreConcentrate = new Werkstoff( + new short[] { 128, 128, 96 }, + "Lanthanum Ore Concentrate", + subscriptNumbers("??La??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 46, + TextureSet.SET_DULL); + + // Praseodymium + public static final Werkstoff PraseodymiumOreConcentrate = new Werkstoff( + new short[] { 140, 192, 130 }, + "Praseodymium Ore Concentrate", + subscriptNumbers("??Pr??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 47, + TextureSet.SET_DULL); + + // Cerium + public static final Werkstoff CeriumOreConcentrate = CeriumRichMixture; + + // Neodymium + public static final Werkstoff NeodymiumOreConcentrate = new Werkstoff( + new short[] { 128, 128, 128 }, + "Neodymium Ore Concentrate", + subscriptNumbers("??Nd??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 49, + TextureSet.SET_DULL); + + // Promethium + public static final Werkstoff PromethiumOreConcentrate = new Werkstoff( + new short[] { 150, 255, 140 }, + "Promethium Ore Concentrate", + subscriptNumbers("??Po??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 50, + TextureSet.SET_DULL); + + // Samarium + // public static final Werkstoff SamariumOreConcentrate = new Werkstoff( + // new short[] { 255, 200, 230 }, + // "Samarium Ore Concentrate", + // subscriptNumbers("??Sm??"), + // new Werkstoff.Stats(), + // Werkstoff.Types.MIXTURE, + // new Werkstoff.GenerationFeatures().disable().onlyDust(), + // offsetID2 + 28, + // TextureSet.SET_DULL); + + // Europium + public static final Werkstoff EuropiumOreConcentrate = new Werkstoff( + new short[] { 240, 200, 240 }, + "Europium Ore Concentrate", + subscriptNumbers("??Eu??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 51, + TextureSet.SET_DULL); + + // Gadolinium + public static final Werkstoff GadoliniumOreConcentrate = new Werkstoff( + new short[] { 160, 255, 140 }, + "Gadolinium Ore Concentrate", + subscriptNumbers("??Gd??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 52, + TextureSet.SET_DULL); + + // Terbium + public static final Werkstoff TerbiumOreConcentrate = new Werkstoff( + new short[] { 255, 255, 255 }, + "Terbium Ore Concentrate", + subscriptNumbers("??Tb??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 53, + TextureSet.SET_DULL); + + // Dysprosium + public static final Werkstoff DysprosiumOreConcentrate = new Werkstoff( + new short[] { 150, 240, 180 }, + "Dysprosium Ore Concentrate", + subscriptNumbers("??Dy??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 54, + TextureSet.SET_DULL); + + // Holmium + public static final Werkstoff HolmiumOreConcentrate = new Werkstoff( + new short[] { 60, 90, 255 }, + "Holmium Ore Concentrate", + subscriptNumbers("??Ho??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 55, + TextureSet.SET_DULL); + + // Erbium + public static final Werkstoff ErbiumOreConcentrate = new Werkstoff( + new short[] { 233, 170, 100 }, + "Erbium Ore Concentrate", + subscriptNumbers("??Er??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 56, + TextureSet.SET_DULL); + + // Thulium + public static final Werkstoff ThuliumOreConcentrate = new Werkstoff( + new short[] { 160, 200, 255 }, + "Thulium Ore Concentrate", + subscriptNumbers("??Tm??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 57, + TextureSet.SET_DULL); + + // Ytterbium + public static final Werkstoff YtterbiumOreConcentrate = new Werkstoff( + new short[] { 100, 255, 100 }, + "Ytterbium Ore Concentrate", + subscriptNumbers("??Yb??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 58, + TextureSet.SET_DULL); + + // Lutetium + public static final Werkstoff LutetiumOreConcentrate = new Werkstoff( + new short[] { 240, 100, 240 }, + "Lutetium Ore Concentrate", + subscriptNumbers("??Lu??"), + new Werkstoff.Stats(), + Werkstoff.Types.MIXTURE, + new Werkstoff.GenerationFeatures().disable() + .onlyDust(), + offsetID4 + 59, + TextureSet.SET_DULL); + + // LuAG + public static final Werkstoff CeriumDopedLutetiumAluminiumOxygenBlend = new Werkstoff( + new short[] { 128, 192, 80 }, + "Cerium-doped Lutetium Aluminium Oxygen Blend", + subscriptNumbers("(Ce)Lu3Al5O12"), + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .onlyDust() + .addMolten(), + offsetID5 + 38, + TextureSet.SET_DULL); + + public static final Werkstoff CeriumDopedLutetiumAluminiumGarnet = new Werkstoff( + new short[] { 144, 255, 63 }, + "Cerium-doped Lutetium Aluminium Garnet (Ce:LuAG)", + subscriptNumbers("(Ce)Lu3Al5O12"), + new Werkstoff.Stats(), + Werkstoff.Types.MATERIAL, + new Werkstoff.GenerationFeatures().disable() + .addGems(), + offsetID5 + 39, + TextureSet.SET_GEM_VERTICAL); + + // public static final Werkstoff RawCeriumDopedLutetiumAluminiumGarnetPart = new Werkstoff( + // new short[] { 63, 255, 63 }, + // "Raw Cerium Doped Lutetium Aluminium Garnet Part", + // subscriptNumbers("(Ce)Lu3Al5O12"), + // new Werkstoff.Stats(), + // Werkstoff.Types.MATERIAL, + // new Werkstoff.GenerationFeatures().disable().addGems(), + // offsetID4 + 33, + // TextureSet.SET_GEM_VERTICAL); + + // public static final Werkstoff C272 = new Werkstoff( + // new short[] { 0x29, 0xc2, 0x2a }, + // "C-272", + // subscriptNumbers("(C8H17)2PO2H"), + // new Werkstoff.Stats().setElektrolysis(true), + // Werkstoff.Types.COMPOUND, + // new Werkstoff.GenerationFeatures().disable().addCells(), + // offsetID4 + 59, + // TextureSet.SET_FLUID, + // new Pair<>(Carbon, 16), + // new Pair<>(Phosphorus, 1), + // new Pair<>(Oxygen, 3), + // new Pair<>(Hydrogen, 35)); + + public static void runInit() { + + addSubTags(); + } + + private static void addSubTags() { + + // WerkstoffMaterialPool.PTMEGElastomer.add(SubTag.BOUNCY, SubTag.STRETCHY); + + } + + @Override + public void run() {} +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/common/tileentity/Digester.java b/lath/src/main/java/com/elisis/gtnhlanth/common/tileentity/Digester.java new file mode 100644 index 0000000000..479569c7f6 --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/common/tileentity/Digester.java @@ -0,0 +1,244 @@ +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.transpose; +import static gregtech.api.enums.GT_HatchElement.Energy; +import static gregtech.api.enums.GT_HatchElement.InputBus; +import static gregtech.api.enums.GT_HatchElement.InputHatch; +import static gregtech.api.enums.GT_HatchElement.Maintenance; +import static gregtech.api.enums.GT_HatchElement.Muffler; +import static gregtech.api.enums.GT_HatchElement.OutputBus; +import static gregtech.api.enums.GT_HatchElement.OutputHatch; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_ACTIVE; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_ACTIVE_GLOW; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_GLOW; +import static gregtech.api.enums.Textures.BlockIcons.casingTexturePages; +import static gregtech.api.util.GT_StructureUtility.buildHatchAdder; +import static gregtech.api.util.GT_StructureUtility.ofCoil; + +import javax.annotation.Nonnull; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; + +import com.elisis.gtnhlanth.api.recipe.LanthanidesRecipeMaps; +import com.elisis.gtnhlanth.util.DescTextLocalization; +import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.HeatingCoilLevel; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.logic.ProcessingLogic; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase; +import gregtech.api.recipe.RecipeMap; +import gregtech.api.recipe.check.CheckRecipeResult; +import gregtech.api.recipe.check.CheckRecipeResultRegistry; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_OverclockCalculator; +import gregtech.api.util.GT_Recipe; + +public class Digester extends GT_MetaTileEntity_EnhancedMultiBlockBase<Digester> implements ISurvivalConstructable { + + protected int casingAmount = 0; + protected int height = 0; + + private HeatingCoilLevel heatLevel; + + private final IStructureDefinition<Digester> multiDefinition = StructureDefinition.<Digester>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', + buildHatchAdder(Digester.class) + .atLeast(InputHatch, OutputHatch, InputBus, OutputBus, Maintenance, Energy, Muffler) + .casingIndex(47) + .dot(1) + .buildAndChain(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 boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + return checkPiece(mName, 3, 3, 0) && !mMufflerHatches.isEmpty() && mMaintenanceHatches.size() == 1; + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return true; + } + + public HeatingCoilLevel getCoilLevel() { + return this.heatLevel; + } + + public void setCoilLevel(HeatingCoilLevel level) { + this.heatLevel = level; + } + + @Override + public RecipeMap<?> getRecipeMap() { + return LanthanidesRecipeMaps.digesterRecipes; + } + + @Override + protected ProcessingLogic createProcessingLogic() { + return new ProcessingLogic() { + + @Nonnull + @Override + protected GT_OverclockCalculator createOverclockCalculator(@Nonnull GT_Recipe recipe) { + return super.createOverclockCalculator(recipe).enablePerfectOC(); + } + + @Override + protected @Nonnull CheckRecipeResult validateRecipe(@Nonnull GT_Recipe recipe) { + return recipe.mSpecialValue <= Digester.this.getCoilLevel() + .getHeat() ? CheckRecipeResultRegistry.SUCCESSFUL + : CheckRecipeResultRegistry.insufficientHeat(recipe.mSpecialValue); + } + + }; + } + + @Override + public boolean supportsVoidProtection() { + return true; + } + + @Override + public boolean supportsInputSeparation() { + return true; + } + + @Override + public boolean supportsBatchMode() { + return true; + } + + @Override + public boolean supportsSingleRecipeLocking() { + return true; + } + + @Override + public int getMaxEfficiency(ItemStack itemStack) { + return 10000; + } + + @Override + public int getPollutionPerTick(ItemStack aStack) { + return 20; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity arg0) { + return new Digester(this.mName); + } + + @Override + public void construct(ItemStack itemStack, boolean b) { + buildPiece(mName, itemStack, b, 3, 3, 0); + } + + @Override + public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) { + if (mMachine) return -1; + return survivialBuildPiece(mName, stackSize, 3, 3, 0, elementBudget, env, false, true); + } + + @Override + public String[] getStructureDescription(ItemStack arg0) { + return DescTextLocalization.addText("Digester.hint", 6); + } + + public ITexture[] getTexture(IGregTechTileEntity te, ForgeDirection side, ForgeDirection facing, int colorIndex, + boolean active, boolean redstone) { + + // Oil Cracker textures cuz I'm lazy + + if (side == facing) { + if (active) return new ITexture[] { casingTexturePages[0][47], TextureFactory.builder() + .addIcon(OVERLAY_FRONT_OIL_CRACKER_ACTIVE) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_OIL_CRACKER_ACTIVE_GLOW) + .extFacing() + .glow() + .build() }; + return new ITexture[] { casingTexturePages[0][47], TextureFactory.builder() + .addIcon(OVERLAY_FRONT_OIL_CRACKER) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_OIL_CRACKER_GLOW) + .extFacing() + .glow() + .build() }; + } + return new ITexture[] { casingTexturePages[0][47] }; + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + 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(BLUEPRINT_INFO) + .addSeparator() + .addController("Front bottom") + .addInputHatch("Hint block with dot 1") + .addInputBus("Hint block with dot 1") + .addOutputHatch("Hint block with dot 1") + .addOutputBus("Hint block with dot 1") + .addMaintenanceHatch("Hint block with dot 1") + .addMufflerHatch("Hint block with dot 1") + .toolTipFinisher("GTNH: Lanthanides"); + return tt; + } + + @Override + public IStructureDefinition<Digester> getStructureDefinition() { + return multiDefinition; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack arg0) { + // TODO Auto-generated method stub + return false; + } + + @Override + public int getDamageToComponent(ItemStack arg0) { + // TODO Auto-generated method stub + return 0; + } +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/common/tileentity/DissolutionTank.java b/lath/src/main/java/com/elisis/gtnhlanth/common/tileentity/DissolutionTank.java new file mode 100644 index 0000000000..f515024365 --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/common/tileentity/DissolutionTank.java @@ -0,0 +1,277 @@ +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.ofBlockAdder; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose; +import static gregtech.api.enums.GT_HatchElement.Energy; +import static gregtech.api.enums.GT_HatchElement.InputBus; +import static gregtech.api.enums.GT_HatchElement.InputHatch; +import static gregtech.api.enums.GT_HatchElement.Maintenance; +import static gregtech.api.enums.GT_HatchElement.OutputBus; +import static gregtech.api.enums.GT_HatchElement.OutputHatch; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_ACTIVE; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_ACTIVE_GLOW; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_OIL_CRACKER_GLOW; +import static gregtech.api.enums.Textures.BlockIcons.casingTexturePages; +import static gregtech.api.util.GT_StructureUtility.buildHatchAdder; + +import java.util.Arrays; +import java.util.List; + +import javax.annotation.Nonnull; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; + +import org.jetbrains.annotations.NotNull; + +import com.elisis.gtnhlanth.api.recipe.LanthanidesRecipeMaps; +import com.elisis.gtnhlanth.util.DescTextLocalization; +import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry; +import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; + +import gregtech.api.GregTech_API; +import gregtech.api.interfaces.ISecondaryDescribable; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.logic.ProcessingLogic; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase; +import gregtech.api.recipe.RecipeMap; +import gregtech.api.recipe.check.CheckRecipeResult; +import gregtech.api.recipe.check.CheckRecipeResultRegistry; +import gregtech.api.recipe.check.SimpleCheckRecipeResult; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_Recipe; + +public class DissolutionTank extends GT_MetaTileEntity_EnhancedMultiBlockBase<DissolutionTank> + implements ISurvivalConstructable, ISecondaryDescribable { + + private final IStructureDefinition<DissolutionTank> multiDefinition = StructureDefinition.<DissolutionTank>builder() + .addShape( + mName, + transpose( + new String[][] { { " sss ", "sssss", "sssss", "sssss", " sss " }, + { "sgggs", "g---g", "g---g", "g---g", "sgggs" }, { "sgggs", "g---g", "g---g", "g---g", "sgggs" }, + { "ss~ss", "shhhs", "shhhs", "shhhs", "sssss" }, { "s s", " ", " ", " ", "s s" } })) + .addElement( + 's', + buildHatchAdder(DissolutionTank.class) + .atLeast(InputHatch, OutputHatch, InputBus, OutputBus, Maintenance, Energy) + .casingIndex(49) + .dot(1) + .buildAndChain(GregTech_API.sBlockCasings4, 1)) + .addElement('h', ofBlock(GregTech_API.sBlockCasings1, 11)) + .addElement('g', ofBlockAdder(DissolutionTank::addGlass, ItemRegistry.bw_glasses[0], 1)) + .build(); + + public DissolutionTank(String name) { + super(name); + } + + public DissolutionTank(int id, String name, String nameRegional) { + super(id, name, nameRegional); + } + + @Override + public IStructureDefinition<DissolutionTank> getStructureDefinition() { + return multiDefinition; + } + + @Override + public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + return checkPiece(mName, 2, 3, 0) && mMaintenanceHatches.size() == 1; + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return true; + } + + private boolean addGlass(Block block, int meta) { + return block == ItemRegistry.bw_glasses[0]; + } + + @Override + public RecipeMap<?> getRecipeMap() { + return LanthanidesRecipeMaps.dissolutionTankRecipes; + } + + @Override + protected ProcessingLogic createProcessingLogic() { + return new ProcessingLogic() { + + @NotNull + @Override + protected CheckRecipeResult onRecipeStart(@Nonnull GT_Recipe recipe) { + if (!checkRatio(recipe, Arrays.asList(inputFluids))) { + criticalStopMachine(); + return SimpleCheckRecipeResult.ofFailurePersistOnShutdown("dissolution_ratio"); + } + return CheckRecipeResultRegistry.SUCCESSFUL; + } + + }; + } + + @Override + public boolean supportsVoidProtection() { + return true; + } + + @Override + public boolean supportsInputSeparation() { + return true; + } + + @Override + public boolean supportsBatchMode() { + return true; + } + + @Override + public boolean supportsSingleRecipeLocking() { + return true; + } + + private boolean checkRatio(GT_Recipe tRecipe, List<FluidStack> tFluidInputs) { + FluidStack majorGenericFluid = tRecipe.mFluidInputs[0]; + FluidStack minorGenericFluid = tRecipe.mFluidInputs[1]; + + // FluidStack majorInput = null; + // FluidStack minorInput = null; + + int majorAmount; + int minorAmount; + + FluidStack fluidInputOne = tFluidInputs.get(0); + FluidStack fluidInputTwo = tFluidInputs.get(1); + + // majorInput = ((fluidInputOne.getUnlocalizedName().equals(majorGenericFluid.getUnlocalizedName())) + // ? fluidInputOne + // : fluidInputTwo); + // GT_Log.out.print(majorInput.getLocalizedName()); + if (fluidInputOne.getUnlocalizedName() + .equals(majorGenericFluid.getUnlocalizedName())) { + if (fluidInputTwo.getUnlocalizedName() + .equals(minorGenericFluid.getUnlocalizedName())) { + // majorInput = fluidInputOne; + majorAmount = fluidInputOne.amount; + // minorInput = fluidInputTwo; + minorAmount = fluidInputTwo.amount; + // GT_Log.out.print("in first IF"); + } else return false; // No valid other input + + } else if (fluidInputTwo.getUnlocalizedName() + .equals(majorGenericFluid.getUnlocalizedName())) { + if (fluidInputOne.getUnlocalizedName() + .equals(minorGenericFluid.getUnlocalizedName())) { + // majorInput = fluidInputTwo; + majorAmount = fluidInputTwo.amount; + // minorInput = fluidInputOne; + minorAmount = fluidInputOne.amount; + // GT_Log.out.print("in second if"); + } else return false; + + } else return false; + + // GT_Log.out.print("out of switch weirdness"); + + // GT_Log.out.print("major " + majorInput.getLocalizedName()); + // GT_Log.out.print("minor " + minorInput.getLocalizedName()); + + // GT_Log.out.print("mjrinputamt " + majorInput.amount); + return majorAmount / tRecipe.mSpecialValue == minorAmount; + } + + @Override + public int getMaxEfficiency(ItemStack itemStack) { + return 10000; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity arg0) { + return new DissolutionTank(this.mName); + } + + @Override + public void construct(ItemStack itemStack, boolean b) { + buildPiece(mName, itemStack, b, 2, 3, 0); + } + + @Override + public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) { + if (mMachine) return -1; + return survivialBuildPiece(mName, stackSize, 2, 3, 0, elementBudget, env, false, true); + } + + @Override + public String[] getStructureDescription(ItemStack arg0) { + return DescTextLocalization.addText("DissolutionTank.hint", 4); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity te, ForgeDirection side, ForgeDirection facing, int colorIndex, + boolean active, boolean redstone) { + + if (side == facing) { + if (active) return new ITexture[] { casingTexturePages[0][49], TextureFactory.builder() + .addIcon(OVERLAY_FRONT_OIL_CRACKER_ACTIVE) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_OIL_CRACKER_ACTIVE_GLOW) + .extFacing() + .glow() + .build() }; + return new ITexture[] { casingTexturePages[0][49], TextureFactory.builder() + .addIcon(OVERLAY_FRONT_OIL_CRACKER) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_OIL_CRACKER_GLOW) + .extFacing() + .glow() + .build() }; + } + return new ITexture[] { casingTexturePages[0][49] }; + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Dissolution Tank") + .addInfo("Controller block for the Dissolution Tank") + .addInfo("Input Water and Fluid, output Fluid") + .addInfo("You must input the Fluids at the correct Ratio") + .addInfo(BLUEPRINT_INFO) + .addSeparator() + .addController("Front bottom") + .addInputHatch("Hint block with dot 1") + .addInputBus("Hint block with dot 1") + .addOutputHatch("Hint block with dot 1") + .addOutputBus("Hint block with dot 1") + .addMaintenanceHatch("Hint block with dot 1") + .toolTipFinisher("GTNH: Lanthanides"); + + return tt; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack arg0) { + return false; + } + + @Override + public int getDamageToComponent(ItemStack arg0) { + return 0; + } +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/loader/BotRecipes.java b/lath/src/main/java/com/elisis/gtnhlanth/loader/BotRecipes.java new file mode 100644 index 0000000000..a0480b62dd --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/loader/BotRecipes.java @@ -0,0 +1,267 @@ +package com.elisis.gtnhlanth.loader; + +import static com.elisis.gtnhlanth.common.register.BotWerkstoffMaterialPool.*; +import static gregtech.api.enums.OrePrefixes.*; +import static gregtech.api.recipe.RecipeMaps.chemicalReactorRecipes; +import static gregtech.api.recipe.RecipeMaps.electrolyzerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.UniversalChemical; + +import java.util.HashSet; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +import com.elisis.gtnhlanth.common.register.BotWerkstoffMaterialPool; +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import ic2.core.Ic2Items; + +/* + * Originally authored by botn365 under the MIT License. See BotdustriesLICENSE + */ + +public class BotRecipes { + + public static void addGTRecipe() { + ItemStack C1 = GT_Utility.getIntegratedCircuit(1); + ItemStack C2 = GT_Utility.getIntegratedCircuit(2); + ItemStack C24 = GT_Utility.getIntegratedCircuit(24); + + // CaCO3 + 2HCl = H2O + CO2 + CaCl2 + GT_Values.RA.addChemicalRecipe( + Materials.Calcite.getDust(5), + Materials.Empty.getCells(1), + Materials.HydrochloricAcid.getFluid(2000), + Materials.Water.getFluid(1000), + Materials.CarbonDioxide.getCells(1), + WerkstoffLoader.CalciumChloride.get(dust, 3), + 80, + 120); + + // tungsten chain + FluidStack sodiumTungsten = SodiumTungstate.getFluidOrGas(1000); + ItemStack scheelite = Materials.Scheelite.getDust(6); + + // Li2WO4 + 2Na = Na2WO4 + 2Li + GT_Values.RA.addAutoclaveRecipe( + Materials.Tungstate.getDust(7), + Materials.Sodium.getDust(2), + Materials.Water.getFluid(4000), + sodiumTungsten, + Materials.Lithium.getDust(2), + 10000, + 100, + 1920, + false); + + // MnWO4 + 2Na = Na2WO4 + Mn + GT_Values.RA.addAutoclaveRecipe( + WerkstoffLoader.Huebnerit.get(dust, 6), + Materials.Sodium.getDust(2), + Materials.Water.getFluid(4000), + sodiumTungsten, + Materials.Manganese.getDust(1), + 10000, + 100, + 1920, + false); + + // FeWO4 + 2Na = Na2WO4 + Fe + GT_Values.RA.addAutoclaveRecipe( + WerkstoffLoader.Ferberite.get(dust, 6), + Materials.Sodium.getDust(2), + Materials.Water.getFluid(4000), + sodiumTungsten, + Materials.Iron.getDust(1), + 10000, + 100, + 1920, + false); + + // CaCl2 + Na2WO4 = 2NaCl + CaWO4 + ItemStack Ca2Cl = WerkstoffLoader.CalciumChloride.get(dust, 3); + GT_Values.RA + .addChemicalRecipe(Ca2Cl, null, sodiumTungsten, null, scheelite, Materials.Salt.getDust(4), 100, 480); + + ItemStack H2WO4 = TungsticAcid.get(dust, 7); + // CaWO4 + 2HCl = H2WO4 + CaCl2 + GT_Values.RA.addChemicalRecipe( + scheelite, + null, + Materials.HydrochloricAcid.getFluid(2000), + null, + H2WO4, + Ca2Cl, + 50, + 1920); + + ItemStack WO3 = TungstenTrioxide.get(dust, 4); + // H2WO4 = WO3 + H2O + GT_Values.RA.addBlastRecipe(H2WO4, null, null, null, WO3, null, 200, 480, 1200); + + // WO3 + 6H = W + 3H2O + GT_Values.RA.addBlastRecipe( + WO3, + C2, + Materials.Hydrogen.getGas(6000), + GT_ModHandler.getSteam(3000), + Materials.Tungsten.getDust(1), + null, + 100, + 1920, + 1000); + + WO3.stackSize = 8; + // 2WO3 + 3C = 2W + 3CO2 + GT_Values.RA.addBlastRecipe( + WO3, + Materials.Carbon.getDust(3), + null, + Materials.CarbonDioxide.getGas(3000), + GT_OreDictUnificator.get(ingotHot, Materials.Tungsten, 2L), + null, + 8000, + 1920, + 3000); + + // rocket fuels + // LMP103S + // 2Cl + CO = COCl2 + + GT_Values.RA.stdBuilder() + .itemInputs(Materials.CarbonMonoxide.getCells(1), GT_Utility.getIntegratedCircuit(12)) + .itemOutputs(Phosgene.get(cell, 1)) + .fluidInputs(Materials.Chlorine.getGas(2000)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_HV) + .addTo(chemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Chlorine.getCells(2), GT_Utility.getIntegratedCircuit(12)) + .itemOutputs(Phosgene.get(cell, 1), Materials.Empty.getCells(1)) + .fluidInputs(Materials.CarbonMonoxide.getGas(1000)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_HV) + .addTo(chemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(Materials.CarbonMonoxide.getCells(1), Materials.Chlorine.getCells(2)) + .itemOutputs(Phosgene.get(cell, 1), Materials.Empty.getCells(2)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_HV) + .addTo(chemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Chlorine.getCells(2), GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(Materials.Empty.getCells(2)) + .fluidInputs(Materials.CarbonMonoxide.getGas(1000)) + .fluidOutputs(BotWerkstoffMaterialPool.Phosgene.getFluidOrGas(1000)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_HV) + .addTo(UniversalChemical); + + // H3PO4 = P + H2O + GT_Values.RA.addDistilleryRecipe( + C2, + Materials.PhosphoricAcid.getFluid(1000), + Materials.Water.getFluid(500), + Materials.Phosphorus.getDust(1), + 20, + 480, + false); + + ItemStack cells = Ic2Items.cell.copy(); + cells.stackSize = 1; + // NH4Cl = HCl + NH3 + GT_Values.RA.addDistilleryRecipe( + cells, + WerkstoffLoader.AmmoniumChloride.getFluidOrGas(1000), + Materials.HydrochloricAcid.getFluid(1000), + Materials.Ammonia.getCells(1), + 50, + 120, + false); + + // N2H4O3 + NaOH = NaNO3 + NH3 + H2O + GT_Values.RA.addChemicalRecipeForBasicMachineOnly( + AmmoniumNitrate.get(dust, 9), + Materials.SodiumHydroxide.getDust(3), + null, + Materials.Ammonia.getGas(1000), + WerkstoffLoader.SodiumNitrate.get(dust, 5), + null, + 100, + 480); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { AmmoniumNitrate.get(dust, 9), Materials.SodiumHydroxide.getDust(3), C2 }, + null, + new FluidStack[] { Materials.Ammonia.getGas(1000), Materials.Water.getFluid(1000) }, + new ItemStack[] { WerkstoffLoader.SodiumNitrate.get(dust, 5) }, + 100, + 480); + + // N2H4O3 + NaOH + H =H2SO4= NH3 + HNO3 + Na + H2O + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { C24, AmmoniumNitrate.get(dust, 9), Materials.SodiumHydroxide.getDust(3) }, + new FluidStack[] { Materials.SulfuricAcid.getFluid(1000), Materials.Hydrogen.getGas(1000) }, + new FluidStack[] { Materials.Ammonia.getGas(1000), Materials.NitricAcid.getFluid(1000), + Materials.DilutedSulfuricAcid.getFluid(1000) }, + new ItemStack[] { Materials.Sodium.getDust(1) }, + 300, + 480); + + // Monomethylhydrazine + cells.stackSize = 1; + // C7H8 + CH4O = C8H10 + H2O + GT_Values.RA.addCrackingRecipe( + 1, + Materials.Toluene.getFluid(1000), + Materials.Methanol.getFluid(1000), + OXylene.getFluidOrGas(1000), + 600, + 4096); + + // 2HNO3 + C3H8 = 2CH3NO2 + 2H2O + C + GT_Values.RA.addCrackingRecipe( + 2, + Materials.Propane.getGas(1000), + Materials.NitricAcid.getFluid(2000), + Nitromethane.getFluidOrGas(2000), + 300, + 1920); + } + + public static void removeRecipes() { + BotRecipes.removeTungstenElectro(); + } + + public static void removeTungstenElectro() { + HashSet<GT_Recipe> toDel = new HashSet<>(); + ItemStack[] toRemove = { Materials.Scheelite.getDust(1), Materials.Tungstate.getDust(1), + WerkstoffLoader.Ferberite.get(dust, 1), WerkstoffLoader.Huebnerit.get(dust, 1) }; + for (GT_Recipe tRecipe : electrolyzerRecipes.getAllRecipes()) { + if (tRecipe.mFakeRecipe) continue; + for (int i = 0; i < tRecipe.mInputs.length; i++) { + ItemStack tItem = tRecipe.mInputs[i]; + if (item == null || !GT_Utility.isStackValid(tItem)) continue; + for (ItemStack tStack : toRemove) { + if (GT_Utility.areStacksEqual(tItem, tStack)) { + toDel.add(tRecipe); + continue; + } + } + } + } + electrolyzerRecipes.getBackend() + .removeRecipes(toDel); + electrolyzerRecipes.getBackend() + .reInit(); + } +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/loader/MetaTileEntity_Loader.java b/lath/src/main/java/com/elisis/gtnhlanth/loader/MetaTileEntity_Loader.java new file mode 100644 index 0000000000..e24034c663 --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/loader/MetaTileEntity_Loader.java @@ -0,0 +1,4 @@ +package com.elisis.gtnhlanth.loader; + +public class MetaTileEntity_Loader { +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/loader/RecipeLoader.java b/lath/src/main/java/com/elisis/gtnhlanth/loader/RecipeLoader.java new file mode 100644 index 0000000000..d5c7d63f8d --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/loader/RecipeLoader.java @@ -0,0 +1,3744 @@ +package com.elisis.gtnhlanth.loader; + +import static com.elisis.gtnhlanth.api.recipe.LanthanidesRecipeMaps.digesterRecipes; +import static com.elisis.gtnhlanth.api.recipe.LanthanidesRecipeMaps.dissolutionTankRecipes; +import static com.elisis.gtnhlanth.common.register.WerkstoffMaterialPool.*; +import static gregtech.api.recipe.RecipeMaps.autoclaveRecipes; +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.centrifugeNonCellRecipes; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.chemicalBathRecipes; +import static gregtech.api.recipe.RecipeMaps.distillationTowerRecipes; +import static gregtech.api.recipe.RecipeMaps.electrolyzerNonCellRecipes; +import static gregtech.api.recipe.RecipeMaps.electrolyzerRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes; +import static gregtech.api.recipe.RecipeMaps.hammerRecipes; +import static gregtech.api.recipe.RecipeMaps.laserEngraverRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.recipe.RecipeMaps.mixerNonCellRecipes; +import static gregtech.api.recipe.RecipeMaps.mixerRecipes; +import static gregtech.api.recipe.RecipeMaps.multiblockChemicalReactorRecipes; +import static gregtech.api.recipe.RecipeMaps.oreWasherRecipes; +import static gregtech.api.recipe.RecipeMaps.sifterRecipes; +import static gregtech.api.recipe.RecipeMaps.thermalCentrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.vacuumFreezerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.common.items.GT_MetaGenerated_Item_01.registerCauldronCleaningFor; +import static gtPlusPlus.api.recipe.GTPPRecipeMaps.chemicalDehydratorRecipes; +import static gtPlusPlus.api.recipe.GTPPRecipeMaps.simpleWasherRecipes; +import static gtPlusPlus.api.recipe.GTPPRecipeMaps.vacuumFurnaceRecipes; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.HashSet; + +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.CraftingManager; +import net.minecraft.item.crafting.IRecipe; +import net.minecraft.item.crafting.ShapedRecipes; +import net.minecraft.item.crafting.ShapelessRecipes; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; +import net.minecraftforge.oredict.ShapedOreRecipe; +import net.minecraftforge.oredict.ShapelessOreRecipe; + +import org.apache.commons.lang3.reflect.FieldUtils; + +import com.elisis.gtnhlanth.Tags; +import com.elisis.gtnhlanth.common.register.BotWerkstoffMaterialPool; +import com.elisis.gtnhlanth.common.register.LanthItemList; +import com.elisis.gtnhlanth.common.register.WerkstoffMaterialPool; +import com.github.bartimaeusnek.bartworks.system.material.GT_Enhancement.PlatinumSludgeOverHaul; +import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader; + +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.registry.GameRegistry; +import goodgenerator.items.MyMaterial; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; + +public class RecipeLoader { + + private static final Materials[] BLACKLIST = null; + + public static void loadGeneral() { + + /* ZIRCONIUM */ + // ZrCl4 + // ZrO2 + 4HCl = ZrCl4 + 2H2O + GT_Values.RA.addChemicalRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.Zirconia.get(OrePrefixes.dust, 3), + Materials.HydrochloricAcid.getFluid(4000), + Materials.Water.getFluid(2000), + WerkstoffMaterialPool.ZirconiumTetrachloride.get(OrePrefixes.dust, 5), + 300); + + // ZrCl4-H2O + GT_Values.RA.addChemicalRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.ZirconiumTetrachloride.get(OrePrefixes.dust, 5), + Materials.Water.getFluid(1000), + WerkstoffMaterialPool.ZirconiumTetrachlorideSolution.getFluidOrGas(1000), + null, + 200); + + // Zr + // ZrCl4·H2O + 2Mg = Zr + 2MgCl2 + 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, 6), + 600, + 1920, + 4500); + + /* HAFNIUM */ + // HfCl4 + // HfO2 + 4HCl = HfCl4 + 2H2O + GT_Values.RA.addChemicalRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.Hafnia.get(OrePrefixes.dust, 3), + Materials.HydrochloricAcid.getFluid(4000), + Materials.Water.getFluid(2000), + WerkstoffMaterialPool.HafniumTetrachloride.get(OrePrefixes.dust, 5), + 300); + + // HfCl4-H2O + GT_Values.RA.addChemicalRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.HafniumTetrachloride.get(OrePrefixes.dust, 5), + Materials.Water.getFluid(1000), + WerkstoffMaterialPool.HafniumTetrachlorideSolution.getFluidOrGas(1000), + null, + 200); + + // LP-Hf + // HfCl4 + 2Mg = ??Hf?? + 2MgCl2 + 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, 6), + 600, + 1920, + 2700); + + // HfI4 + // ??Hf?? + 4I = 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, 5), + 300); + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.LowPurityHafnium.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.Iodine.get(OrePrefixes.dust, 4), + null, + null, + WerkstoffMaterialPool.HafniumIodide.get(OrePrefixes.dust, 5), + 300); + + // Hf + // HfI4 = Hf + 4I + GT_Values.RA.addBlastRecipe( + GT_Utility.getIntegratedCircuit(12), + WerkstoffMaterialPool.HafniumIodide.get(OrePrefixes.dust, 5), + null, + WerkstoffMaterialPool.Iodine.getFluidOrGas(4000), + WerkstoffMaterialPool.Hafnium.get(OrePrefixes.ingotHot, 1), + WerkstoffMaterialPool.HafniumRunoff.get(OrePrefixes.dustTiny, 1), + 600, + 1920, + 3400); + + // Hf * 9 + GT_Values.RA.addBlastRecipe( + GT_Utility.getIntegratedCircuit(13), + WerkstoffMaterialPool.HafniumIodide.get(OrePrefixes.dust, 45), + null, + WerkstoffMaterialPool.Iodine.getFluidOrGas(36000), + WerkstoffMaterialPool.Hafnium.get(OrePrefixes.ingotHot, 9), + WerkstoffMaterialPool.HafniumRunoff.get(OrePrefixes.dust, 1), + 5400, + 1920, + 3400); + + // Zirconia-Hafnia + // ??HfZr?? = HfO2 + ZrO2 + GT_Values.RA.addCentrifugeRecipe( + WerkstoffMaterialPool.HafniaZirconiaBlend.get(OrePrefixes.dust, 1), + null, + null, + null, + WerkstoffMaterialPool.Hafnia.get(OrePrefixes.dust, 3), + WerkstoffMaterialPool.Zirconia.get(OrePrefixes.dust, 3), + null, + null, + null, + null, + new int[] { 10000, 10000 }, + 600, + 1920); + + // Ammonium Nitrate + // HNO3 + NH3 = NH4NO3 + GT_Values.RA.addChemicalRecipeForBasicMachineOnly( + GT_Utility.getIntegratedCircuit(12), + Materials.NitricAcid.getCells(1), + Materials.Ammonia.getGas(1000), + WerkstoffMaterialPool.AmmoniumNitrate.getFluidOrGas(1000), + Materials.Empty.getCells(1), + null, + 30, + 400); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { GT_Utility.getIntegratedCircuit(12) }, + new FluidStack[] { Materials.NitricAcid.getFluid(1000), Materials.Ammonia.getGas(1000) }, + new FluidStack[] { WerkstoffMaterialPool.AmmoniumNitrate.getFluidOrGas(1000) }, + new ItemStack[] {}, + 30, + 400); + + // IODINE-START + // SeaweedAsh + GT_ModHandler.addSmeltingRecipe( + GT_ModHandler.getModItem("harvestcraft", "seaweedItem", 1), + WerkstoffMaterialPool.SeaweedAsh.get(OrePrefixes.dustSmall, 1)); + + // SeaweedConcentrate + GT_Values.RA.addMixerRecipe( + WerkstoffMaterialPool.SeaweedAsh.get(OrePrefixes.dust, 2), + null, + null, + null, + Materials.DilutedSulfuricAcid.getFluid(1200), + WerkstoffMaterialPool.SeaweedConcentrate.getFluidOrGas(1200), + Materials.Calcite.getDust(1), + 600, + 240); + + // SeaweedConcentrate * 4 + GT_Values.RA.addMixerRecipe( + WerkstoffMaterialPool.SeaweedAsh.get(OrePrefixes.dust, 4), + null, + null, + null, + Materials.DilutedSulfuricAcid.getFluid(2400), + WerkstoffMaterialPool.SeaweedConcentrate.getFluidOrGas(2400), + Materials.Calcite.getDust(2), + 1200, + 240); + + // Iodine + GT_Values.RA.addCentrifugeRecipe( + Materials.Benzene.getCells(1), + null, + WerkstoffMaterialPool.SeaweedConcentrate.getFluidOrGas(2000), + WerkstoffMaterialPool.SeaweedByproducts.getFluidOrGas(200), + Materials.Empty.getCells(1), + WerkstoffMaterialPool.Iodine.get(OrePrefixes.dust, 1), + null, + null, + null, + null, + new int[] { 10000, 10000 }, + 760, + 480); + + // IODINE-END + + // 2MnO2 + 2KOH + KClO3 = 2KMnO4 + H2O + KCl + GT_Values.RA.addBlastRecipe( + Materials.Pyrolusite.getDust(6), + GT_ModHandler.getModItem("dreamcraft", "item.PotassiumHydroxideDust", 6), + WerkstoffMaterialPool.PotassiumChlorate.get(OrePrefixes.dust, 5), + null, + null, + Materials.Water.getFluid(1000), + WerkstoffMaterialPool.PotassiumPermanganate.get(OrePrefixes.dust, 12), + Materials.RockSalt.getDust(2), + null, + null, + 150, + 480, + 1200); + + // Mn + 2O = MnO2 + GT_Values.RA.addChemicalRecipe( + Materials.Manganese.getDust(1), + GT_Utility.getIntegratedCircuit(1), + Materials.Oxygen.getGas(2000), + null, + Materials.Pyrolusite.getDust(3), + 40, + 30); + + // 6KOH + 6Cl = KClO3 + 5KCl + 3H2O + GT_Values.RA.addChemicalRecipe( + GT_ModHandler.getModItem("dreamcraft", "item.PotassiumHydroxideDust", 18), + GT_Utility.getIntegratedCircuit(3), + Materials.Chlorine.getGas(6000), + Materials.Water.getFluid(3000), + Materials.RockSalt.getDust(10), + WerkstoffMaterialPool.PotassiumChlorate.get(OrePrefixes.dust, 5), + 40, + 30); + + /* + * //Fluorosilicic Acid GT_Values.RA.addChemicalRecipe( GT_Utility.getIntegratedCircuit(1), + * Materials.SiliconDioxide.getDust(1), Materials.HydrofluoricAcid.getFluid(6000), + * WerkstoffMaterialPool.FluorosilicicAcid.getFluidOrGas(1000), null, 300, 600 ); + */ + // Sodium Fluorosilicate + // 2NaCl + H2SiF6 = 2HCl + Na2SiF6 + GT_Values.RA.addChemicalRecipe( + Materials.Empty.getCells(2), + Materials.Salt.getDust(4), + WerkstoffLoader.HexafluorosilicicAcid.getFluidOrGas(1000), + WerkstoffMaterialPool.SodiumFluorosilicate.getFluidOrGas(1000), + Materials.HydrochloricAcid.getCells(2), + 600, + 450); + } + + public static void loadLanthanideRecipes() { + // Methanol + // CH4O + CO + 3O =V2O5= H2C2O4 + H2O + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { MyMaterial.vanadiumPentoxide.get(OrePrefixes.dustTiny, 1) }, + new FluidStack[] { Materials.Methanol.getFluid(1000), Materials.CarbonMonoxide.getGas(1000), + Materials.Oxygen.getGas(3000) }, + new FluidStack[] { MyMaterial.oxalate.getFluidOrGas(1000), Materials.Water.getFluid(1000) }, + null, + 450, + 240); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { GT_Utility.getIntegratedCircuit(9), + MyMaterial.vanadiumPentoxide.get(OrePrefixes.dust, 1) }, + new FluidStack[] { Materials.Methanol.getFluid(9000), Materials.CarbonMonoxide.getGas(9000), + Materials.Oxygen.getGas(27000) }, + new FluidStack[] { MyMaterial.oxalate.getFluidOrGas(9000), Materials.Water.getFluid(9000) }, + null, + 4050, + 240); + + // Ethanol + // C2H6O + 5O =V2O5= H2C2O4 + 2H2O + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { MyMaterial.vanadiumPentoxide.get(OrePrefixes.dustTiny, 1) }, + new FluidStack[] { Materials.Ethanol.getFluid(1000), Materials.Oxygen.getGas(5000) }, + new FluidStack[] { MyMaterial.oxalate.getFluidOrGas(1000), Materials.Water.getFluid(2000) }, + null, + 450, + 240); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { GT_Utility.getIntegratedCircuit(9), + MyMaterial.vanadiumPentoxide.get(OrePrefixes.dust, 1) }, + new FluidStack[] { Materials.Ethanol.getFluid(9000), Materials.Oxygen.getGas(45000) }, + new FluidStack[] { MyMaterial.oxalate.getFluidOrGas(9000), Materials.Water.getFluid(18000) }, + null, + 4050, + 240); + + // GT_Values.RA.addChemicalRecipe( + // GT_Utility.getIntegratedCircuit(2), + // WerkstoffMaterialPool.CeriumDioxide + // + // ) + + // Cerium Oxalate + // 2CeCl3 + 3H2C2O4 = 6HCl + Ce2(C2O4)3 + GT_Values.RA.addChemicalRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.CeriumChloride.get(OrePrefixes.dust, 8), + MyMaterial.oxalate.getFluidOrGas(3000), + Materials.HydrochloricAcid.getFluid(6000), + WerkstoffMaterialPool.CeriumOxalate.get(OrePrefixes.dust, 5), + null, + 300, + 450); + + // Cerium + // Ce2O3 = 2Ce + 3O + 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 + // MONAZITE + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.NitricAcid.getFluid(700)) + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Monazite, 2)) + .fluidOutputs(WerkstoffMaterialPool.MuddyRareEarthMonaziteSolution.getFluidOrGas(400)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .eut(1920) + .duration(400) + .specialValue(800) + .addTo(digesterRecipes); + + GT_Values.RA.stdBuilder() + .fluidInputs( + Materials.Water.getFluid(10000), + WerkstoffMaterialPool.MuddyRareEarthMonaziteSolution.getFluidOrGas(1000)) + .itemInputs(GT_Utility.getIntegratedCircuit(1), Materials.Saltpeter.getDust(1)) + .fluidOutputs(WerkstoffMaterialPool.DilutedRareEarthMonaziteMud.getFluidOrGas(11000)) + .itemOutputs( + WerkstoffMaterialPool.HafniaZirconiaBlend.get(OrePrefixes.dustTiny, 4), + WerkstoffLoader.Thorianit.get(OrePrefixes.dust, 1), + Materials.Monazite.getDustTiny(2)) + .eut(480) + .duration(900) + .specialValue(10) + .noOptimize() + .addTo(dissolutionTankRecipes); + + GT_Values.RA.stdBuilder() + .fluidInputs( + Materials.Water.getFluid(90000), + WerkstoffMaterialPool.MuddyRareEarthMonaziteSolution.getFluidOrGas(9000)) + .itemInputs(GT_Utility.getIntegratedCircuit(9), Materials.Saltpeter.getDust(9)) + .fluidOutputs(WerkstoffMaterialPool.DilutedRareEarthMonaziteMud.getFluidOrGas(99000)) + .itemOutputs( + WerkstoffMaterialPool.HafniaZirconiaBlend.get(OrePrefixes.dust, 4), + WerkstoffLoader.Thorianit.get(OrePrefixes.dust, 9), + Materials.Monazite.getDust(2)) + .eut(480) + .duration(8100) + .specialValue(10) + .noOptimize() + .addTo(dissolutionTankRecipes); + + sifterRecipes.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[] { 9000, 7500, 2000, 500, 2000 }, + new FluidStack[] { WerkstoffMaterialPool.DilutedRareEarthMonaziteMud.getFluidOrGas(1000) }, + null, + 400, + 240, + 0); + + GT_Values.RA.addMixerRecipe( + WerkstoffMaterialPool.MonaziteSulfate.get(OrePrefixes.dust, 1), + null, + null, + null, + null, + null, + Materials.Water.getFluid(6000), + WerkstoffMaterialPool.DilutedMonaziteSulfate.getFluidOrGas(7000), + null, + 480, + 400); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { GT_Utility.getIntegratedCircuit(13) }, + new FluidStack[] { WerkstoffMaterialPool.DilutedMonaziteSulfate.getFluidOrGas(1000), + WerkstoffMaterialPool.AmmoniumNitrate.getFluidOrGas(200) }, + null, + new ItemStack[] { WerkstoffMaterialPool.AcidicMonazitePowder.get(OrePrefixes.dustTiny, 3), }, + 480, + 480); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { GT_Utility.getIntegratedCircuit(14) }, + new FluidStack[] { WerkstoffMaterialPool.DilutedMonaziteSulfate.getFluidOrGas(9000), + WerkstoffMaterialPool.AmmoniumNitrate.getFluidOrGas(1800) }, + null, + new ItemStack[] { WerkstoffMaterialPool.AcidicMonazitePowder.get(OrePrefixes.dust, 3), }, + 4320, + 480); + + GT_Values.RA.addSifterRecipe( + WerkstoffMaterialPool.AcidicMonazitePowder.get(OrePrefixes.dust, 1), + new ItemStack[] { WerkstoffMaterialPool.MonaziteRareEarthFiltrate.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.ThoriumPhosphateCake.get(OrePrefixes.dust, 1) }, + new int[] { 9000, 7000 }, + 600, + 256); + + GT_Values.RA.addBlastRecipe( + WerkstoffMaterialPool.ThoriumPhosphateCake.get(OrePrefixes.dust, 1), + null, + null, + null, + WerkstoffMaterialPool.ThoriumPhosphateConcentrate.get(OrePrefixes.dust, 1), + null, + 300, + 128, + 1500); + + GT_Values.RA.addThermalCentrifugeRecipe( + WerkstoffMaterialPool.ThoriumPhosphateConcentrate.get(OrePrefixes.dust), + Materials.Thorium.getDust(1), + Materials.Phosphate.getDust(1), + null, + new int[] { 10000, 10000 }, + 200, + 480); + + GT_Values.RA.addChemicalBathRecipe( + WerkstoffMaterialPool.MonaziteRareEarthFiltrate.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.AmmoniumNitrate.getFluidOrGas(320), + WerkstoffMaterialPool.NeutralizedMonaziteRareEarthFiltrate.get(OrePrefixes.dust, 1), + null, + null, + new int[] { 10000 }, + 120, + 240); + + GT_Values.RA.addSifterRecipe( + WerkstoffMaterialPool.NeutralizedMonaziteRareEarthFiltrate.get(OrePrefixes.dust, 1), + new ItemStack[] { WerkstoffMaterialPool.MonaziteRareEarthHydroxideConcentrate.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.UraniumFiltrate.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.UraniumFiltrate.get(OrePrefixes.dust, 1) }, + new int[] { 9000, 5000, 4000 }, + 800, + 480); + + GT_Values.RA.addChemicalBathRecipe( + WerkstoffMaterialPool.UraniumFiltrate.get(OrePrefixes.dust, 1), + Materials.HydrofluoricAcid.getFluid(100), + WerkstoffMaterialPool.NeutralizedUraniumFiltrate.get(OrePrefixes.dust, 1), + null, + null, + new int[] { 10000 }, + 360, + 120); + + GT_Values.RA.addSifterRecipe( + WerkstoffMaterialPool.NeutralizedUraniumFiltrate.get(OrePrefixes.dust, 1), + new ItemStack[] { Materials.Uranium.getDust(1), Materials.Uranium.getDust(1), Materials.Uranium.getDust(1), + Materials.Uranium235.getDust(1), Materials.Uranium235.getDust(1), }, + new int[] { 4500, 4000, 3000, 3000, 2000 }, + 1000, + 30); + + GT_Values.RA.addBlastRecipe( + WerkstoffMaterialPool.MonaziteRareEarthHydroxideConcentrate.get(OrePrefixes.dust, 1), + null, + null, + null, + WerkstoffMaterialPool.DriedMonaziteRareEarthConcentrate.get(OrePrefixes.dust, 1), + null, + 300, + 120, + 1200); + + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.DriedMonaziteRareEarthConcentrate.get(OrePrefixes.dust, 1), + null, + Materials.NitricAcid.getFluid(500), + WerkstoffMaterialPool.NitratedRareEarthMonaziteConcentrate.getFluidOrGas(1000), + null, + 500, + 480); + + GT_Values.RA.addMixerRecipe( + Materials.Water.getCells(1), + null, + null, + null, + WerkstoffMaterialPool.NitratedRareEarthMonaziteConcentrate.getFluidOrGas(1000), + WerkstoffMaterialPool.NitricLeachedMonaziteMixture.getFluidOrGas(1000), + Materials.Empty.getCells(1), + 200, + 120); + + GT_Values.RA.addMixerRecipe( + WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 3), + null, + null, + null, + WerkstoffMaterialPool.NitratedRareEarthMonaziteConcentrate.getFluidOrGas(1000), + WerkstoffMaterialPool.NitricLeachedMonaziteMixture.getFluidOrGas(2000), + null, + 220, + 120); + + sifterRecipes.addRecipe( + false, + null, + new ItemStack[] { WerkstoffMaterialPool.CeriumDioxide.get(OrePrefixes.dust, 1) }, + null, + new int[] { 1111 }, + new FluidStack[] { WerkstoffMaterialPool.NitricLeachedMonaziteMixture.getFluidOrGas(1000) }, + new FluidStack[] { WerkstoffMaterialPool.NitricMonaziteLeachedConcentrate.getFluidOrGas(1000) }, + 400, + 240, + 0); + + // BEGIN Cerium + // Cerium-rich mixture + 3HCl = CeCl3 + Monazite (to allow cerium processing without bastnazite/monazite) + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 15), + null, + Materials.HydrochloricAcid.getFluid(750), + Materials.Water.getFluid(750), + WerkstoffMaterialPool.CeriumChloride.get(OrePrefixes.dust, 1), + Materials.Monazite.getDust(1), + 300, + 450); + // CeO2 + 3NH4Cl + H = 3NH3 + CeCl3 + 2H2O + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.CeriumDioxide.get(OrePrefixes.dust, 3), + WerkstoffLoader.AmmoniumChloride.get(OrePrefixes.cell, 3), + Materials.Hydrogen.getGas(1000), + Materials.Water.getGas(2000), + WerkstoffMaterialPool.CeriumChloride.get(OrePrefixes.dust, 4), + Materials.Ammonia.getCells(3), + 300, + 450); + + // Ce2(C2O4)3 + 3C = Ce2O3 + 9CO + GT_Values.RA.addBlastRecipe( + WerkstoffMaterialPool.CeriumOxalate.get(OrePrefixes.dust, 5), + Materials.Carbon.getDust(3), + null, + Materials.CarbonMonoxide.getGas(9000), + WerkstoffMaterialPool.CeriumIIIOxide.get(OrePrefixes.dust, 5), + null, + 200, + 480, + 800); + + // END Cerium (NMLC) + + vacuumFreezerRecipes.addRecipe( // Uses fluid, outputs item. Yet another hacky recipe + false, + null, + new ItemStack[] { WerkstoffMaterialPool.CooledMonaziteRareEarthConcentrate.get(OrePrefixes.dust, 1), // TODO: + // Perhaps + // add + // more + // shit + // on + // output + }, + null, + new FluidStack[] { WerkstoffMaterialPool.NitricMonaziteLeachedConcentrate.getFluidOrGas(1000) }, + null, + 100, + 240, + 0); + + GT_Values.RA.addElectromagneticSeparatorRecipe( + WerkstoffMaterialPool.CooledMonaziteRareEarthConcentrate.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.MonaziteRarerEarthSediment.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.EuropiumIIIOxide.get(OrePrefixes.dust, 5), // Maybe also holmium + null, + new int[] { 9000, 500 }, + 600, + 1920); + + // 5Eu2O3 + Eu = 4EuO + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.EuropiumIIIOxide.get(OrePrefixes.dust, 5), + Materials.Europium.getDust(1), + null, + null, + WerkstoffMaterialPool.EuropiumOxide.get(OrePrefixes.dust, 6), + 300, + 8400); + + // 4 EuO = 2 Eu + 2O2 + GT_Values.RA.addElectrolyzerRecipe( + WerkstoffMaterialPool.EuropiumOxide.get(OrePrefixes.dust, 2), + null, + null, + Materials.Oxygen.getGas(1000L), + Materials.Europium.getDust(1), + null, + null, + null, + null, + null, + new int[] { 10000, 10000 }, + 300, + 33000); + + // EuS = Eu + S + // TODO old recipe. for compat only. remove material and recipe half a year later, i.e. after September 2023. + GT_Values.RA.addElectrolyzerRecipe( + WerkstoffMaterialPool.EuropiumSulfide.get(OrePrefixes.dust, 2), + null, + null, + null, + Materials.Europium.getDust(1), + Materials.Sulfur.getDust(1), + null, + null, + null, + null, + new int[] { 10000, 10000 }, + 600, + 33000); + + GT_Values.RA.addBlastRecipe( + WerkstoffMaterialPool.MonaziteRarerEarthSediment.get(OrePrefixes.dust, 1), + null, + Materials.Chlorine.getGas(1000), + null, + WerkstoffMaterialPool.MonaziteHeterogenousHalogenicRareEarthMixture.get(OrePrefixes.dust, 1), + null, + 500, + 480, + 1200); + + GT_Values.RA.addMixerRecipe( + Materials.Salt.getDust(1), + WerkstoffMaterialPool.MonaziteHeterogenousHalogenicRareEarthMixture.get(OrePrefixes.dust, 1), + null, + null, + Materials.Acetone.getFluid(1000), + null, + WerkstoffMaterialPool.SaturatedMonaziteRareEarthMixture.get(OrePrefixes.dust, 1), + 200, + 240); + + GT_Values.RA.addMixerRecipe( + WerkstoffMaterialPool.MonaziteHeterogenousHalogenicRareEarthMixture.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 2), + null, + null, + Materials.Acetone.getFluid(1000), + null, + WerkstoffMaterialPool.SaturatedMonaziteRareEarthMixture.get(OrePrefixes.dust, 3), + 400, + 240); + /* + * GT_Values.RA.addCentrifugeRecipe( + * WerkstoffMaterialPool.SaturatedMonaziteRareEarthMixture.get(OrePrefixes.dust, 2), null, null, + * Materials.Chloromethane.getGas(200), WerkstoffMaterialPool.SamaricResidue.get(OrePrefixes.dustSmall, 6), + * null, //TODO null, null, null, null, new int[] { 10000, //10000 }, 700, 1920 ); + */ + GT_Values.RA.addCentrifugeRecipe( + GT_Utility.getIntegratedCircuit(4), + WerkstoffMaterialPool.SaturatedMonaziteRareEarthMixture.get(OrePrefixes.dust, 8), + null, + Materials.Chloromethane.getGas(800), + WerkstoffMaterialPool.SamaricResidue.get(OrePrefixes.dust, 6), + null, // WerkstoffMaterialPool.UnknownBlend.get(OrePrefixes.dust, 2) TODO + null, + null, + null, + null, + new int[] { 10000, // 10000 + }, + 6300, + 1920); + + GT_Values.RA.addSifterRecipe( + WerkstoffMaterialPool.SamaricResidue.get(OrePrefixes.dust, 9), + new ItemStack[] { Materials.Samarium.getDust(6), Materials.Gadolinium.getDust(3) }, + new int[] { 10000, 10000 }, + 400, + 1920); + + // BASTNASITE (god help me) + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.NitricAcid.getFluid(700)) + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Bastnasite, 2)) + .fluidOutputs(WerkstoffMaterialPool.MuddyRareEarthBastnasiteSolution.getFluidOrGas(400)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .eut(1920) + .duration(400) + .specialValue(800) + .addTo(digesterRecipes); + + GT_Values.RA.addCrackingRecipe( + 1, + WerkstoffMaterialPool.MuddyRareEarthBastnasiteSolution.getFluidOrGas(1000), + GT_ModHandler.getSteam(1000), + WerkstoffMaterialPool.SteamCrackedBasnasiteSolution.getFluidOrGas(2000), + 600, + 480); + + GT_Values.RA.addMixerRecipe( + GT_Utility.getIntegratedCircuit(6), + WerkstoffMaterialPool.SteamCrackedBasnasiteSolution.get(OrePrefixes.cell, 1), + null, + null, + WerkstoffMaterialPool.SodiumFluorosilicate.getFluidOrGas(320), + WerkstoffMaterialPool.ConditionedBastnasiteMud.getFluidOrGas(1320), + Materials.Empty.getCells(1), + 800, + 120); + + GT_Values.RA.stdBuilder() + .fluidInputs( + Materials.Water.getFluid(10000), + WerkstoffMaterialPool.ConditionedBastnasiteMud.getFluidOrGas(1000)) + .itemInputs(Materials.Saltpeter.getDust(1)) + .fluidOutputs(WerkstoffMaterialPool.DiltedRareEarthBastnasiteMud.getFluidOrGas(11000)) + .itemOutputs(WerkstoffMaterialPool.Gangue.get(OrePrefixes.dust, 1)) + .eut(1920) + .duration(1000) + .specialValue(10) + .noOptimize() + .addTo(dissolutionTankRecipes); + + sifterRecipes.addRecipe( + false, + null, + new ItemStack[] { Materials.SiliconDioxide.getDust(1), Materials.Rutile.getDust(1), + WerkstoffLoader.RedZircon.get(OrePrefixes.dust, 1), // TODO:Change outputs to complement + // Monazite + Materials.Ilmenite.getDust(1) }, + null, + new int[] { 9000, 7500, 1000, 500, 2000 }, + new FluidStack[] { WerkstoffMaterialPool.DiltedRareEarthBastnasiteMud.getFluidOrGas(1000) }, + new FluidStack[] { WerkstoffMaterialPool.FilteredBastnasiteMud.getFluidOrGas(400) }, + 400, + 240, + 0); + + GT_Values.RA.addBlastRecipe( + GT_Utility.getIntegratedCircuit(1), + null, + WerkstoffMaterialPool.FilteredBastnasiteMud.getFluidOrGas(1000), + null, // TODO: Maybe add some useful shit? + WerkstoffMaterialPool.BastnasiteRareEarthOxidePowder.get(OrePrefixes.dust, 1), + null, // See above + 500, + 600, + 1400); + + GT_Values.RA.addChemicalBathRecipe( + WerkstoffMaterialPool.BastnasiteRareEarthOxidePowder.get(OrePrefixes.dust, 1), + Materials.HydrochloricAcid.getFluid(500), + WerkstoffMaterialPool.LeachedBastnasiteRareEarthOxides.get(OrePrefixes.dust, 1), + null, + null, + new int[] { 10000 }, + 200, + 30); + + GT_Values.RA.addBlastRecipe( + GT_Utility.getIntegratedCircuit(1), + WerkstoffMaterialPool.LeachedBastnasiteRareEarthOxides.get(OrePrefixes.dust, 1), + Materials.Oxygen.getGas(1000), + Materials.Fluorine.getGas(13), + WerkstoffMaterialPool.RoastedRareEarthOxides.get(OrePrefixes.dust, 1), + null, + 600, + 120, + 1200); + + GT_Values.RA.addMixerRecipe( + GT_Utility.getIntegratedCircuit(7), + WerkstoffMaterialPool.RoastedRareEarthOxides.get(OrePrefixes.dust, 1), + null, + null, + Materials.Water.getFluid(200), + null, + WerkstoffMaterialPool.WetRareEarthOxides.get(OrePrefixes.dust, 1), + 100, + 30); + + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.WetRareEarthOxides.get(OrePrefixes.dust, 1), + null, + Materials.Fluorine.getGas(4000), + Materials.HydrofluoricAcid.getFluid(4000), + WerkstoffMaterialPool.CeriumOxidisedRareEarthOxides.get(OrePrefixes.dust, 1), + 300, + 480); + + GT_Values.RA.addCentrifugeRecipe( + WerkstoffMaterialPool.CeriumOxidisedRareEarthOxides.get(OrePrefixes.dust, 1), + null, + null, + null, + WerkstoffMaterialPool.BastnasiteRarerEarthOxides.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.CeriumDioxide.get(OrePrefixes.dust, 1), + null, + null, + null, + null, + new int[] { 10000, 9000 }, + 600, + 480); + + GT_Values.RA.addMixerRecipe( + WerkstoffMaterialPool.BastnasiteRarerEarthOxides.get(OrePrefixes.dust, 1), + null, + null, + null, + Materials.NitricAcid.getFluid(400), + WerkstoffMaterialPool.NitratedBastnasiteRarerEarthOxides.getFluidOrGas(1000), + null, + 300, + 480); + + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.NitratedBastnasiteRarerEarthOxides.get(OrePrefixes.cell, 1), + null, + Materials.Acetone.getFluid(1000), + WerkstoffMaterialPool.SaturatedBastnasiteRarerEarthOxides.getFluidOrGas(1000), + Materials.Empty.getCells(1), + 700, + 480); + + GT_Values.RA.addCentrifugeRecipe( + null, + null, + WerkstoffMaterialPool.SaturatedBastnasiteRarerEarthOxides.getFluidOrGas(1000), + WerkstoffMaterialPool.DilutedAcetone.getFluidOrGas(750), + WerkstoffMaterialPool.NeodymicRareEarthConcentrate.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.SamaricRareEarthConcentrate.get(OrePrefixes.dust, 1), + null, + null, + null, + null, + new int[] { 8000, 5000 }, + 900, + 480); + + // Nd RE + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.NeodymicRareEarthConcentrate.get(OrePrefixes.dust, 2), + null, + Materials.HydrochloricAcid.getFluid(2000), + null, + WerkstoffMaterialPool.LanthaniumChloride.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.NeodymiumOxide.get(OrePrefixes.dust, 1), + 900, + 800); + + // Sm RE + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.SamaricRareEarthConcentrate.get(OrePrefixes.dust, 1), + null, + Materials.HydrofluoricAcid.getFluid(2000), + null, + WerkstoffMaterialPool.FluorinatedSamaricConcentrate.get(OrePrefixes.dust, 1), + null, + 300, + 480); + + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.SamaricRareEarthConcentrate.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 1), + Materials.HydrofluoricAcid.getFluid(2000), + null, + WerkstoffMaterialPool.FluorinatedSamaricConcentrate.get(OrePrefixes.dust, 2), + null, + 350, + 480); + + GT_Values.RA.addBlastRecipe( + WerkstoffMaterialPool.FluorinatedSamaricConcentrate.get(OrePrefixes.dust, 8), + Materials.Calcium.getDust(4), + null, + WerkstoffMaterialPool.CalciumFluoride.getFluidOrGas(12000), + Materials.Holmium.getDust(1), + WerkstoffMaterialPool.SamariumTerbiumMixture.get(OrePrefixes.dust, 4), + 1600, + 1920, + 1200); + + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.SamariumTerbiumMixture.get(OrePrefixes.dust, 1), + BotWerkstoffMaterialPool.AmmoniumNitrate.get(OrePrefixes.dust, 9), + null, + null, + WerkstoffMaterialPool.NitratedSamariumTerbiumMixture.get(OrePrefixes.dust, 1), + null, + 600, + 480); + + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.NitratedSamariumTerbiumMixture.get(OrePrefixes.dust, 4), + Materials.Copper.getDust(1), + null, + null, + WerkstoffMaterialPool.TerbiumNitrate.get(OrePrefixes.dust, 2), + WerkstoffMaterialPool.SamaricResidue.get(OrePrefixes.dust, 2), // Potentially make only Samarium + 3200, + 1920); + + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 2), + Materials.Calcium.getDust(3), + null, + null, + WerkstoffMaterialPool.DephosphatedSamariumConcentrate.get(OrePrefixes.dust, 1), + Materials.TricalciumPhosphate.getDust(5), + 300, + 1920); + + GT_Values.RA.addCentrifugeRecipe( + WerkstoffMaterialPool.DephosphatedSamariumConcentrate.get(OrePrefixes.dust, 6), + null, + null, + null, + Materials.Samarium.getDust(1), + WerkstoffLoader.Thorianit.get(OrePrefixes.dust, 2), + WerkstoffMaterialPool.Gangue.get(OrePrefixes.dust, 4), + null, + null, + null, + new int[] { 9000, 8000, 10000 }, + 200, + 1920); + + // TODO UV Tier Ion Extracting Method + + // Lanthanum Part + // Digester to produce Lanthanum Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Lanthanum, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(LanthanumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(LanthanumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(LanthanumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs( + LanthanumExtractingNanoResin.getFluidOrGas(1000), + LanthanumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledLanthanumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Praseodymium Part + // Digester to produce Praseodymium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Praseodymium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(PraseodymiumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(PraseodymiumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(PraseodymiumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs( + PraseodymiumExtractingNanoResin.getFluidOrGas(1000), + PraseodymiumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledPraseodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Cerium Part + // Digester to produce Cerium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Cerium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(CeriumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(CeriumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(CeriumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs(CeriumExtractingNanoResin.getFluidOrGas(1000), CeriumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledCeriumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Neodymium Part + // Digester to produce Neodymium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Neodymium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(NeodymiumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(NeodymiumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(NeodymiumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs( + NeodymiumExtractingNanoResin.getFluidOrGas(1000), + NeodymiumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledNeodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Neodymium Part + // Digester to produce Neodymium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Neodymium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(NeodymiumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(NeodymiumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(NeodymiumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs( + NeodymiumExtractingNanoResin.getFluidOrGas(1000), + NeodymiumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledNeodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Promethium Part + // Digester to produce Neodymium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Promethium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(PromethiumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(PromethiumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(PromethiumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs( + PromethiumExtractingNanoResin.getFluidOrGas(1000), + PromethiumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledPromethiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Promethium Part + // Digester to produce Promethium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Promethium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(PromethiumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(PromethiumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(PromethiumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs( + PromethiumExtractingNanoResin.getFluidOrGas(1000), + PromethiumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledPromethiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Samarium Part + // Digester to produce Samarium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Samarium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(SamariumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(SamariumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(SamariumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs( + SamariumExtractingNanoResin.getFluidOrGas(1000), + SamariumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledSamariumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Europium Part + // Digester to produce Europium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Europium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(EuropiumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(EuropiumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(EuropiumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs( + EuropiumExtractingNanoResin.getFluidOrGas(1000), + EuropiumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledEuropiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Gadolinium Part + // Digester to produce Gadolinium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Gadolinium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(GadoliniumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GadoliniumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(GadoliniumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs( + GadoliniumExtractingNanoResin.getFluidOrGas(1000), + GadoliniumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledGadoliniumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Terbium Part + // Digester to produce Terbium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Terbium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(TerbiumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(TerbiumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(TerbiumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs(TerbiumExtractingNanoResin.getFluidOrGas(1000), TerbiumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledTerbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Dysprosium Part + // Digester to produce Dysprosium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Dysprosium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(DysprosiumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(DysprosiumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(DysprosiumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs( + DysprosiumExtractingNanoResin.getFluidOrGas(1000), + DysprosiumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledDysprosiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Holmium Part + // Digester to produce Holmium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Holmium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(HolmiumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(HolmiumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(HolmiumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs(HolmiumExtractingNanoResin.getFluidOrGas(1000), HolmiumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledHolmiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Erbium Part + // Digester to produce Erbium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Erbium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(ErbiumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ErbiumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(ErbiumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs(ErbiumExtractingNanoResin.getFluidOrGas(1000), ErbiumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledErbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Thulium Part + // Digester to produce Thulium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Thulium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(ThuliumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ThuliumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(ThuliumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs(ThuliumExtractingNanoResin.getFluidOrGas(1000), ThuliumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledThuliumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Ytterbium Part + // Digester to produce Ytterbium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Ytterbium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(YtterbiumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(YtterbiumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(YtterbiumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs( + YtterbiumExtractingNanoResin.getFluidOrGas(1000), + YtterbiumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledYtterbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Lutetium Part + // Digester to produce Lutetium Chloride Concentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Lutetium, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(3)) + .fluidInputs(Materials.Chlorine.getGas(36000)) + .fluidOutputs(LutetiumChlorideConcentrate.getFluidOrGas(3000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(LutetiumOreConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(Materials.SiliconDioxide.getDust(1)) + .fluidInputs(Materials.Chlorine.getGas(12000)) + .fluidOutputs(LutetiumChlorideConcentrate.getFluidOrGas(1000)) + .specialValue(800) + .eut(TierEU.RECIPE_ZPM) + .duration(2 * SECONDS) + .addTo(digesterRecipes); + // 1B oreChlorideConcentrate = 1 ore's rare earth metal + 3 any rare earth metal + GT_Values.RA.stdBuilder() + .fluidInputs( + LutetiumExtractingNanoResin.getFluidOrGas(1000), + LutetiumChlorideConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledLutetiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Ion Extracting Process to produce Rare Earth Element (example Samarium) by Nano Resin + // Get Extracting Nano Resin + + // Lanthanum + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Lanthanum.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(LanthanumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Praseodymium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Praseodymium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(PraseodymiumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Cerium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Cerium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(CeriumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Neodymium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Neodymium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(NeodymiumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Promethium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Promethium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(PromethiumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Sm + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Samarium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(SamariumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Europium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Europium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(EuropiumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Gadolinium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Gadolinium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(GadoliniumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Terbium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Terbium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(TerbiumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Dysprosium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Dysprosium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(DysprosiumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Holmium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Holmium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(HolmiumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Erbium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Erbium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(ErbiumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Thulium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Thulium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(ThuliumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Ytterbium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Ytterbium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(YtterbiumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // Lutetium + GT_Values.RA.stdBuilder() + .itemInputs( + GT_ModHandler.getModItem("dreamcraft", "item.MysteriousCrystalLens", 0), + Materials.Lutetium.getDust(1), + Materials.Carbon.getNanite(1)) + .fluidInputs(MyMaterial.P507.getFluidOrGas(4000)) + .fluidOutputs(LutetiumExtractingNanoResin.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(10 * SECONDS) + .addTo(laserEngraverRecipes); + + // TODO Electrolyzer recycle Nano Resin and produce molten rare earth metal, + + // La + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledLanthanumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + LanthanumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Lanthanum, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Pr + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledPraseodymiumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + PraseodymiumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Praseodymium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Ce + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledCeriumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + CeriumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Cerium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Nd + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledNeodymiumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + NeodymiumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Neodymium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Po + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledPromethiumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + PromethiumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Promethium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Sm + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledSamariumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + SamariumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Samarium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Eu + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledEuropiumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + EuropiumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Europium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Ga + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledGadoliniumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + GadoliniumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Gadolinium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Tb + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledTerbiumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + TerbiumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Terbium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Dy + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledDysprosiumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + DysprosiumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Dysprosium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Ho + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledHolmiumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + HolmiumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Holmium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Er + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledErbiumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + ErbiumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Erbium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Tm + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledThuliumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + ThuliumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Thulium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Yb + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledYtterbiumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + YtterbiumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Ytterbium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // Lu + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(2)) + .fluidInputs(FilledLutetiumExtractingNanoResin.getFluidOrGas(1000)) + .itemOutputs( + LutetiumExtractingNanoResin.get(OrePrefixes.cell, 1), + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Lutetium, 1)) + .fluidOutputs(Materials.Chlorine.getGas(3000)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(electrolyzerRecipes); + + // TODO ChlorinitedRareEarthConcentrate process with every 15 Rare Earth Extracting Nano Resin + + // La + GT_Values.RA.stdBuilder() + .fluidInputs( + LanthanumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledLanthanumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + LanthanumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledLanthanumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + LanthanumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledLanthanumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Pr + GT_Values.RA.stdBuilder() + .fluidInputs( + PraseodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledPraseodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + PraseodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledPraseodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + PraseodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledPraseodymiumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Ce + GT_Values.RA.stdBuilder() + .fluidInputs( + CeriumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledCeriumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + CeriumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledCeriumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + CeriumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledCeriumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Nd + GT_Values.RA.stdBuilder() + .fluidInputs( + NeodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledNeodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + NeodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledNeodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + NeodymiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledNeodymiumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Pm + GT_Values.RA.stdBuilder() + .fluidInputs( + PromethiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledPromethiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + PromethiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledPromethiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + PromethiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledPromethiumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Sm + GT_Values.RA.stdBuilder() + .fluidInputs( + SamariumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledSamariumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + SamariumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledSamariumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + SamariumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledSamariumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Eu + GT_Values.RA.stdBuilder() + .fluidInputs( + EuropiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledEuropiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + EuropiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledEuropiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + EuropiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledEuropiumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Ga + GT_Values.RA.stdBuilder() + .fluidInputs( + GadoliniumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledGadoliniumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + GadoliniumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledGadoliniumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + GadoliniumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledGadoliniumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Tb + GT_Values.RA.stdBuilder() + .fluidInputs( + TerbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledTerbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + TerbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledTerbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + TerbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledTerbiumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Dy + GT_Values.RA.stdBuilder() + .fluidInputs( + DysprosiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledDysprosiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + DysprosiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledDysprosiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + DysprosiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledDysprosiumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Ho + GT_Values.RA.stdBuilder() + .fluidInputs( + HolmiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledHolmiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + HolmiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledHolmiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + HolmiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledHolmiumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Er + GT_Values.RA.stdBuilder() + .fluidInputs( + ErbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledErbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + ErbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledErbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + ErbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledErbiumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Tm + GT_Values.RA.stdBuilder() + .fluidInputs( + ThuliumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledThuliumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + ThuliumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledThuliumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + ThuliumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledThuliumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Yb + GT_Values.RA.stdBuilder() + .fluidInputs( + YtterbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledYtterbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + YtterbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledYtterbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + YtterbiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledYtterbiumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // Lu + GT_Values.RA.stdBuilder() + .fluidInputs( + LutetiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthConcentrate.getFluidOrGas(1000)) + .fluidOutputs( + FilledLutetiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + LutetiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthEnrichedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledLutetiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .fluidInputs( + LutetiumExtractingNanoResin.getFluidOrGas(1000), + ChlorinatedRareEarthDilutedSolution.getFluidOrGas(1000)) + .fluidOutputs( + FilledLutetiumExtractingNanoResin.getFluidOrGas(1000), + MyMaterial.wasteLiquid.getFluidOrGas(1000)) + .eut(TierEU.RECIPE_UV) + .duration(1 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // TODO Samarium Ore Concentrate Dust Processing Line Start + + // 16 SmOreDust + 200L NitricAcid =EV@10s= 800L MuddySamariumRareEarthSolution + 1 ?ThP?ConcentrateDust + GT_Values.RA.stdBuilder() + .itemInputs(SamariumOreConcentrate.get(OrePrefixes.dust, 16)) + .fluidInputs(Materials.NitricAcid.getFluid(200)) + .itemOutputs(ThoriumPhosphateConcentrate.get(OrePrefixes.dust, 1)) + .fluidOutputs(MuddySamariumRareEarthSolution.getFluidOrGas(800)) + .specialValue(800) + .eut(TierEU.RECIPE_EV) + .duration(10 * SECONDS) + .addTo(digesterRecipes); + + // 1 CrushedSamariumOre = 3 SamariumOreConcentrate in process + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Samarium, 8)) + .fluidInputs(Materials.NitricAcid.getFluid(300)) + .itemOutputs(ThoriumPhosphateConcentrate.get(OrePrefixes.dust, 3)) + .fluidOutputs(MuddySamariumRareEarthSolution.getFluidOrGas(1200)) + .specialValue(800) + .eut(TierEU.RECIPE_EV) + .duration(10 * SECONDS) + .addTo(digesterRecipes); + + // 1B MuddySmSolution + 1B NitricAcid =EV@10s= 2B SamariumRareEarthMud + 0.8 CeriumDioxide + 0.6 + // CeriumRichMixture(CeriumOreConcentrate) + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.NitricAcid.getFluid(1000), MuddySamariumRareEarthSolution.getFluidOrGas(1000)) + .itemOutputs(CeriumDioxide.get(OrePrefixes.dust, 1), CeriumOreConcentrate.get(OrePrefixes.dust, 1)) + .fluidOutputs(SamariumRareEarthMud.getFluidOrGas(2000)) + .specialValue(1) + .outputChances(8000, 6000) + .noOptimize() + .eut(TierEU.RECIPE_EV) + .duration(10 * SECONDS) + .addTo(dissolutionTankRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(9)) + .fluidInputs(Materials.NitricAcid.getFluid(9000), MuddySamariumRareEarthSolution.getFluidOrGas(9000)) + .itemOutputs(CeriumDioxide.get(OrePrefixes.dust, 9), CeriumOreConcentrate.get(OrePrefixes.dust, 9)) + .fluidOutputs(SamariumRareEarthMud.getFluidOrGas(18000)) + .specialValue(1) + .outputChances(8000, 6000) + .noOptimize() + .eut(TierEU.RECIPE_IV) + .duration(300) + .addTo(dissolutionTankRecipes); + // Low Efficiency method in LCR + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.NitricAcid.getFluid(1000), MuddySamariumRareEarthSolution.getFluidOrGas(1000)) + .itemOutputs(CeriumDioxide.get(OrePrefixes.dust, 1)) + .fluidOutputs(SamariumRareEarthMud.getFluidOrGas(1000)) + .outputChances(5000) + .eut(TierEU.RECIPE_EV) + .duration(300) + .addTo(multiblockChemicalReactorRecipes); + + // 1B SamariumRareEarthMud + 9B water =EV@30s= 10B DilutedSamariumRareEarthSolution + // + (90% + 60%) NeodymiumREConcentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(Materials.Water.getFluid(9000), SamariumRareEarthMud.getFluidOrGas(1000)) + .itemOutputs( + NeodymicRareEarthConcentrate.get(OrePrefixes.dust, 1), + NeodymicRareEarthConcentrate.get(OrePrefixes.dust, 1)) + .fluidOutputs(DilutedSamariumRareEarthSolution.getFluidOrGas(10000)) + .specialValue(9) + .outputChances(9000, 6000) + .noOptimize() + .eut(TierEU.RECIPE_EV) + .duration(600) + .addTo(dissolutionTankRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(9)) + .fluidInputs(Materials.Water.getFluid(81000), SamariumRareEarthMud.getFluidOrGas(9000)) + .itemOutputs( + NeodymicRareEarthConcentrate.get(OrePrefixes.dust, 9), + NeodymicRareEarthConcentrate.get(OrePrefixes.dust, 9)) + .fluidOutputs(DilutedSamariumRareEarthSolution.getFluidOrGas(90000)) + .specialValue(9) + .outputChances(9000, 6000) + .noOptimize() + .eut(TierEU.RECIPE_IV) + .duration(900) + .addTo(dissolutionTankRecipes); + // Low Efficiency method in LCR + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(1)) + .fluidInputs(SamariumRareEarthMud.getFluidOrGas(1000), Materials.Water.getFluid(16000)) + .fluidOutputs(DilutedSamariumRareEarthSolution.getFluidOrGas(8000)) + .eut(TierEU.RECIPE_EV) + .duration(1200) + .addTo(multiblockChemicalReactorRecipes); + + // 2B DilutedSamariumRareEarthSolution + 3B Oxalate + // =EV@10s= + // 5 ImpureSamariumOxalate + 50L MuddySamariumRareEarthSolution + 0.1*2 LepersonniteDust + // LepersonniteDust -> DephosphatedSamariumConcentrate + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.getIntegratedCircuit(13)) + .fluidInputs(DilutedSamariumRareEarthSolution.getFluidOrGas(2000), MyMaterial.oxalate.getFluidOrGas(3000)) + .itemOutputs( + SamariumOxalate.get(OrePrefixes.dust, 5), + DephosphatedSamariumConcentrate.get(OrePrefixes.dust, 3)) + .fluidOutputs(MuddySamariumRareEarthSolution.getFluidOrGas(50)) + .outputChances(10000, 1000) + .eut(TierEU.RECIPE_EV) + .duration(10 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + // 5 ImpureSamariumOxalate + 6B HCL = 8 ImpureSamariumChloride + 6B CO + GT_Values.RA.stdBuilder() + .itemInputs(SamariumOxalate.get(OrePrefixes.dust, 5)) + .fluidInputs(Materials.HydrochloricAcid.getFluid(6000)) + .itemOutputs(SamariumChloride.get(OrePrefixes.dust, 8)) + .fluidOutputs(Materials.CarbonMonoxide.getGas(6000)) + .eut(960) + .duration(10 * SECONDS) + .addTo(multiblockChemicalReactorRecipes); + + /** + * ImpureSamariumChloride has 2 method to process 1. In IV-LuV, fix with NcCL then use electrolyzer to process + * the mixture, get Samarium dust & Chlorine & Sodium. 2. In ZPM, put molten ImpureSamariumChloride and + * LanthanumDust in Distillation Tower to get molten Samarium and impure Lanthanum Chloride. + */ + + // 2 ImpureSamariumChloride + 1 NaCl =LV@5s= 3 SamariumChlorideSodiumChlorideBlend + GT_Values.RA.stdBuilder() + .itemInputs(SamariumChloride.get(OrePrefixes.dust, 2), Materials.Salt.getDust(1)) + .itemOutputs(SamariumChlorideSodiumChlorideBlend.get(OrePrefixes.dust, 3)) + .eut(30) + .duration(5 * SECONDS) + .addTo(mixerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(SamariumChloride.get(OrePrefixes.dust, 2), Materials.Sodium.getDust(1)) + .itemOutputs(SamariumChlorideSodiumChlorideBlend.get(OrePrefixes.dust, 3)) + .eut(30) + .duration(5 * SECONDS) + .addTo(mixerNonCellRecipes); + + // 6 SamariumChlorideSodiumChlorideBlend =IV@1s= 1 SamariumDust + 1 SodiumDust + 2/9 RarestEarthResidue + 4B + // Chlorine + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(1), + SamariumChlorideSodiumChlorideBlend.get(OrePrefixes.dust, 6)) + .itemOutputs( + Materials.Samarium.getDust(1), + Materials.Sodium.getDust(1), + RarestEarthResidue.get(OrePrefixes.dustTiny, 2)) + .fluidOutputs(Materials.Chlorine.getGas(4000)) + .eut(TierEU.RECIPE_IV) + .duration(1 * SECONDS) + .addTo(electrolyzerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(9), + SamariumChlorideSodiumChlorideBlend.get(OrePrefixes.dust, 54)) + .itemOutputs( + Materials.Samarium.getDust(9), + Materials.Sodium.getDust(9), + RarestEarthResidue.get(OrePrefixes.dust, 2)) + .fluidOutputs(Materials.Chlorine.getGas(36000)) + .eut(30720) + .duration(2 * SECONDS) + .addTo(electrolyzerRecipes); + + // ZPM molten distilling method + + // melt ImpureSamariumChloride + GT_Values.RA.stdBuilder() + .itemInputs(SamariumChloride.get(OrePrefixes.dust, 1)) + .fluidOutputs(SamariumChloride.getMolten(144)) + .eut(TierEU.RECIPE_EV) + .duration(24) + .addTo(fluidExtractionRecipes); + + // distill with LanthanumDust 36*144L moltenSmCl3 = 16*144L moltenSm + 27B Cl + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Lanthanum.getDust(9)) + .itemOutputs(ImpureLanthanumChloride.get(OrePrefixes.dust, 36)) + .fluidInputs(SamariumChloride.getMolten(5184)) + .fluidOutputs(Materials.Samarium.getMolten(2304)) + .eut(TierEU.RECIPE_ZPM) + .duration(5 * SECONDS) + .noOptimize() + .addTo(distillationTowerRecipes); + + // Centrifuge ImpureLanthanumChlorideDust + GT_Values.RA.stdBuilder() + .itemInputs(ImpureLanthanumChloride.get(OrePrefixes.dust, 36)) + .itemOutputs(LanthaniumChloride.get(OrePrefixes.dust, 36), RarestEarthResidue.get(OrePrefixes.dust, 5)) + .eut(TierEU.RECIPE_EV) + .duration(5 * SECONDS) + .addTo(centrifugeRecipes); + + /** + * DephosphatedSamariumConcentrate has a simple and not shit process. Just burn in furnace, then use + * electolyzer. + */ + GameRegistry.addSmelting( + DephosphatedSamariumConcentrate.get(OrePrefixes.dust, 1), + SamariumOxide.get(OrePrefixes.dustTiny, 2), + 114); + GT_Values.RA.stdBuilder() + .itemInputs(DephosphatedSamariumConcentrate.get(OrePrefixes.dust, 1)) + .itemOutputs(SamariumOxide.get(OrePrefixes.dust, 1), Gangue.get(OrePrefixes.dust, 1)) + .specialValue(1200) + .eut(514) + .duration(2 * SECONDS) + .addTo(blastFurnaceRecipes); + // GT_Values.RA.addBlastRecipe( + // DephosphatedSamariumConcentrate.get(OrePrefixes.dust, 1), + // null, + // null, + // null, + // SamariumOxide.get(OrePrefixes.dust, 1), + // Gangue.get(OrePrefixes.dust, 1), + // 40, + // 514, + // 1200); + + } + + public static void addRandomChemCrafting() { + + // PTMEG Elastomer + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.Butanediol.get(OrePrefixes.cell, 1), + null, + WerkstoffMaterialPool.TolueneTetramethylDiisocyanate.getFluidOrGas(4000), + WerkstoffMaterialPool.PTMEGElastomer.getMolten(4000), + Materials.Empty.getCells(1), + 1500, + 480); + + // Toluene Tetramethyl Diisocyanate + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.TolueneDiisocyanate.get(OrePrefixes.cell, 3), + Materials.Hydrogen.getCells(2), + WerkstoffMaterialPool.Polytetrahydrofuran.getFluidOrGas(1000), + WerkstoffMaterialPool.TolueneTetramethylDiisocyanate.getFluidOrGas(2000), + Materials.Empty.getCells(5), + 1200, + 480); + + // PTHF + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.TungstophosphoricAcid.get(OrePrefixes.cell, 1), + Materials.Oxygen.getCells(1), + WerkstoffMaterialPool.Tetrahydrofuran.getFluidOrGas(144), + WerkstoffMaterialPool.Polytetrahydrofuran.getFluidOrGas(432), + Materials.Empty.getCells(2), + 1000, + 120); + + // THF + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.AcidicButanediol.get(OrePrefixes.cell, 1), + null, + Materials.Ethanol.getFluid(1000), + WerkstoffMaterialPool.Tetrahydrofuran.getFluidOrGas(1000), + Materials.Empty.getCells(1), + 800, + 480); + + // Acidicised Butanediol + GT_Values.RA.addMixerRecipe( + Materials.SulfuricAcid.getCells(1), + null, + null, + null, + WerkstoffMaterialPool.Butanediol.getFluidOrGas(1000), + WerkstoffMaterialPool.AcidicButanediol.getFluidOrGas(1000), + Materials.Water.getCells(1), + 600, + 2000); + + // Butanediol + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.MoTeOCatalyst.get(OrePrefixes.dustTiny, 1), + null, + Materials.Butane.getGas(1000), + WerkstoffMaterialPool.Butanediol.getFluidOrGas(1000), + null, + 900, + 1920); + + GT_Values.RA.addMultiblockChemicalRecipe( + new ItemStack[] { GT_Utility.getIntegratedCircuit(9), + WerkstoffMaterialPool.MoTeOCatalyst.get(OrePrefixes.dust, 1) }, + new FluidStack[] { Materials.Butane.getGas(9000) }, + new FluidStack[] { WerkstoffMaterialPool.Butanediol.getFluidOrGas(9000) }, + null, + 8100, + 1920); + + // Moly-Te-Oxide Catalyst + GT_Values.RA.addMixerRecipe( + WerkstoffMaterialPool.MolybdenumIVOxide.get(OrePrefixes.dust, 1), + WerkstoffMaterialPool.TelluriumIVOxide.get(OrePrefixes.dust, 1), + null, + null, + null, + null, + WerkstoffMaterialPool.MoTeOCatalyst.get(OrePrefixes.dust, 2), + 300, + 120); + + // Tungstophosphoric Acid + GT_Values.RA.addChemicalRecipe( + Materials.PhosphoricAcid.getCells(1), + Materials.HydrochloricAcid.getCells(24), + BotWerkstoffMaterialPool.SodiumTungstate.getFluidOrGas(12000), + WerkstoffMaterialPool.TungstophosphoricAcid.getFluidOrGas(1000), + Materials.Salt.getDust(24), + Materials.Empty.getCells(25), + 500, + 1024); + + // Toluene Diisocyanate + GT_Values.RA.addChemicalRecipe( + WerkstoffMaterialPool.Diaminotoluene.get(OrePrefixes.cell, 1), + Materials.Empty.getCells(3), + BotWerkstoffMaterialPool.Phosgene.getFluidOrGas(2000), + WerkstoffMaterialPool.TolueneDiisocyanate.getFluidOrGas(1000), + Materials.HydrochloricAcid.getCells(4), + 900, + 480); + + // Diaminotoluene + GT_Values.RA.addChemicalRecipe( + Materials.Hydrogen.getCells(4), + null, + WerkstoffMaterialPool.Dinitrotoluene.getFluidOrGas(1000), + WerkstoffMaterialPool.Diaminotoluene.getFluidOrGas(1000), + Materials.Empty.getCells(4), + 300, + 480); + + // Dinitrotoluene + GT_Values.RA.addChemicalRecipe( + Materials.NitricAcid.getCells(2), + null, + Materials.Toluene.getFluid(1000), + WerkstoffMaterialPool.Dinitrotoluene.getFluidOrGas(1000), + Materials.Empty.getCells(2), + 900, + 480); + // Digester Control Block + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { ItemList.Hull_IV.get(1L), ItemList.Super_Tank_EV.get(2L), + ItemList.Electric_Motor_IV.get(4L), ItemList.Electric_Pump_IV.get(4L), + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Desh, 4L), + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Master, 4L), + GT_Utility.getIntegratedCircuit(1) }, + Materials.Polytetrafluoroethylene.getMolten(1440), + LanthItemList.DIGESTER, + 600, + 4096); + + // Dissolution Tank + GT_Values.RA.addAssemblerRecipe( + new ItemStack[] { ItemList.Hull_EV.get(1L), ItemList.Super_Tank_HV.get(2L), + ItemList.Electric_Motor_EV.get(4L), ItemList.Electric_Pump_EV.get(2L), + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.VibrantAlloy, 4L), + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Data, 4L), GT_Utility.getIntegratedCircuit(2) }, + Materials.Polytetrafluoroethylene.getMolten(720), + LanthItemList.DISSOLUTION_TANK, + 400, + 960); + + GT_Values.RA.addFluidHeaterRecipe( + null, + WerkstoffMaterialPool.DilutedAcetone.getFluidOrGas(250), + Materials.Acetone.getFluid(150), + 120, + 120); + + // PTMEG Manipulation + + GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Ingot.get(0L), + WerkstoffMaterialPool.PTMEGElastomer.getMolten(144), + WerkstoffMaterialPool.PTMEGElastomer.get(OrePrefixes.ingot, 1), + 40, + 64); + + GT_Values.RA.addFluidSolidifierRecipe( + ItemList.Shape_Mold_Plate.get(0L), + WerkstoffMaterialPool.PTMEGElastomer.getMolten(144), + WerkstoffMaterialPool.PTMEGElastomer.get(OrePrefixes.plate, 1), + 40, + 64); + + // TODO Cerium-doped Lutetium Aluminium Garnet (Ce:LuAG) + /** + * 1/9 Ce + 3 Lu + 5 Sapphire = 8 LuAG Blend 1/9 Ce + 3 Lu + 10 Green Sapphire = 8 LuAG Blend 2/9 Ce + 6 Lu + 25 + * Alumina + 9 Oxygen = 12 LuAG Blend + * + * 1 Ce + 60 Lu + 100 Sapphire = 160 LuAG Blend 1 Ce + 60 Lu +200 Green Sapphire = 160 LuAG Blend + * + */ + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(4), + Materials.Cerium.getDustTiny(1), + Materials.Lutetium.getDust(3), + Materials.Sapphire.getDust(5)) + .itemOutputs(CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 8)) + .eut(TierEU.RECIPE_UV) + .duration(5 * SECONDS) + .addTo(mixerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(4), + Materials.Cerium.getDustTiny(1), + Materials.Lutetium.getDust(3), + Materials.GreenSapphire.getDust(10)) + .itemOutputs(CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 8)) + .eut(TierEU.RECIPE_UV) + .duration(5 * SECONDS) + .addTo(mixerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(4), + Materials.Cerium.getDustTiny(2), + Materials.Lutetium.getDust(6), + Materials.Aluminiumoxide.getDust(25)) + .itemOutputs(CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 12)) + .fluidInputs(Materials.Oxygen.getGas(9000)) + .eut(TierEU.RECIPE_UV) + .duration(400) + .addTo(mixerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(5), + Materials.Cerium.getDust(1), + Materials.Lutetium.getDust(60), + Materials.Sapphire.getDust(64), + Materials.Sapphire.getDust(36)) + .itemOutputs( + CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 64), + CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 64), + CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 32)) + .eut(TierEU.RECIPE_UV) + .duration(1800) + .addTo(mixerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(5), + Materials.Cerium.getDust(1), + Materials.Lutetium.getDust(60), + Materials.GreenSapphire.getDust(64), + Materials.GreenSapphire.getDust(64), + Materials.GreenSapphire.getDust(64), + Materials.GreenSapphire.getDust(8)) + .itemOutputs( + CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 64), + CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 64), + CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 32)) + .eut(TierEU.RECIPE_UV) + .duration(1800) + .addTo(mixerRecipes); + + // Get LuAG Crystal seed + GT_Values.RA.stdBuilder() + .itemInputs(CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 1)) + .itemOutputs(CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gem, 1)) + .fluidInputs(Materials.Lutetium.getMolten(144 * 8)) + .outputChances(514) + .eut(500000) + .duration(500) + .addTo(autoclaveRecipes); + + // 1 LuAG Blend = 1.1(Og) 1.0(Xe) 0.99(Kr) LuAG in Autoclave + GT_Values.RA.stdBuilder() + .itemInputs( + CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 1), + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gem, 1)) + .itemOutputs( + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gemExquisite, 1), + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gemExquisite, 1)) + .fluidInputs(WerkstoffLoader.Krypton.getFluidOrGas(40)) + .outputChances(8000, 1900) + .eut(TierEU.RECIPE_UHV) + .duration(512) + .addTo(autoclaveRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 1), + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gem, 1)) + .itemOutputs( + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gemExquisite, 1), + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gemExquisite, 1)) + .fluidInputs(WerkstoffLoader.Xenon.getFluidOrGas(25)) + .outputChances(9000, 1000) + .eut(TierEU.RECIPE_UHV) + .duration(256) + .addTo(autoclaveRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(1), + CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 1)) + .itemOutputs( + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gemExquisite, 1), + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gemExquisite, 1)) + .fluidInputs(WerkstoffLoader.Oganesson.getFluidOrGas(10)) + .outputChances(10000, 100) + .eut(TierEU.RECIPE_UHV) + .duration(128) + .addTo(autoclaveRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 1), + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gem, 1)) + .itemOutputs( + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gemExquisite, 1), + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gemExquisite, 2)) + .fluidInputs(WerkstoffLoader.Oganesson.getFluidOrGas(10)) + .outputChances(10000, 2000) + .eut(TierEU.RECIPE_UHV) + .duration(128) + .addTo(autoclaveRecipes); + + // 1 LuAG Blend = 1 LuAG in Vacuum Furnace + GT_Values.RA.stdBuilder() + .itemInputs(CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.dust, 1)) + .itemOutputs(CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gemExquisite, 1)) + .fluidInputs(CeriumDopedLutetiumAluminiumOxygenBlend.getMolten(108)) + .specialValue(9100) + .eut(TierEU.RECIPE_UHV) + .duration(5 * SECONDS) + .addTo(vacuumFurnaceRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(CeriumDopedLutetiumAluminiumOxygenBlend.get(OrePrefixes.dust, 1)) + .fluidOutputs(CeriumDopedLutetiumAluminiumOxygenBlend.getMolten(144)) + .eut(30000) + .duration(1 * SECONDS) + .addTo(fluidExtractionRecipes); + + // 16 Adv Crystal SoC + for (ItemStack itemStack : OreDictionary.getOres("craftingLensBlue")) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(0, itemStack), + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gemExquisite, 1)) + .itemOutputs(ItemList.Circuit_Chip_CrystalSoC2.get(16)) + .requiresCleanRoom() + .eut(160000) + .duration(40 * SECONDS) + .addTo(laserEngraverRecipes); + } + + // 16 Crystal SoC + for (ItemStack itemStack : OreDictionary.getOres("craftingLensGreen")) { + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.copyAmount(0, itemStack), + CeriumDopedLutetiumAluminiumGarnet.get(OrePrefixes.gemExquisite, 1)) + .itemOutputs(ItemList.Circuit_Chip_CrystalSoC.get(16)) + .requiresCleanRoom() + .eut(160000) + .duration(40 * SECONDS) + .addTo(laserEngraverRecipes); + } + + } + + // public static void loadZylon + + public static void removeCeriumSources() { + + GT_Log.out.print(Tags.MODID + ": AAAAAA"); + + HashSet<GT_Recipe> remove = new HashSet<>(5000); + HashSet<GT_Recipe> reAdd = new HashSet<>(5000); + + // For Crusher + for (GT_Recipe recipe : maceratorRecipes.getAllRecipes()) { + ItemStack input = recipe.mInputs[0]; + // GT_Log.out.print("\n" + input.getDisplayName()); + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if ((OreDictionary.getOreName(oreDictID) + .startsWith("ore") + || OreDictionary.getOreName(oreDictID) + .startsWith("rawOre") + || OreDictionary.getOreName(oreDictID) + .startsWith("crushed"))) { + GT_Log.out.print(OreDictionary.getOreName(oreDictID)); + GT_Recipe tRecipe = recipe.copy(); + boolean modified = false; + 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)); + modified = true; + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize * 2, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 1)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + maceratorRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(maceratorRecipes::add); + maceratorRecipes.getBackend() + .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 : oreWasherRecipes.getAllRecipes()) { + 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(); + boolean modified = false; + 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)); + modified = true; + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize * 2, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 1)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + oreWasherRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(oreWasherRecipes::add); + oreWasherRecipes.getBackend() + .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 : thermalCentrifugeRecipes.getAllRecipes()) { + 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) + .startsWith("purified")) /* && OreDictionary.getOreName(oreDictID).contains("Cerium") */) { + GT_Recipe tRecipe = recipe.copy(); + boolean modified = false; + 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)); + modified = true; + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize * 2, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 1)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + thermalCentrifugeRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(thermalCentrifugeRecipes::add); + thermalCentrifugeRecipes.getBackend() + .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 : centrifugeRecipes.getAllRecipes()) { + ItemStack input = null; + FluidStack fluidInput = null; + if (recipe.mInputs.length > 0) input = recipe.mInputs[0]; + if (recipe.mFluidInputs.length > 0) fluidInput = recipe.mFluidInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID) + .startsWith("dust") + && (!OreDictionary.getOreName(oreDictID) + .contains( + "Dephosphated")) /* + * 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(); + boolean modified = false; + 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize * 2, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dustTiny, 1)); + modified = true; + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize * 2, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 1)); + modified = true; + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDustSmall(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize * 2, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dustSmall, 1)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + /* + * GT_Recipe tRecipe = recipe.copy(); if (GT_Utility.isStackValid(fluidInput)) { if + * (fluidInput.getLocalizedName() == MyMaterial.plutoniumBasedLiquidFuel.getDefaultName()) { + * tRecipe.mOutputs[1] = GT_Utility.copyAmount(tRecipe.mOutputs[1].stackSize * 2, + * WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1)); reAdd.add(tRecipe); + * remove.add(tRecipe); } } + */ + } + centrifugeRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(centrifugeRecipes::add); + centrifugeRecipes.getBackend() + .reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Centrifuge done!\n"); + + // For Centrifuge (PA) + for (GT_Recipe recipe : centrifugeNonCellRecipes.getAllRecipes()) { + ItemStack input = null; + FluidStack fluidInput = null; + if (recipe.mInputs.length > 0) input = recipe.mInputs[0]; + if (recipe.mFluidInputs.length > 0) fluidInput = recipe.mFluidInputs[0]; + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + if (OreDictionary.getOreName(oreDictID) + .startsWith("dust") + && (!OreDictionary.getOreName(oreDictID) + .contains("Dephosphated"))) { + GT_Recipe tRecipe = recipe.copy(); + boolean modified = false; + 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)); + modified = true; + } 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)); + modified = true; + } 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)); + modified = true; + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDustTiny(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize * 2, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dustTiny, 1)); + modified = true; + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize * 2, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 1)); + modified = true; + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDustSmall(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize * 2, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dustSmall, 1)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + centrifugeNonCellRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(centrifugeNonCellRecipes::add); + centrifugeNonCellRecipes.getBackend() + .reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Centrifuge (PA) done!\n"); + + // For Hammer + for (GT_Recipe recipe : hammerRecipes.getAllRecipes()) { + 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(); + boolean modified = false; + 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)); + modified = true; + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize * 2, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 1)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + hammerRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(hammerRecipes::add); + hammerRecipes.getBackend() + .reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Hammer done!\n"); + + // Electrolyzer + for (GT_Recipe recipe : electrolyzerRecipes.getAllRecipes()) { + for (ItemStack input : recipe.mInputs) { + if (GT_Utility.isStackValid(input)) { + GT_Log.out.print(input.getDisplayName() + "\n"); + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + String oreName = OreDictionary.getOreName(oreDictID); + if (oreName.equals("dustHibonite") || oreName.equals("dustLanthaniteCe") + || oreName.equals("dustZirconolite") + || oreName.equals("dustYttrocerite") + || oreName.equals("dustXenotime") + || oreName.equals("dustBastnasite") + || oreName.equals("dustFlorencite")) { + GT_Recipe tRecipe = recipe.copy(); + boolean modified = false; + 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)); + modified = true; + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 1)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + } + + electrolyzerRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(electrolyzerRecipes::add); + electrolyzerRecipes.getBackend() + .reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Electrolyzer done!\n"); + + // Electrolyzer (PA) + for (GT_Recipe recipe : electrolyzerNonCellRecipes.getAllRecipes()) { + for (ItemStack input : recipe.mInputs) { + if (GT_Utility.isStackValid(input)) { + GT_Log.out.print(input.getDisplayName() + "\n"); + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + String oreName = OreDictionary.getOreName(oreDictID); + if (oreName.equals("dustHibonite") || oreName.equals("dustLanthaniteCe") + || oreName.equals("dustZirconolite") + || oreName.equals("dustYttrocerite") + || oreName.equals("dustXenotime") + || oreName.equals("dustBastnasite") + || oreName.equals("dustFlorencite")) { + GT_Recipe tRecipe = recipe.copy(); + boolean modified = false; + 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)); + modified = true; + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 1)); + modified = true; + } + } + if (modified) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + } + + electrolyzerNonCellRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(electrolyzerNonCellRecipes::add); + electrolyzerNonCellRecipes.getBackend() + .reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Electrolyzer (PA) done!\n"); + + if (Loader.isModLoaded("miscutils")) { + // For Simple Washer + for (GT_Recipe recipe : simpleWasherRecipes.getAllRecipes()) { + 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") + || OreDictionary.getOreName(oreDictID) + .startsWith("dustImpureSamarium") + || OreDictionary.getOreName(oreDictID) + .startsWith("dustPureSamarium") + || OreDictionary.getOreName(oreDictID) + .startsWith("dustPureCerium")) { + 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)); + } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Samarium.getDust(1))) { + tRecipe.mOutputs[i] = GT_Utility.copyAmount( + tRecipe.mOutputs[i].stackSize, + WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 1)); + } + } + if (!tRecipe.equals(recipe)) { + reAdd.add(tRecipe); + remove.add(recipe); + } + break; + } + } + } + } + simpleWasherRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(simpleWasherRecipes::add); + simpleWasherRecipes.getBackend() + .reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Simple Washer done!\n"); + + // Dehydrator + for (GT_Recipe recipe : chemicalDehydratorRecipes.getAllRecipes()) { + if (recipe.mInputs.length == 0) { + continue; + } + ItemStack input = recipe.mInputs[0]; + + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + String oreName = OreDictionary.getOreName(oreDictID); + if (oreName.equals("dustCerite") || oreName.equals("dustFluorcaphite") + || oreName.equals("dustZirkelite") + || oreName.equals("dustGadoliniteCe") + || oreName.equals("dustGadoliniteY") + || oreName.equals("dustPolycrase") + || oreName.equals("dustBastnasite")) { + 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; + } + } + } + } + + chemicalDehydratorRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(chemicalDehydratorRecipes::add); + chemicalDehydratorRecipes.getBackend() + .reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Dehydrator done!\n"); + } + + /* + * DOES NOT WORK, something to do with load times for sifter recipes or some shit //Sifter for (GT_Recipe recipe + * : sifterRecipes.mRecipeList) { if (recipe.mInputs.length == 0) break; ItemStack input = recipe.mInputs[0]; + * GT_Log.out.print("Sift ore found " + input.getDisplayName() + "\n"); if (GT_Utility.isStackValid(input)) { if + * (true) { GT_Log.out.print("Sift ore found and iffed " + input.getDisplayName() + "\n"); //GT_Recipe tRecipe = + * recipe.copy(); remove.add(recipe); break; } } } sifterRecipes.mRecipeList.removeAll(remove); + * sifterRecipes.mRecipeList.addAll(reAdd); sifterRecipes.reInit(); GT_Log.out.print(Tags.MODID + ": Replace " + + * remove.size() + "! "); remove.clear(); reAdd.clear(); GT_Log.out.print("Sifter done!\n"); + */ + // Chemical Bath + for (GT_Recipe recipe : chemicalBathRecipes.getAllRecipes()) { + // ItemStack input = recipe.mInputs[0]; + for (ItemStack input : recipe.mInputs) { + GT_Log.out.print(input.getDisplayName() + "\n"); + if (GT_Utility.isStackValid(input)) { + int[] oreDict = OreDictionary.getOreIDs(input); + for (int oreDictID : oreDict) { + String oreName = OreDictionary.getOreName(oreDictID); + if (oreName.equals("dustTin") || oreName.equals("dustRutile")) { + GT_Recipe tRecipe = recipe.copy(); + remove.add(recipe); + break; + } + } + } + } + } + + chemicalBathRecipes.getBackend() + .removeRecipes(remove); + reAdd.forEach(chemicalBathRecipes::add); + chemicalBathRecipes.getBackend() + .reInit(); + + GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! "); + + remove.clear(); + reAdd.clear(); + + GT_Log.out.print("Chemical Bath done!\n"); + + // For Cauldron Wash + registerCauldronCleaningFor(Materials.Cerium, WerkstoffMaterialPool.CeriumRichMixture.getBridgeMaterial()); + registerCauldronCleaningFor( + Materials.Samarium, + WerkstoffMaterialPool.SamariumOreConcentrate.getBridgeMaterial()); + GT_Log.out.print(Tags.MODID + ": Replace 3! "); + GT_Log.out.print("Cauldron Wash done!\n"); + + // For Crafting Table + CraftingManager.getInstance() + .getRecipeList() + .forEach(RecipeLoader::replaceInCraftTable); + + GT_Log.out.print(Tags.MODID + ": Replace Unknown! "); + GT_Log.out.print("Crafting Table done!\n"); + } + + // below are taken from GoodGenerator + + // I don't understand. . . + // I use and copy some private methods in Bartworks because his system runs well. + // Bartworks is under MIT License + /* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY + * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A + * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR + * IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + public static void replaceInCraftTable(Object obj) { + + Constructor<?> cs = null; + PlatinumSludgeOverHaul BartObj = null; + try { + cs = PlatinumSludgeOverHaul.class.getDeclaredConstructor(); + cs.setAccessible(true); + } catch (NoSuchMethodException e) { + e.printStackTrace(); + } + + if (cs == null) return; + + try { + BartObj = (PlatinumSludgeOverHaul) cs.newInstance(); + } catch (IllegalAccessException | InstantiationException | InvocationTargetException e) { + e.printStackTrace(); + } + + Method recipeCheck = null; + + try { + recipeCheck = PlatinumSludgeOverHaul.class.getDeclaredMethod("checkRecipe", Object.class, Materials.class); + recipeCheck.setAccessible(true); + } catch (Exception e) { + e.printStackTrace(); + } + + String inputName = "output"; + String inputItemName = "input"; + if (!(obj instanceof ShapedOreRecipe || obj instanceof ShapelessOreRecipe)) { + if (obj instanceof ShapedRecipes || (obj instanceof ShapelessRecipes)) { + inputName = "recipeOutput"; + inputItemName = "recipeItems"; + } + } + IRecipe recipe = (IRecipe) obj; + ItemStack result = recipe.getRecipeOutput(); + + Field out = FieldUtils.getDeclaredField(recipe.getClass(), inputName, true); + if (out == null) out = FieldUtils.getField(recipe.getClass(), inputName, true); + + Field in = FieldUtils.getDeclaredField(recipe.getClass(), inputItemName, true); + if (in == null) in = FieldUtils.getField(recipe.getClass(), inputItemName, true); + if (in == null) return; + + // this part here is NOT MIT LICENSED BUT LICSENSED UNDER THE Apache License, Version 2.0! + try { + if (Modifier.isFinal(in.getModifiers())) { + // Do all JREs implement Field with a private ivar called "modifiers"? + Field modifiersField = Field.class.getDeclaredField("modifiers"); + boolean doForceAccess = !modifiersField.isAccessible(); + if (doForceAccess) { + modifiersField.setAccessible(true); + } + try { + modifiersField.setInt(in, in.getModifiers() & ~Modifier.FINAL); + } finally { + if (doForceAccess) { + modifiersField.setAccessible(false); + } + } + } + } catch (NoSuchFieldException ignored) { + // The field class contains always a modifiers field + } catch (IllegalAccessException ignored) { + // The modifiers field is made accessible + } + // END OF APACHE COMMONS COLLECTION COPY + + Object input; + try { + input = in.get(obj); + } catch (IllegalAccessException e) { + e.printStackTrace(); + return; + } + + if (out == null || recipeCheck == null) return; + + if (GT_Utility.areStacksEqual(result, Materials.Cerium.getDust(1), true)) { + + recipeCheck.setAccessible(true); + boolean isOk = true; + + try { + isOk = (boolean) recipeCheck.invoke(BartObj, input, Materials.Cerium); + } catch (InvocationTargetException | IllegalAccessException ignored) {} + + if (isOk) return; + try { + out.set(recipe, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 2)); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } else if (GT_Utility.areStacksEqual(result, Materials.Samarium.getDust(1), true)) { + + recipeCheck.setAccessible(true); + boolean isOk = true; + + try { + isOk = (boolean) recipeCheck.invoke(BartObj, input, Materials.Samarium); + } catch (InvocationTargetException | IllegalAccessException ignored) {} + + if (isOk) return; + try { + out.set(recipe, WerkstoffMaterialPool.SamariumOreConcentrate.get(OrePrefixes.dust, 2)); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + } + } +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/loader/ZPMRubberChanges.java b/lath/src/main/java/com/elisis/gtnhlanth/loader/ZPMRubberChanges.java new file mode 100644 index 0000000000..52ab4f15d1 --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/loader/ZPMRubberChanges.java @@ -0,0 +1,409 @@ +package com.elisis.gtnhlanth.loader; + +import static gregtech.api.enums.OrePrefixes.*; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.function.Consumer; +import java.util.function.Predicate; + +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.CraftingManager; +import net.minecraft.item.crafting.IRecipe; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import org.apache.commons.lang3.reflect.FieldUtils; +import org.apache.commons.lang3.reflect.MethodUtils; + +import com.elisis.gtnhlanth.common.register.WerkstoffMaterialPool; +import com.github.bartimaeusnek.bartworks.system.material.Werkstoff; +import com.github.bartimaeusnek.bartworks.util.BW_Util; + +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.Mods; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.objects.ItemData; +import gregtech.api.recipe.RecipeMap; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Recipe.GT_Recipe_AssemblyLine; +import gregtech.api.util.GT_Shaped_Recipe; +import gregtech.api.util.GT_Utility; + +public class ZPMRubberChanges implements Runnable { + + @SuppressWarnings("unchecked") + public void run() { + + List<IRecipe> bufferedRecipeList = null; + + try { + bufferedRecipeList = (List<IRecipe>) FieldUtils + .getDeclaredField(GT_ModHandler.class, "sBufferRecipeList", true) + .get(null); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + + HashSet<ItemStack> ZPMPlusComponents = new HashSet<>(); + OrePrefixes[] RubberGenerated = { plate }; + + Arrays.stream(ItemList.values()) + .filter( + item -> (item.toString() + .contains("ZPM") + || item.toString() + .contains("UV") + || item.toString() + .contains("UHV") + || item.toString() + .contains("UEV")) + && item.hasBeenSet()) + .forEach(item -> ZPMPlusComponents.add(item.get(1))); + + if (Mods.NewHorizonsCoreMod.isModLoaded()) { + addDreamcraftItemListItems(ZPMPlusComponents); + } + + for (ItemStack component : ZPMPlusComponents) { + GT_Log.out.print(component.getDisplayName() + " "); + } + + replaceAllRecipes(ZPMPlusComponents, RubberGenerated, bufferedRecipeList); + } + + private static void replaceAllRecipes(Collection<ItemStack> ZPMPlusComponents, OrePrefixes[] RubberGenerated, + List<IRecipe> bufferedRecipeList) { + + for (GT_Recipe_AssemblyLine sAssemblylineRecipe : GT_Recipe_AssemblyLine.sAssemblylineRecipes) { + for (ItemStack stack : ZPMPlusComponents) { + rewriteAsslineRecipes(stack, RubberGenerated, sAssemblylineRecipe); + } + } + + for (RecipeMap<?> map : RecipeMap.ALL_RECIPE_MAPS.values()) { + for (GT_Recipe recipe : map.getAllRecipes()) { + for (ItemStack stack : ZPMPlusComponents) { + rewriteMachineRecipes(stack, RubberGenerated, recipe); + } + } + } + + for (ItemStack stack : ZPMPlusComponents) { + Predicate recipeFilter = obj -> obj instanceof GT_Shaped_Recipe + && GT_Utility.areStacksEqual(((GT_Shaped_Recipe) obj).getRecipeOutput(), stack, true); + rewriteCraftingRecipes(bufferedRecipeList, RubberGenerated, recipeFilter); + } + /* + * for (ItemStack stack : LuVMachines) { Predicate recipeFilter = obj -> obj instanceof GT_Shaped_Recipe && + * GT_Utility.areStacksEqual(((GT_Shaped_Recipe) obj).getRecipeOutput(), stack, true); + * rewriteCraftingRecipes(bufferedRecipeList, LuVMaterialsGenerated, recipeFilter); } + */ + } + + private static void addDreamcraftItemListItems(Collection ZPMPlusComponents) { + try { + Class customItemListClass = Class.forName("com.dreammaster.gthandler.CustomItemList"); + Method hasnotBeenSet = MethodUtils.getAccessibleMethod(customItemListClass, "hasBeenSet"); + Method get = MethodUtils.getAccessibleMethod(customItemListClass, "get", long.class, Object[].class); + for (Enum customItemList : (Enum[]) FieldUtils.getField(customItemListClass, "$VALUES", true) + .get(null)) { + if ((customItemList.toString() + .contains("ZPM") + || customItemList.toString() + .contains("UV") + || customItemList.toString() + .contains("UHV") + || customItemList.toString() + .contains("UEV")) + && (boolean) hasnotBeenSet.invoke(customItemList)) + ZPMPlusComponents.add((ItemStack) get.invoke(customItemList, 1, new Object[0])); + } + } catch (IllegalAccessException | ClassNotFoundException | InvocationTargetException e) { + e.printStackTrace(); + } + } + + private static void rewriteCraftingRecipes(List<IRecipe> bufferedRecipeList, OrePrefixes[] RubberGenerated, + Predicate recipeFilter) { + for (OrePrefixes prefixes : RubberGenerated) { + + Consumer recipeAction = (obj) -> { + ZPMRubberChanges.doStacksCointainAndReplace( + ((GT_Shaped_Recipe) obj).getInput(), + GT_OreDictUnificator.get(prefixes, Materials.Silicone, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + ZPMRubberChanges.doStacksCointainAndReplace( + ((GT_Shaped_Recipe) obj).getInput(), + GT_OreDictUnificator.get(prefixes, Materials.StyreneButadieneRubber, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + }; + + /* + * || ZPMRubberChanges.doStacksCointainAndReplace(((GT_Shaped_Recipe) obj).getInput(), + * GT_OreDictUnificator.get(prefixes, Materials.StyreneButadieneRubber, 1), true, + * WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + */ + + CraftingManager.getInstance() + .getRecipeList() + .stream() + .filter(recipeFilter) + .forEach(recipeAction); + bufferedRecipeList.stream() + .filter(recipeFilter) + .forEach(recipeAction); + } + } + + private static void rewriteMachineRecipes(ItemStack stack, OrePrefixes[] RubberGenerated, GT_Recipe recipe) { + if (ZPMRubberChanges.doStacksCointainAndReplace(recipe.mInputs, stack, false)) { + for (OrePrefixes prefixes : RubberGenerated) { + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mInputs, + GT_OreDictUnificator.get(prefixes, Materials.Silicone, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mOutputs, + GT_OreDictUnificator.get(prefixes, Materials.Silicon, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mInputs, + GT_OreDictUnificator.get(prefixes, Materials.StyreneButadieneRubber, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mOutputs, + GT_OreDictUnificator.get(prefixes, Materials.StyreneButadieneRubber, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + } + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mFluidInputs, + Materials.Silicone.getMolten(1), + true, + WerkstoffMaterialPool.PTMEGElastomer.getMolten(1) + .getFluid()); + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mFluidOutputs, + Materials.Silicone.getMolten(1), + true, + WerkstoffMaterialPool.PTMEGElastomer.getMolten(1) + .getFluid()); + + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mFluidInputs, + Materials.StyreneButadieneRubber.getMolten(1), + true, + WerkstoffMaterialPool.PTMEGElastomer.getMolten(1) + .getFluid()); + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mFluidOutputs, + Materials.StyreneButadieneRubber.getMolten(1), + true, + WerkstoffMaterialPool.PTMEGElastomer.getMolten(1) + .getFluid()); + } + if (ZPMRubberChanges.doStacksCointainAndReplace(recipe.mOutputs, stack, false)) { + for (OrePrefixes prefixes : RubberGenerated) { + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mInputs, + GT_OreDictUnificator.get(prefixes, Materials.Silicone, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mOutputs, + GT_OreDictUnificator.get(prefixes, Materials.Silicone, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mInputs, + GT_OreDictUnificator.get(prefixes, Materials.StyreneButadieneRubber, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mOutputs, + GT_OreDictUnificator.get(prefixes, Materials.StyreneButadieneRubber, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + } + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mFluidInputs, + Materials.Silicone.getMolten(1), + true, + WerkstoffMaterialPool.PTMEGElastomer.getMolten(1) + .getFluid()); + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mFluidOutputs, + Materials.Silicone.getMolten(1), + true, + WerkstoffMaterialPool.PTMEGElastomer.getMolten(1) + .getFluid()); + + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mFluidInputs, + Materials.StyreneButadieneRubber.getMolten(1), + true, + WerkstoffMaterialPool.PTMEGElastomer.getMolten(1) + .getFluid()); + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mFluidOutputs, + Materials.StyreneButadieneRubber.getMolten(1), + true, + WerkstoffMaterialPool.PTMEGElastomer.getMolten(1) + .getFluid()); + } + } + + private static void rewriteAsslineRecipes(ItemStack stack, OrePrefixes[] RubberGenerated, + GT_Recipe.GT_Recipe_AssemblyLine recipe) { + for (OrePrefixes prefixes : RubberGenerated) { + if (ZPMRubberChanges.doStacksCointainAndReplace(recipe.mInputs, stack, false)) { + + GT_Log.out.print(Arrays.toString(recipe.mInputs)); + + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mInputs, + GT_OreDictUnificator.get(prefixes, Materials.Silicone, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + ZPMRubberChanges.doStacksCointainAndReplace( + new Object[] { recipe.mOutput }, + GT_OreDictUnificator.get(prefixes, Materials.Silicone, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mInputs, + GT_OreDictUnificator.get(prefixes, Materials.StyreneButadieneRubber, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + ZPMRubberChanges.doStacksCointainAndReplace( + new Object[] { recipe.mOutput }, + GT_OreDictUnificator.get(prefixes, Materials.StyreneButadieneRubber, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + } + if (ZPMRubberChanges.doStacksCointainAndReplace(new Object[] { recipe.mOutput }, stack, false)) { + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mInputs, + GT_OreDictUnificator.get(prefixes, Materials.Silicone, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + ZPMRubberChanges.doStacksCointainAndReplace( + new Object[] { recipe.mOutput }, + GT_OreDictUnificator.get(prefixes, Materials.Silicone, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mInputs, + GT_OreDictUnificator.get(prefixes, Materials.StyreneButadieneRubber, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + ZPMRubberChanges.doStacksCointainAndReplace( + new Object[] { recipe.mOutput }, + GT_OreDictUnificator.get(prefixes, Materials.StyreneButadieneRubber, 1), + true, + WerkstoffMaterialPool.PTMEGElastomer.get(prefixes)); + } + } + if (ZPMRubberChanges.doStacksCointainAndReplace(recipe.mInputs, stack, false)) { + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mFluidInputs, + Materials.Silicone.getMolten(1), + true, + WerkstoffMaterialPool.PTMEGElastomer.getMolten(1) + .getFluid()); + + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mFluidInputs, + Materials.StyreneButadieneRubber.getMolten(1), + true, + WerkstoffMaterialPool.PTMEGElastomer.getMolten(1) + .getFluid()); + } + if (ZPMRubberChanges.doStacksCointainAndReplace(new Object[] { recipe.mOutput }, stack, false)) { + ZPMRubberChanges.doStacksCointainAndReplace( + recipe.mFluidInputs, + Materials.StyreneButadieneRubber.getMolten(1), + true, + WerkstoffMaterialPool.PTMEGElastomer.getMolten(1) + .getFluid()); + } + } + + private static ItemStack[] replaceArrayWith(ItemStack[] stackArray, Materials source, Werkstoff target) { + for (int i = 0; i < stackArray.length; i++) { + ItemStack stack = stackArray[i]; + if (!BW_Util.checkStackAndPrefix(stack)) continue; + stackArray[i] = replaceStackWith(stack, source, target); + } + return stackArray; + } + + private static ItemStack replaceStackWith(ItemStack stack, Materials source, Werkstoff target) { + ItemData ass = GT_OreDictUnificator.getAssociation(stack); + if (ass.mMaterial.mMaterial.equals(source)) + if (target.hasItemType(ass.mPrefix)) stack = target.get(ass.mPrefix, stack.stackSize); + return stack; + } + + private static boolean doStacksCointainAndReplace(FluidStack[] stacks, FluidStack stack, boolean replace, + Fluid... replacement) { + boolean replaced = false; + for (int i = 0; i < stacks.length; i++) { + if (GT_Utility.areFluidsEqual(stack, stacks[i])) if (!replace) return true; + else { + int amount = stacks[i].amount; + stacks[i] = new FluidStack(replacement[0], amount); + replaced = true; + } + } + return replaced; + } + + private static boolean doStacksCointainAndReplace(Object[] stacks, ItemStack stack, boolean replace, + ItemStack... replacement) { + // GT_Log.out.print("In doStacksCointainAndReplace!\n"); + boolean replaced = false; + for (int i = 0; i < stacks.length; i++) { + if (!GT_Utility.isStackValid(stacks[i])) { + if (stacks[i] instanceof ArrayList && ((ArrayList) stacks[i]).size() > 0) { + if (GT_Utility.areStacksEqual(stack, (ItemStack) ((ArrayList) stacks[i]).get(0), true)) + if (!replace) return true; + else { + int amount = ((ItemStack) ((ArrayList) stacks[i]).get(0)).stackSize; + stacks[i] = new ArrayList<>(); + ((ArrayList) stacks[i]).add(BW_Util.setStackSize(replacement[0], amount)); + replaced = true; + + GT_Log.out.print("Replaced recipe!: " + stack.getDisplayName() + " "); + } + + } else continue; + } else if (GT_Utility.areStacksEqual(stack, (ItemStack) stacks[i], true)) if (!replace) return true; + else { + int amount = ((ItemStack) stacks[i]).stackSize; + stacks[i] = BW_Util.setStackSize(replacement[0], amount); + replaced = true; + } + } + return replaced; + } +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/util/DescTextLocalization.java b/lath/src/main/java/com/elisis/gtnhlanth/util/DescTextLocalization.java new file mode 100644 index 0000000000..28e63b2744 --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/util/DescTextLocalization.java @@ -0,0 +1,22 @@ +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; + } +} diff --git a/lath/src/main/java/com/elisis/gtnhlanth/xmod/nei/NEI_Config.java b/lath/src/main/java/com/elisis/gtnhlanth/xmod/nei/NEI_Config.java new file mode 100644 index 0000000000..cf784d638e --- /dev/null +++ b/lath/src/main/java/com/elisis/gtnhlanth/xmod/nei/NEI_Config.java @@ -0,0 +1,26 @@ +package com.elisis.gtnhlanth.xmod.nei; + +import com.elisis.gtnhlanth.Tags; + +import codechicken.nei.api.IConfigureNEI; + +public class NEI_Config implements IConfigureNEI { + + public static boolean isAdded = true; + + @Override + public String getName() { + return "GTNH: Lanthanides NEI"; + } + + @Override + public String getVersion() { + return Tags.VERSION; + } + + @Override + public void loadConfig() { + isAdded = false; + isAdded = true; + } +} diff --git a/lath/src/main/resources/assets/gtnhlanth/lang/en_US.lang b/lath/src/main/resources/assets/gtnhlanth/lang/en_US.lang new file mode 100644 index 0000000000..5aeb987b00 --- /dev/null +++ b/lath/src/main/resources/assets/gtnhlanth/lang/en_US.lang @@ -0,0 +1,55 @@ +# RecipeMaps +gtnhlanth.recipe.digester=Digester +gtnhlanth.recipe.disstank=Dissolution Tank + +# NEI +value.disstank=Ratio: %s:1 + +DissolutionTank.hint.0=Dot 1: Clean Stainless Steel Machine Casing +DissolutionTank.hint.1=24x Borosilicate Glass +DissolutionTank.hint.2=9x Heat Proof Machine Casing +DissolutionTank.hint.3=Input Bus, Output Bus, Input Hatches, Output Hatch +DissolutionTank.hint.4=Energy Hatch, Maintenance Hatch + +Digester.hint.0=Dot 1: Robust Tungstensteel Machine Casing +Digester.hint.1=9x Clean Stainless Steel Machine Casing +Digester.hint.2=16x Heat Proof Machine Casing +Digester.hint.3=16x Coil Block +Digester.hint.4=Input Bus, Output Bus, Input Hatch, Output Hatch +Digester.hint.5=Energy Hatch, Maintenance Hatch + +fluid.Antimony Pentafluoride Solution=Antimony Pentafluoride Solution +fluid.Hafnium Tetrachloride Solution=Hafnium Tetrachloride Solution +fluid.Zirconium Tetrachloride Solution=Zirconium Tetrachloride Solution +fluid.Iodine=Iodine +fluid.Muddy Monazite Rare Earth Solution=Muddy Monazite Rare Earth Solution +fluid.Diluted Monazite Rare Earth Mud=Diluted Monazite Rare Earth Mud +fluid.Diluted Monazite Sulfate=Diluted Monazite Sulfate +fluid.Nitrogenated Monazite Rare Earth Concentrate=Nitrogenated Monazite Rare Earth Concentrate +fluid.Nitric Monazite Leached Concentrate=Nitric Monazite Leached Concentrate +fluid.Ammonium Nitrate Solution=Ammonium Nitrate Solution +fluid.Seaweed Concentrate=Seaweed Concentrate +fluid.Potassium Permanganate Solution=Potassium Permanganate Solution +fluid.Seaweed Byproducts=Seaweed Byproducts +fluid.Nitric-Leached Monazite Mixture=Nitric-Leached Monazite Mixture +fluid.Muddy Bastnasite Rare Earth Solution=Muddy Bastnasite Rare Earth Solution +fluid.Sodiumfluorosilicate=Sodiumfluorosilicate +fluid.Steam-Cracked Bastnasite Mud=Steam-Cracked Bastnasite Mud +fluid.Conditioned Bastnasite Mud=Conditioned Bastnasite Mud +fluid.Diluted Bastnasite Mud=Diluted Bastnasite Mud +fluid.Filtered Bastnasite Mud=Filtered Bastnasite Mud +fluid.Nitrogenated Bastnasite Rarer Earth Oxides=Nitrogenated Bastnasite Rarer Earth Oxides +fluid.Bastnasite Rarer Earth Oxide Suspension=Bastnasite Rarer Earth Oxide Suspension +fluid.Calcium Fluoride=Calcium Fluoride +fluid.Tetrahydrofuran=Tetrahydrofuran +"fluid.1,4-Butanediol"="1,4-butanediol" +"fluid.Acidicised 1,4-Butanediol"="acidicised 1,4-butanediol" +fluid.Polytetrahydrofuran=Polytetrahydrofuran +fluid.Tungstophosphoric Acid=Tungstophosphoric Acid +fluid.Toluene Diisocyanate=Toluene Diisocyanate +fluid.Dinitrotoluene=Dinitrotoluene +fluid.Diaminotoluene=Diaminotoluene +fluid.Toluene Tetramethyl Diisocyanate=Toluene Tetramethyl Diisocyanate +fluid.Diluted Acetone=Diluted Acetone + +GT5U.gui.text.dissolution_ratio=§7Wrong fluid input ratio diff --git a/lath/src/main/resources/assets/gtnhlanth/lang/zh_CN.lang b/lath/src/main/resources/assets/gtnhlanth/lang/zh_CN.lang new file mode 100644 index 0000000000..2bd95ff47d --- /dev/null +++ b/lath/src/main/resources/assets/gtnhlanth/lang/zh_CN.lang @@ -0,0 +1,19 @@ +# RecipeMaps +gtnhlanth.recipe.digester=煮解池 +gtnhlanth.recipe.disstank=溶解罐 + +# NEI +value.disstank=比例: %s:1 + +DissolutionTank.hint.0=提示方块：1号：洁净不锈钢机械方块 +DissolutionTank.hint.1=24x硼玻璃(任意等级) +DissolutionTank.hint.2=9x隔热机械方块 +DissolutionTank.hint.3=输入总线、输出总线、输入仓、输出仓 +DissolutionTank.hint.4=能源仓、维护仓 + +Digester.hint.0=提示方块：1号：强化钨钢机械方块 +Digester.hint.1=9x洁净不锈钢机械方块 +Digester.hint.2=16x隔热机械方块 +Digester.hint.3=16x线圈方块 +Digester.hint.4=输入总线、输出总线、输入仓、输出仓 +Digester.hint.5=能源仓、维护仓 diff --git a/lath/src/main/resources/mcmod.info b/lath/src/main/resources/mcmod.info new file mode 100644 index 0000000000..c2262016e2 --- /dev/null +++ b/lath/src/main/resources/mcmod.info @@ -0,0 +1,16 @@ +[ + { + "modid": "${modId}", + "name": "${modName}", + "description": "An example mod for Minecraft 1.7.10 with Forge focussed on a stable setup.", + "version": "${modVersion}", + "mcversion": "${minecraftVersion}", + "url": "https://github.com/SinTh0r4s/MyMod", + "updateUrl": "", + "authorList": ["SinTho0r4s"], + "credits": "", + "logoFile": "", + "screenshots": [], + "dependencies": [] + } +] |