Add materials, add multis, just look at the diff tbh

10 files changed, 1289 insertions, 7 deletions

diff --git a/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java b/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java
index 6f22d039e5..5e900fdf55 100644
--- a/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java
+++ b/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java
@@ -1,7 +1,11 @@
 package com.elisis.gtnhlanth;

 

+import java.util.logging.Logger;

+

 import com.elisis.gtnhlanth.common.CommonProxy;

+import com.elisis.gtnhlanth.common.register.ItemList;

 import com.elisis.gtnhlanth.common.register.WerkstoffMaterialPool;

+import com.elisis.gtnhlanth.loader.RecipeLoader;

 import com.github.bartimaeusnek.bartworks.API.WerkstoffAdderRegistry;

 

 import cpw.mods.fml.common.Mod;

@@ -13,9 +17,13 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 

 @Mod(modid = Tags.MODID, version = Tags.VERSION, name = Tags.MODNAME, 

     dependencies = "required-after:IC2; " + "required-after:gregtech; "

+            + "required-after:bartworks; " 

+            + "required-after:GoodGenerator; "

         )

 public class GTNHLanthanides {

     

+    public static Logger LOG = Logger.getLogger("GTNH:Lanthanides");

+    

     @Mod.Instance

     public static GTNHLanthanides instance;

     

@@ -25,6 +33,7 @@ public class GTNHLanthanides {
     @EventHandler

     public static void preInit(FMLPreInitializationEvent e) {

         WerkstoffAdderRegistry.addWerkstoffAdder(new WerkstoffMaterialPool());

+        ItemList.register();

         proxy.preInit(e);

     }

     

@@ -35,6 +44,8 @@ public class GTNHLanthanides {
     

     @EventHandler

     public static void postInit(FMLPostInitializationEvent e) {

+        RecipeLoader.loadGeneral();

+        RecipeLoader.loadLanthanideRecipes();

         proxy.postInit(e);

     }

     

diff --git a/src/main/java/com/elisis/gtnhlanth/common/CommonProxy.java b/src/main/java/com/elisis/gtnhlanth/common/CommonProxy.java
index c99a60fd79..a1022cf699 100644
--- a/src/main/java/com/elisis/gtnhlanth/common/CommonProxy.java
+++ b/src/main/java/com/elisis/gtnhlanth/common/CommonProxy.java
@@ -1,7 +1,5 @@
 package com.elisis.gtnhlanth.common;

 

-import java.util.logging.Logger;

-

 import cpw.mods.fml.common.event.FMLInitializationEvent;

 import cpw.mods.fml.common.event.FMLPostInitializationEvent;

 import cpw.mods.fml.common.event.FMLPreInitializationEvent;

diff --git a/src/main/java/com/elisis/gtnhlanth/common/register/ItemList.java b/src/main/java/com/elisis/gtnhlanth/common/register/ItemList.java
new file mode 100644
index 0000000000..9f70c70d78
--- /dev/null
+++ b/src/main/java/com/elisis/gtnhlanth/common/register/ItemList.java
@@ -0,0 +1,19 @@
+package com.elisis.gtnhlanth.common.register;
+
+import com.elisis.gtnhlanth.common.tileentity.Digester;
+
+import net.minecraft.item.ItemStack;
+
+public final class ItemList {
+	
+	public static ItemStack DIGESTER;
+
+	public static void register() {
+		
+		ItemList.DIGESTER = new Digester(10500, "Digester", "Digester").getStackForm(1L);
+		
+	}
+	
+	
+
+}
diff --git a/src/main/java/com/elisis/gtnhlanth/common/register/WerkstoffMaterialPool.java b/src/main/java/com/elisis/gtnhlanth/common/register/WerkstoffMaterialPool.java
index ec8bb8cbbf..dca342fded 100644
--- a/src/main/java/com/elisis/gtnhlanth/common/register/WerkstoffMaterialPool.java
+++ b/src/main/java/com/elisis/gtnhlanth/common/register/WerkstoffMaterialPool.java
@@ -3,6 +3,7 @@ package com.elisis.gtnhlanth.common.register;
 import static com.github.bartimaeusnek.bartworks.util.BW_Util.subscriptNumbers;

 

 import com.github.bartimaeusnek.bartworks.system.material.Werkstoff;

+import com.github.bartimaeusnek.bartworks.system.material.Werkstoff.GenerationFeatures;

 

 import gregtech.api.enums.TextureSet;

 

@@ -12,6 +13,28 @@ public class WerkstoffMaterialPool implements Runnable {
     private static final int offsetID = 11_000;

     

     //Misc.

+    public static final Werkstoff Hafnium = new Werkstoff(

+            new short[] {232, 224, 219},

+            "Hafnium",

+            subscriptNumbers("Hf"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().onlyDust().addMetalItems().enforceUnification(), //Perhaps use hafnia liquid in elemental hafnium synthesis

+            offsetID,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff LowPurityHafnium = new Werkstoff(

+            new short[] {240, 223, 208},

+            "Low-Purity Hafnium",

+            subscriptNumbers("??Hf??"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(), //Perhaps use hafnia liquid in elemental hafnium synthesis

+            offsetID + 1,

+            TextureSet.SET_DULL

+        );

+    

     public static final Werkstoff Hafnia = new Werkstoff(

             new short[] {247, 223, 203},

             "Hafnia",

@@ -19,10 +42,122 @@ public class WerkstoffMaterialPool implements Runnable {
             new Werkstoff.Stats(),

             Werkstoff.Types.COMPOUND,

             new Werkstoff.GenerationFeatures().disable().onlyDust(), //Perhaps use hafnia liquid in elemental hafnium synthesis

-            offsetID,

+            offsetID + 2,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff HafniumTetrachloride = new Werkstoff(

+            new short[] {238, 247, 249},

+            "Hafnium Tetrachloride",

+            subscriptNumbers("HfCl4"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 3,

             TextureSet.SET_DULL

         );

     

+    public static final Werkstoff HafniumTetrachlorideSolution = new Werkstoff(

+            new short[] {238, 247, 249},

+            "Hafnium Tetrachloride Solution",

+            subscriptNumbers("HfCl4"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().addCells(),

+            offsetID + 4,

+            TextureSet.SET_FLUID

+        );

+    

+    public static final Werkstoff HafniumIodide = new Werkstoff(

+            new short[] {216, 60, 1},

+            "Hafnium Iodide",

+            subscriptNumbers("HfI4"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 5,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff HafniumRunoff = new Werkstoff(

+            new short[] {74, 65, 42}, //Literally the statistically ugliest colour

+            "Hafnium Runoff",

+            subscriptNumbers("??????"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 6,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff Zirconium = new Werkstoff(

+            new short[] {225,230,225},

+            "Zirconium",

+            subscriptNumbers("Zr"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().addMetalItems().enforceUnification(),

+            offsetID + 7,

+            TextureSet.SET_DULL

+            

+        );

+    

+    public static final Werkstoff Zirconia = new Werkstoff(

+            new short[] {177,152,101},

+            "Zirconia",

+            subscriptNumbers("ZrO2"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 8,

+            TextureSet.SET_DULL

+            

+        );

+    

+    public static final Werkstoff ZirconiumTetrachloride = new Werkstoff(

+            new short[] {179, 164, 151},

+            "Zirconium Tetrachloride",

+            subscriptNumbers("ZrCl4"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 9,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff ZirconiumTetrachlorideSolution = new Werkstoff(

+            new short[] {179, 164, 151},

+            "Zirconium Tetrachloride Solution",

+            subscriptNumbers("ZrCl4"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().addCells(), //Blast Furnace needs liquid input because it can't do 3 item inputs so have a shitty material

+            offsetID + 10,

+            TextureSet.SET_FLUID

+        );

+    

+    public static final Werkstoff HafniaZirconiaBlend = new Werkstoff(

+            new short[] {247, 223, 203},

+            "Hafnia-Zirconia Blend", // Maybe Hafnon??

+            subscriptNumbers("??HfZr??"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 11,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff Iodine = new Werkstoff(

+            new short[] {171, 40, 175},

+            "Iodine",

+            subscriptNumbers("I"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().addCells().enforceUnification(),

+            offsetID + 12,

+            TextureSet.SET_FLUID

+        );

+    

     

     //Lanthanide Line

     public static final Werkstoff MuddyRareEarthSolution = new Werkstoff(

@@ -32,7 +167,7 @@ public class WerkstoffMaterialPool implements Runnable {
             new Werkstoff.Stats(),     

             Werkstoff.Types.MIXTURE,

             new Werkstoff.GenerationFeatures().disable().addCells(),

-            offsetID + 1,

+            offsetID + 14,

             TextureSet.SET_FLUID

         );

     

@@ -43,7 +178,7 @@ public class WerkstoffMaterialPool implements Runnable {
             new Werkstoff.Stats(),

             Werkstoff.Types.MIXTURE,

             new Werkstoff.GenerationFeatures().disable().addCells(),

-            offsetID + 2,

+            offsetID + 15,

             TextureSet.SET_FLUID

         );

     

@@ -54,11 +189,223 @@ public class WerkstoffMaterialPool implements Runnable {
             new Werkstoff.Stats(),

             Werkstoff.Types.MIXTURE,

             new Werkstoff.GenerationFeatures().disable().addCells(),

-            offsetID + 3,

+            offsetID + 16,

             TextureSet.SET_FLUID

         );

     

-

+    public static final Werkstoff NitratedRareEarthConcentrate = new Werkstoff(

+            new short[] {250, 223, 173},

+            "Nitrated Rare Earth Concentrate",

+            subscriptNumbers("??LaNd??"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().addCells(),

+            offsetID + 17,

+            TextureSet.SET_FLUID

+        );

+    

+    public static final Werkstoff NitricLeachedConcentrate = new Werkstoff(

+            new short[] {244, 202, 22},

+            "Nitric Leached Concentrate",

+            subscriptNumbers("??LaNd??"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().addCells(),

+            offsetID + 18,

+            TextureSet.SET_FLUID

+        );

+    

+    public static final Werkstoff MonaziteSulfate = new Werkstoff(

+            new short[] {152, 118, 84},

+            "Monazite Sulfate",

+            subscriptNumbers("??CeEu??"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 19,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff AcidicMonazitePowder = new Werkstoff(

+            new short[] {50, 23, 77},

+            "Acidic Monazite Powder",

+            subscriptNumbers("????"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 20,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff RareEarthFiltrate = new Werkstoff(

+            new short[] {72, 60, 50},

+            "Rare Earth Filtrate",

+            subscriptNumbers("????"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 21,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff NeutralizedRareEarthFiltrate = new Werkstoff(

+            new short[] {50, 23, 77},

+            "Neutralized Rare Earth Filtrate",

+            subscriptNumbers("????"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 22,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff RareEarthHydroxideConcentrate = new Werkstoff(

+            new short[] {193, 154, 107},

+            "Rare Earth Hydroxide Concentrate",

+            subscriptNumbers("????"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 23,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff DriedRareEarthConcentrate = new Werkstoff(

+            new short[] {250, 214, 165},

+            "Dried Rare Earth Concentrate",

+            subscriptNumbers("????"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 24,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff CeriumDioxide = new Werkstoff(

+            new short[] {255, 255, 255},

+            "Cerium Dioxide",

+            subscriptNumbers("CeO2"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().onlyDust().enforceUnification(),

+            offsetID + 25,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff CeriumChloride = new Werkstoff(

+            new short[] {255, 255, 255},

+            "Cerium Chloride",

+            subscriptNumbers("CeCl3"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 26,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff CeriumOxalate = new Werkstoff(

+            new short[] {255, 255, 224},

+            "Cerium Oxalate",

+            subscriptNumbers("Ce2(C2O4)3"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 27,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff CeriumIIIOxide = new Werkstoff(

+            new short[] {255, 255, 102},

+            "Cerium (III) Oxide",

+            subscriptNumbers("Ce2O3"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.COMPOUND,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 28,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff CeriumRichMixture = new Werkstoff(

+    		new short[] {244, 164, 96},

+    		"Cerium-Rich Mixture",

+    		subscriptNumbers("??Ce??"),

+    		new Werkstoff.Stats(),

+    		Werkstoff.Types.COMPOUND,

+    		new Werkstoff.GenerationFeatures().disable().onlyDust(),

+    		offsetID + 29,

+    		TextureSet.SET_DULL	

+    	);

+    

+    public static final Werkstoff CooledRareEarthConcentrate = new Werkstoff(

+            new short[] {250, 214, 165},

+            "Cooled Rare Earth Concentrate",

+            subscriptNumbers("????"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 30,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff RarerEarthSediment = new Werkstoff(

+            new short[] {250, 214, 165},

+            "Rarer Earth Sediment",

+            subscriptNumbers("????"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 31,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff HeterogenousHalogenicRareEarthMixture = new Werkstoff(

+            new short[] {250, 214, 165},

+            "Heterogenous Halogenic Rare Earth Mixture",

+            subscriptNumbers("????"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 32,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff SaturatedRareEarthMixture = new Werkstoff(

+            new short[] {250, 214, 165},

+            "Saturated Rare Earth Mixture",

+            subscriptNumbers("????"),

+            new Werkstoff.Stats(),

+            Werkstoff.Types.MIXTURE,

+            new Werkstoff.GenerationFeatures().disable().onlyDust(),

+            offsetID + 33,

+            TextureSet.SET_DULL

+        );

+    

+    public static final Werkstoff SamaricResidue = new Werkstoff(

+    		new short[] {248, 243, 231},

+    		"Samaric Residue",

+    		subscriptNumbers("??SmGd??"),

+    		new Werkstoff.Stats(),

+    		Werkstoff.Types.MIXTURE,

+    		new Werkstoff.GenerationFeatures().disable().onlyDust(),

+    		offsetID + 34,

+    		TextureSet.SET_DULL

+    	);

+    

+    public static final Werkstoff MonaziteResidue = new Werkstoff(

+    		new short[] {64, 69, 62},

+    		subscriptNumbers("??ZrHfTh??"),

+    		new Werkstoff.Stats(),

+    		Werkstoff.Types.MIXTURE,

+    		new Werkstoff.GenerationFeatures().disable().onlyDust(),

+    		offsetID + 35,

+    		TextureSet.SET_DULL

+    	);

+    		

+    		

+    

+    

+    		

+    

     @Override

     public void run() {

         

diff --git a/src/main/java/com/elisis/gtnhlanth/common/tileentity/Digester.java b/src/main/java/com/elisis/gtnhlanth/common/tileentity/Digester.java
new file mode 100644
index 0000000000..655408550c
--- /dev/null
+++ b/src/main/java/com/elisis/gtnhlanth/common/tileentity/Digester.java
@@ -0,0 +1,206 @@
+package com.elisis.gtnhlanth.common.tileentity;
+
+import static com.elisis.gtnhlanth.util.DescTextLocalization.BLUEPRINT_INFO;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain;
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose;
+import static gregtech.api.util.GT_StructureUtility.ofCoil;
+import static gregtech.api.util.GT_StructureUtility.ofHatchAdder;
+
+import java.util.ArrayList;
+
+import org.lwjgl.input.Keyboard;
+
+import com.elisis.gtnhlanth.loader.RecipeAdder;
+import com.elisis.gtnhlanth.util.DescTextLocalization;
+import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_GUIContainer_MultiMachineEM;
+import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM;
+import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.HeatingCoilLevel;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.IIconContainer;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.util.GT_Multiblock_Tooltip_Builder;
+import gregtech.api.util.GT_Recipe;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+
+public class Digester extends GT_MetaTileEntity_MultiblockBase_EM implements IConstructable {
+	
+    protected int casingAmount = 0;
+    protected int height = 0;
+    
+    private HeatingCoilLevel heatLevel;
+    
+    @SuppressWarnings("deprecation")
+	private IStructureDefinition<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', ofChain(
+    					ofHatchAdder(Digester::addInputToMachineList, 47, 1),
+    					ofHatchAdder(Digester::addOutputToMachineList, 47, 1),
+    					ofHatchAdder(Digester::addEnergyInputToMachineList, 47, 1),
+    					ofHatchAdder(Digester::addMaintenanceToMachineList, 47, 1),
+    					ofHatchAdder(Digester::addMufflerToMachineList, 47, 1),
+    					ofBlock(GregTech_API.sBlockCasings4, 0)
+    		))
+    		.addElement('h', ofBlock(GregTech_API.sBlockCasings1, 11))
+    		.addElement('s', ofBlock(GregTech_API.sBlockCasings4, 1))
+    		.addElement('c', ofCoil(Digester::setCoilLevel, Digester::getCoilLevel))
+    		.build();
+    		
+
+    //private int mHeat;
+    //private int mNeededHeat;
+    
+
+    public Digester(String name) {
+    	super(name);
+    }
+
+	public Digester(int id, String name, String nameRegional) {
+		super(id, name, nameRegional);
+	}
+
+	
+	@Override
+    public IStructureDefinition<Digester> getStructure_EM(){	
+		return multiDefinition;
+	}
+	
+	@Override
+    public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        return structureCheck_EM(mName, 3, 3, 0);
+    }
+	
+	@Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+	
+	public HeatingCoilLevel getCoilLevel() {
+		return this.heatLevel;
+	}
+	
+	public void setCoilLevel(HeatingCoilLevel level) {
+		this.heatLevel = level;	
+	}
+	
+	@Override
+	public boolean checkRecipe_EM(ItemStack itemStack) {
+		
+		ArrayList<FluidStack> tFluidInputs = this.getStoredFluids();
+		FluidStack[] tFluidInputArray = tFluidInputs.toArray(new FluidStack[0]);
+		ArrayList<ItemStack> tItems = this.getStoredInputs();
+		long tVoltage = this.getMaxInputVoltage();
+		
+		//Collection<GT_Recipe> tRecipes = RecipeAdder.instance.DigesterRecipes.mRecipeList;
+		GT_Recipe tRecipe = RecipeAdder.instance.DigesterRecipes.findRecipe(
+				this.getBaseMetaTileEntity(), 
+				this.doTickProfilingInThisTick, 
+				tVoltage, 
+				this.mOutputFluids,
+				this.mInventory
+			);
+		
+		if (tRecipe == null)
+			return false;
+		
+		if (tRecipe.isRecipeInputEqual(true, tFluidInputArray, mInventory[1])) {
+			
+			this.mEfficiency = (10000 - (this.getIdealStatus() - this.getRepairStatus()) * 1000);
+			this.mEfficiencyIncrease = 10000;
+			this.calculateOverclockedNessMulti(tRecipe.mEUt, tRecipe.mDuration, 1, tVoltage);
+			
+			if (mMaxProgresstime == Integer.MAX_VALUE - 1 && this.mEUt == Integer.MAX_VALUE - 1)
+				return false;
+			
+			if (tRecipe.mSpecialValue > this.getCoilLevel().getHeat())
+				return false;
+			
+			if (this.mEUt > 0)
+				this.mEUt = (-this.mEUt);
+			
+			this.mOutputFluids = new FluidStack[] {
+					tRecipe.getFluidOutput(0)
+			};
+			return true;
+		}
+		return false;
+	}
+	
+	@Override
+	public int getMaxEfficiency(ItemStack itemStack) {
+		return 10000;
+	}
+	
+	@Override
+    public int getPollutionPerTick(ItemStack aStack) {
+        return 200;
+    }
+	
+	@Override
+    public Object getClientGUI(int id, InventoryPlayer playerInventory, IGregTechTileEntity metaTileEntity) {
+        return new GT_GUIContainer_MultiMachineEM(playerInventory, metaTileEntity, getLocalName(), "Digester.png");
+    }
+	
+	@Override
+    public String[] getDescription() {
+        final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder();
+        tt.addMachineType("Digester")
+                .addInfo("Controller block for the Digester")
+                .addInfo("Input ores and fluid, output water.")
+                .addInfo("You will need to balance the heat provided")
+                .addInfo("to be able to complete the recipe.")
+                .addInfo(BLUEPRINT_INFO)
+                .addSeparator()
+                .addController("Front bottom")
+                .addInputHatch("Hint block with dot 1")
+                .addInputBus("Hint block with dot 1")
+                .addOutputHatch("Hint block with dot 2")
+                .addOutputBus("Hint block with dot 2")
+                .addMaintenanceHatch("Hint block with dot 2")
+                .addOtherStructurePart("Neutron Accelerator", "Hint block with dot 2")
+                .addOtherStructurePart("Neutron Sensor", "Hint block with dot 2")
+                .addCasingInfo("Clean Stainless Steel Machine Casing", 7)
+                .toolTipFinisher("GTNH: Lanthanides");
+        if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
+            return tt.getInformation();
+        } else {
+            return tt.getStructureInformation();
+        }
+    }
+	
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity arg0) {
+		return new Digester(this.mName);
+	}
+
+	@Override
+	public void construct(ItemStack itemStack, boolean b) {
+		structureBuild_EM(mName, 3, 3, 0, b, itemStack);
+		
+	}
+
+	@Override
+	public String[] getStructureDescription(ItemStack arg0) {
+		return DescTextLocalization.addText("UniversalChemicalFuelEngine.hint", 11);
+	}
+
+}
diff --git a/src/main/java/com/elisis/gtnhlanth/common/tileentity/DissolutionTank.java b/src/main/java/com/elisis/gtnhlanth/common/tileentity/DissolutionTank.java
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/src/main/java/com/elisis/gtnhlanth/common/tileentity/DissolutionTank.java
diff --git a/src/main/java/com/elisis/gtnhlanth/loader/MetaTileEntity_Loader.java b/src/main/java/com/elisis/gtnhlanth/loader/MetaTileEntity_Loader.java
new file mode 100644
index 0000000000..a2cd209a13
--- /dev/null
+++ b/src/main/java/com/elisis/gtnhlanth/loader/MetaTileEntity_Loader.java
@@ -0,0 +1,5 @@
+package com.elisis.gtnhlanth.loader;
+
+public class MetaTileEntity_Loader {
+
+}
diff --git a/src/main/java/com/elisis/gtnhlanth/loader/RecipeAdder.java b/src/main/java/com/elisis/gtnhlanth/loader/RecipeAdder.java
new file mode 100644
index 0000000000..fa17bc4bdd
--- /dev/null
+++ b/src/main/java/com/elisis/gtnhlanth/loader/RecipeAdder.java
@@ -0,0 +1,91 @@
+package com.elisis.gtnhlanth.loader;
+
+import java.util.Collection;
+import java.util.HashSet;
+
+import gregtech.api.util.GT_Recipe;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.fluids.FluidStack;
+
+public class RecipeAdder {
+	
+	
+
+	public static final RecipeAdder instance = new RecipeAdder();
+	
+	public final DigestMap DigesterRecipes = new DigestMap(
+			new HashSet<>(100),
+			"gtnhlanth.recipe.digester",
+			StatCollector.translateToLocal("tile.recipe.digester"),
+			null,
+			"gtnhlanth:textures/gui/digester",
+			1, 1, 1, 1, 1,
+			StatCollector.translateToLocal("value.digester") + ": ", //Heat Capacity
+			1,
+			"K",
+			false,
+			true	
+		);
+	
+	public final DissolutionTankMap DissolutionTankRecipes = new DissolutionTankMap(
+			new HashSet<>(100),
+			"gtnhlanth.recipe.disstank",
+			StatCollector.translateToLocal("tile.recipe.disstank"),
+			null,
+			"gtnhlanth:textures/gui/disstank",
+			1, 1, 1, 1, 1,
+			StatCollector.translateToLocal("value.disstank") + " ",
+			1,
+			" EU/t",
+			false,
+			true			
+		);
+	
+	
+	public class DigestMap extends GT_Recipe.GT_Recipe_Map {
+
+		public DigestMap(Collection<GT_Recipe> aRecipeList, 
+					String aUnlocalizedName, String aLocalName, 
+					String aNEIName, String aNEIGUIPath, 
+					int aUsualInputCount, int aUsualOutputCount, 
+					int aMinimalInputItems, int aMinimalInputFluids, 
+					int aAmperage, String aNEISpecialValuePre, 
+					int aNEISpecialValueMultiplier, String aNEISpecialValuePost, 
+					boolean aShowVoltageAmperageInNEI, boolean aNEIAllowed) {
+						super(aRecipeList, aUnlocalizedName, aLocalName, aNEIName, aNEIGUIPath, aUsualInputCount, aUsualOutputCount,
+								aMinimalInputItems, aMinimalInputFluids, aAmperage, aNEISpecialValuePre, aNEISpecialValueMultiplier,
+									aNEISpecialValuePost, aShowVoltageAmperageInNEI, aNEIAllowed);
+			
+					}
+		
+		public void addDigesterRecipe(FluidStack[] fluidInputs, ItemStack[] itemInputs, FluidStack fluidOutput, ItemStack[] itemOutputs, int EUt, int ticks, int heat){
+            super.addRecipe(false, itemInputs, itemOutputs, null, fluidInputs, new FluidStack[]{fluidOutput}, ticks, EUt, heat);
+        }
+		
+
+	}
+	
+	public class DissolutionTankMap extends GT_Recipe.GT_Recipe_Map {
+		
+		public DissolutionTankMap(Collection<GT_Recipe> aRecipeList,
+				String aUnlocalizedName, String aLocalName, 
+				String aNEIName, String aNEIGUIPath, 
+				int aUsualInputCount, int aUsualOutputCount, 
+				int aMinimalInputItems, int aMinimalInputFluids, 
+				int aAmperage, String aNEISpecialValuePre, 
+				int aNEISpecialValueMultiplier, String aNEISpecialValuePost, 
+				boolean aShowVoltageAmperageInNEI, boolean aNEIAllowed) {
+					super(aRecipeList, aUnlocalizedName, aLocalName, aNEIName, aNEIGUIPath, aUsualInputCount, aUsualOutputCount,
+							aMinimalInputItems, aMinimalInputFluids, aAmperage, aNEISpecialValuePre, aNEISpecialValueMultiplier,
+								aNEISpecialValuePost, aShowVoltageAmperageInNEI, aNEIAllowed);
+		
+				}
+		
+		public void addDissolutionTankRecipe(FluidStack[] fluidInputs, ItemStack[] itemInputs, FluidStack fluidOutput, ItemStack[] itemOutputs, int EUt, int ticks) {
+			super.addRecipe(false, itemInputs, itemOutputs, null, fluidInputs, new FluidStack[] {fluidOutput}, ticks, EUt, ticks);
+		}
+		
+	}
+
+}
diff --git a/src/main/java/com/elisis/gtnhlanth/loader/RecipeLoader.java b/src/main/java/com/elisis/gtnhlanth/loader/RecipeLoader.java
new file mode 100644
index 0000000000..2700154bee
--- /dev/null
+++ b/src/main/java/com/elisis/gtnhlanth/loader/RecipeLoader.java
@@ -0,0 +1,587 @@
+package com.elisis.gtnhlanth.loader;
+
+import static goodgenerator.items.MyMaterial.naquadahEarth;
+
+import java.util.HashSet;
+
+import com.elisis.gtnhlanth.Tags;
+import com.elisis.gtnhlanth.common.register.WerkstoffMaterialPool;
+import com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader;
+
+import goodgenerator.crossmod.LoadedList;
+import goodgenerator.items.MyMaterial;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.util.GTPP_Recipe;
+import gregtech.api.util.GT_Log;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gregtech.common.items.CombType;
+import gregtech.loaders.misc.GT_Bees;
+import gtPlusPlus.xmod.gregtech.loaders.RecipeGen_MultisUsingFluidInsteadOfCells;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+public class RecipeLoader {
+
+    private static final Materials[] BLACKLIST = null;
+
+	public static void loadGeneral() {
+        
+        /* ZIRCONIUM */
+        //ZrCl4
+        GT_Values.RA.addChemicalRecipe(
+                GT_Utility.getIntegratedCircuit(1), 
+                WerkstoffMaterialPool.Zirconia.get(OrePrefixes.dust, 1),
+                Materials.HydrochloricAcid.getFluid(4000), 
+                Materials.Water.getFluid(2000), 
+                WerkstoffMaterialPool.ZirconiumTetrachloride.get(OrePrefixes.dust, 1), 
+                300
+            );
+        
+        //ZrCl4-H2O
+        GT_Values.RA.addChemicalRecipe(
+                GT_Utility.getIntegratedCircuit(1),
+                WerkstoffMaterialPool.ZirconiumTetrachloride.get(OrePrefixes.dust, 1),
+                Materials.Water.getFluid(1000),
+                WerkstoffMaterialPool.ZirconiumTetrachlorideSolution.getFluidOrGas(1000),
+                null,
+                200
+            );
+        
+        
+        //Zr
+        GT_Values.RA.addBlastRecipe(
+                GT_Utility.getIntegratedCircuit(2), 
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Magnesium, 2), 
+                WerkstoffMaterialPool.ZirconiumTetrachlorideSolution.getFluidOrGas(1000), 
+                null, //No fluid output
+                WerkstoffMaterialPool.Zirconium.get(OrePrefixes.ingotHot, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Magnesiumchloride, 2), 
+                600, 1920, 4500
+            );
+        
+            
+        /* HAFNIUM */
+        //HfCl4
+        GT_Values.RA.addChemicalRecipe(
+                GT_Utility.getIntegratedCircuit(1), 
+                WerkstoffMaterialPool.Hafnia.get(OrePrefixes.dust, 1),
+                Materials.HydrochloricAcid.getFluid(4000), 
+                Materials.Water.getFluid(2000), 
+                WerkstoffMaterialPool.HafniumTetrachloride.get(OrePrefixes.dust, 1), 
+                300
+            );
+        
+        //HfCl4-H2O
+        GT_Values.RA.addChemicalRecipe(
+                GT_Utility.getIntegratedCircuit(1),
+                WerkstoffMaterialPool.HafniumTetrachloride.get(OrePrefixes.dust, 1),
+                Materials.Water.getFluid(1000),
+                WerkstoffMaterialPool.HafniumTetrachlorideSolution.getFluidOrGas(1000),
+                null,
+                200
+            );
+        
+        //LP-Hf
+        GT_Values.RA.addBlastRecipe(
+                GT_Utility.getIntegratedCircuit(2), 
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Magnesium, 2),
+                WerkstoffMaterialPool.HafniumTetrachlorideSolution.getFluidOrGas(1000), 
+                null, //No fluid output
+                WerkstoffMaterialPool.LowPurityHafnium.get(OrePrefixes.dust, 1),
+                GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Magnesiumchloride, 2), 
+                600, 1920, 2700
+            );
+        
+        //HfI4
+        GT_Values.RA.addChemicalRecipe(
+                GT_Utility.getIntegratedCircuit(1), 
+                WerkstoffMaterialPool.LowPurityHafnium.get(OrePrefixes.dust, 1),
+                WerkstoffMaterialPool.Iodine.getFluidOrGas(4000), 
+                null,
+                WerkstoffMaterialPool.HafniumIodide.get(OrePrefixes.dust, 1), 
+                300
+            );
+        
+        //Hf
+        GT_Values.RA.addBlastRecipe(
+                GT_Utility.getIntegratedCircuit(12), 
+                WerkstoffMaterialPool.HafniumIodide.get(OrePrefixes.dust, 1),
+                null, 
+                WerkstoffMaterialPool.Iodine.getFluidOrGas(4000),
+                WerkstoffMaterialPool.Hafnium.get(OrePrefixes.ingotHot, 1),
+                WerkstoffMaterialPool.HafniumRunoff.get(OrePrefixes.dustTiny, 1), 
+                600, 1920, 3400
+            );
+        
+        
+        //Zirconia-Hafnia
+        GT_Values.RA.addCentrifugeRecipe(
+                WerkstoffMaterialPool.HafniaZirconiaBlend.get(OrePrefixes.dust, 1), 
+                null, 
+                null, 
+                null,
+                WerkstoffMaterialPool.Hafnia.get(OrePrefixes.dust, 1), 
+                WerkstoffMaterialPool.Zirconia.get(OrePrefixes.dust, 1),
+                null, 
+                null, 
+                null, 
+                null, 
+                new int[] {10000, 10000}, 
+                600, 
+                1920
+            );
+        
+        
+        
+    }
+    
+    public static void loadLanthanideRecipes() {
+        
+    	removeCeriumSources();
+    	
+    	// Methanol
+        GT_Values.RA.addMultiblockChemicalRecipe(
+                new ItemStack[] {
+                	MyMaterial.vanadiumPentoxide.get(OrePrefixes.dustTiny, 0)
+                }, 
+                new FluidStack[] {
+                    Materials.Methanol.getFluid(1000),
+                    Materials.CarbonMonoxide.getFluid(2000),
+                    Materials.Oxygen.getFluid(3000)
+                }, 
+                new FluidStack[] {
+                	MyMaterial.oxalate.getFluidOrGas(1000)
+                	
+                },
+                null, 
+                450, 
+                600
+            );
+            
+        // Ethanol
+        GT_Values.RA.addMultiblockChemicalRecipe(
+                new ItemStack[] {
+                    MyMaterial.vanadiumPentoxide.get(OrePrefixes.dustTiny, 0)
+                }, 
+                new FluidStack[] {
+                    Materials.Ethanol.getFluid(1000),
+                    Materials.CarbonMonoxide.getFluid(3000),
+                    Materials.Oxygen.getFluid(3000)
+                }, 
+                new FluidStack[] {
+                	MyMaterial.oxalate.getFluidOrGas(1000)
+                },
+                null, 
+                450, 
+                600
+            );
+        
+        // CeCl3
+        GT_Values.RA.addChemicalRecipe(
+        		GT_Utility.getIntegratedCircuit(1),
+        		WerkstoffMaterialPool.CeriumDioxide.get(OrePrefixes.dust, 1),
+        		WerkstoffLoader.AmmoniumChloride.getFluidOrGas(3000),
+        		Materials.Ammonia.getFluid(3000),
+        		WerkstoffMaterialPool.CeriumChloride.get(OrePrefixes.dust, 1),
+        		300,
+        		450
+        	);
+        
+        //GT_Values.RA.addChemicalRecipe(
+        	//	GT_Utility.getIntegratedCircuit(2),
+        		//WerkstoffMaterialPool.CeriumDioxide
+        		//
+        		//)
+        
+        // Cerium Oxalate
+        GT_Values.RA.addChemicalRecipe(
+        		GT_Utility.getIntegratedCircuit(1),
+        		WerkstoffMaterialPool.CeriumChloride.get(OrePrefixes.dust, 2),
+        		MyMaterial.oxalate.getFluidOrGas(3000),
+        		Materials.HydrochloricAcid.getFluid(6000),
+        		WerkstoffMaterialPool.CeriumOxalate.get(OrePrefixes.dust, 1),
+        		300,
+        		450	
+        	);
+        
+        		
+        // Cerium III Oxide
+        GT_Values.RA.addBlastRecipe(
+        		GT_Utility.getIntegratedCircuit(1),
+        		WerkstoffMaterialPool.CeriumOxalate.get(OrePrefixes.dust, 1),
+        		null,
+        		Materials.Water.getFluid(2000),
+        		WerkstoffMaterialPool.CeriumIIIOxide.get(OrePrefixes.dust, 1),
+        		null,
+        		600,
+        		1920,
+        		1500
+        	);
+        
+        // Cerium
+        GT_Values.RA.addElectrolyzerRecipe(
+        		WerkstoffMaterialPool.CeriumIIIOxide.get(OrePrefixes.dust, 5),
+        		null,
+        		null,
+        		Materials.Oxygen.getFluid(3000),
+        		GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cerium, 2),
+        		null,
+        		null,
+        		null,
+        		null,
+        		null,
+        		new int[]{10000},
+        		150,
+        		120
+        	);
+        
+        
+        //CHAIN BEGIN
+        
+        RecipeAdder.instance.DigesterRecipes.addDigesterRecipe(
+        		new FluidStack[] {Materials.NitricAcid.getFluid(350)}, 
+        		new ItemStack[] {GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Monazite, 1)},
+        		WerkstoffMaterialPool.MuddyRareEarthSolution.getFluidOrGas(200), 
+        		new ItemStack[] {
+        			WerkstoffMaterialPool.HafniaZirconiaBlend.get(OrePrefixes.dustTiny, 4),
+        			Materials.SiliconDioxide.getDustSmall(2),
+        			WerkstoffLoader.Thorianit.get(OrePrefixes.dust, 1)
+        		},
+        		1920, 
+        		200, 
+        		2700
+        	);
+        
+        /*RecipeAdder.instance.DissolutionTankRecipes.addDissolutionTankRecipe(
+        		new FluidStack[] {
+        				Materials.Water.getFluid(10000), 
+        				WerkstoffMaterialPool.MuddyRareEarthSolution.getFluidOrGas(1000)
+        		},
+        		null,
+        		WerkstoffMaterialPool.DilutedRareEarthMud.getFluidOrGas(11000), 
+        		null, 
+        		480, 
+        		900
+        	);
+        */
+        GT_Recipe.GT_Recipe_Map.sSifterRecipes.addRecipe(
+        		false, 
+        		null, 
+        		new ItemStack[] {
+        				WerkstoffMaterialPool.MonaziteSulfate.get(OrePrefixes.dust, 1),
+        				Materials.SiliconDioxide.getDust(1),
+        				Materials.Rutile.getDust(1),
+        				WerkstoffLoader.RedZircon.get(OrePrefixes.dust, 1),
+        				Materials.Ilmenite.getDust(1)
+        		}, 
+        		null, 
+        		new int[] {
+        				7500, 1000, 500, 2000
+        		}, 
+        		new FluidStack[] {
+        				WerkstoffMaterialPool.DilutedRareEarthMud.getFluidOrGas(1000)
+        		},
+        		null, 
+        		400, 
+        		240, 
+        		0
+        	);
+        
+        
+        
+        
+        
+        
+        
+        		
+        		
+        		
+        		
+        	
+        
+        
+        
+        
+    }
+    
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+	private static void removeCeriumSources() {
+    	
+    	GT_Log.out.print(Tags.MODID + ": AAAAAA");
+    	
+    	HashSet<GT_Recipe> remove = new HashSet<>(5000);
+        HashSet<GT_Recipe> reAdd = new HashSet<>(5000);
+
+        //For Crusher
+        for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.mRecipeList) {
+            ItemStack input = recipe.mInputs[0];
+            if (GT_Utility.isStackValid(input)) {
+                int[] oreDict = OreDictionary.getOreIDs(input);
+                for (int oreDictID : oreDict) {
+                    if ((OreDictionary.getOreName(oreDictID).startsWith("ore") || OreDictionary.getOreName(oreDictID).startsWith("crushed")) && OreDictionary.getOreName(oreDictID).contains("Cerium")) {
+                        GT_Recipe tRecipe = recipe.copy();
+                        for (int i = 0; i < tRecipe.mOutputs.length; i ++) {
+                            if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                            if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1));
+                            }
+                        }
+                        if (!tRecipe.equals(recipe)){
+                            reAdd.add(tRecipe);
+                            remove.add(recipe);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.mRecipeList.removeAll(remove);
+        GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.mRecipeList.addAll(reAdd);
+        GT_Recipe.GT_Recipe_Map.sMaceratorRecipes.reInit();
+
+        GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Crusher done!\n");
+
+        //For Washer
+        for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sOreWasherRecipes.mRecipeList) {
+            ItemStack input = recipe.mInputs[0];
+            if (GT_Utility.isStackValid(input)) {
+                int[] oreDict = OreDictionary.getOreIDs(input);
+                for (int oreDictID : oreDict) {
+                    if (OreDictionary.getOreName(oreDictID).startsWith("crushed") && OreDictionary.getOreName(oreDictID).contains("Cerium")) {
+                        GT_Recipe tRecipe = recipe.copy();
+                        for (int i = 0; i < tRecipe.mOutputs.length; i ++) {
+                            if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                            if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1));
+                            }
+                        }
+                        if (!tRecipe.equals(recipe)){
+                            reAdd.add(tRecipe);
+                            remove.add(recipe);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        GT_Recipe.GT_Recipe_Map.sOreWasherRecipes.mRecipeList.removeAll(remove);
+        GT_Recipe.GT_Recipe_Map.sOreWasherRecipes.mRecipeList.addAll(reAdd);
+        GT_Recipe.GT_Recipe_Map.sOreWasherRecipes.reInit();
+
+        GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Washer done!\n");
+
+        //For Thermal Centrifuge
+        for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes.mRecipeList) {
+            ItemStack input = recipe.mInputs[0];
+            if (GT_Utility.isStackValid(input)) {
+                int[] oreDict = OreDictionary.getOreIDs(input);
+                for (int oreDictID : oreDict) {
+                    if (OreDictionary.getOreName(oreDictID).startsWith("crushed") && OreDictionary.getOreName(oreDictID).contains("Cerium")) {
+                        GT_Recipe tRecipe = recipe.copy();
+                        for (int i = 0; i < tRecipe.mOutputs.length; i ++) {
+                            if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                            if (tRecipe.mOutputs[i].isItemEqual(Materials.Naquadah.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, naquadahEarth.get(OrePrefixes.dust, 1));
+                            }
+                        }
+                        if (!tRecipe.equals(recipe)){
+                            reAdd.add(tRecipe);
+                            remove.add(recipe);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes.mRecipeList.removeAll(remove);
+        GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes.mRecipeList.addAll(reAdd);
+        GT_Recipe.GT_Recipe_Map.sThermalCentrifugeRecipes.reInit();
+
+        GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Thermal Centrifuge done!\n");
+
+        //For Centrifuge
+        for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.mRecipeList) {
+            ItemStack input = null;
+            if (recipe.mInputs.length > 0) input = recipe.mInputs[0];
+            if (GT_Utility.isStackValid(input)) {
+                int[] oreDict = OreDictionary.getOreIDs(input);
+                if (input.isItemEqual(GT_Bees.combs.getStackForType(CombType.DOB))){
+                    GT_Recipe tRecipe = recipe.copy();
+                    for (int i = 0; i < tRecipe.mOutputs.length; i ++) {
+                        if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                        if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDustTiny(1))) {
+                            tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dustTiny, 1));
+                        }
+                    }
+                    if (!tRecipe.equals(recipe)){
+                        reAdd.add(tRecipe);
+                        remove.add(recipe);
+                    }
+                }
+                else for (int oreDictID : oreDict) {
+                    if (OreDictionary.getOreName(oreDictID).startsWith("dustPureCerium") || OreDictionary.getOreName(oreDictID).startsWith("dustImpureCerium") || OreDictionary.getOreName(oreDictID).startsWith("dustSpace") || OreDictionary.getOreName(oreDictID).startsWith("dustCerium")) {
+                        GT_Recipe tRecipe = recipe.copy();
+                        for (int i = 0; i < tRecipe.mOutputs.length; i ++) {
+                            if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                            if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDustTiny(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dustTiny, 1));                         
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1));                         
+                            } else if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDustSmall(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dustSmall, 1));
+                            }
+                        }
+                        if (!tRecipe.equals(recipe)){
+                            reAdd.add(tRecipe);
+                            remove.add(recipe);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.mRecipeList.removeAll(remove);
+        GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.mRecipeList.addAll(reAdd);
+        GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes.reInit();
+
+        GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Centrifuge done!\n");
+
+        //For Hammer
+        for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sHammerRecipes.mRecipeList) {
+            ItemStack input = recipe.mInputs[0];
+            if (GT_Utility.isStackValid(input)) {
+                int[] oreDict = OreDictionary.getOreIDs(input);
+                for (int oreDictID : oreDict) {
+                    if (OreDictionary.getOreName(oreDictID).startsWith("crushed") && OreDictionary.getOreName(oreDictID).contains("Cerium")) {
+                        GT_Recipe tRecipe = recipe.copy();
+                        for (int i = 0; i < tRecipe.mOutputs.length; i ++) {
+                            if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                            if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize * 2, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1));                            
+                            }
+                        }
+                        if (!tRecipe.equals(recipe)){
+                            reAdd.add(tRecipe);
+                            remove.add(recipe);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        GT_Recipe.GT_Recipe_Map.sHammerRecipes.mRecipeList.removeAll(remove);
+        GT_Recipe.GT_Recipe_Map.sHammerRecipes.mRecipeList.addAll(reAdd);
+        GT_Recipe.GT_Recipe_Map.sHammerRecipes.reInit();
+
+        GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("Hammer done!\n");
+
+        if (LoadedList.GTPP) {
+            //For Multi Centrifuge
+            //Blame alk. She made some shit in it, NEI will break down if anyone modify the hash list directly.
+            GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT.mRecipeList.clear();
+            RecipeGen_MultisUsingFluidInsteadOfCells.generateRecipesNotUsingCells(GT_Recipe.GT_Recipe_Map.sCentrifugeRecipes, GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT);
+            GTPP_Recipe.GTPP_Recipe_Map.sMultiblockCentrifugeRecipes_GT.reInit();
+
+            //For Simple Washer
+            for (GT_Recipe recipe : GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes.mRecipeList) {
+                ItemStack input = recipe.mInputs[0];
+                if (GT_Utility.isStackValid(input)) {
+                    int[] oreDict = OreDictionary.getOreIDs(input);
+                    for (int oreDictID : oreDict) {
+                        if (OreDictionary.getOreName(oreDictID).startsWith("dustImpureCerium")) {
+                            GT_Recipe tRecipe = recipe.copy();
+                            for (int i = 0; i < tRecipe.mOutputs.length; i ++) {
+                                if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                                if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDust(1))) {
+                                    tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1));                               
+                                }
+                            }
+                            if (!tRecipe.equals(recipe)){
+                                reAdd.add(tRecipe);
+                                remove.add(recipe);
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+            GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes.mRecipeList.removeAll(remove);
+            GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes.mRecipeList.addAll(reAdd);
+            GTPP_Recipe.GTPP_Recipe_Map.sSimpleWasherRecipes.reInit();
+
+            GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! ");
+
+            remove.clear();
+            reAdd.clear();
+
+            GT_Log.out.print("Simple Washer done!\n");
+        }
+
+        //For ByProduct List
+        for (GT_Recipe recipe : GT_Recipe.GT_Recipe_Map.sByProductList.mRecipeList) {
+            ItemStack input = recipe.mInputs[0];
+            if (GT_Utility.isStackValid(input)) {
+                int[] oreDict = OreDictionary.getOreIDs(input);
+                for (int oreDictID : oreDict) {
+                    if (OreDictionary.getOreName(oreDictID).startsWith("ore") && OreDictionary.getOreName(oreDictID).contains("Cerium")) {
+                        GT_Recipe tRecipe = recipe.copy();
+                        for (int i = 0; i < tRecipe.mOutputs.length; i ++) {
+                            if (!GT_Utility.isStackValid(tRecipe.mOutputs[i])) continue;
+                            if (tRecipe.mOutputs[i].isItemEqual(Materials.Cerium.getDust(1))) {
+                                tRecipe.mOutputs[i] = GT_Utility.copyAmount(tRecipe.mOutputs[i].stackSize, WerkstoffMaterialPool.CeriumRichMixture.get(OrePrefixes.dust, 1));                            
+                            }
+                        }
+                        if (!tRecipe.equals(recipe)){
+                            reAdd.add(tRecipe);
+                            remove.add(recipe);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        GT_Recipe.GT_Recipe_Map.sByProductList.mRecipeList.removeAll(remove);
+        GT_Recipe.GT_Recipe_Map.sByProductList.mRecipeList.addAll(reAdd);
+        GT_Recipe.GT_Recipe_Map.sByProductList.reInit();
+
+        GT_Log.out.print(Tags.MODID + ": Replace " + remove.size() + "! ");
+
+        remove.clear();
+        reAdd.clear();
+
+        GT_Log.out.print("ByProduct List done!\n");
+    }
+}
+    
+    
+
diff --git a/src/main/java/com/elisis/gtnhlanth/util/DescTextLocalization.java b/src/main/java/com/elisis/gtnhlanth/util/DescTextLocalization.java
new file mode 100644
index 0000000000..fc01d37ec4
--- /dev/null
+++ b/src/main/java/com/elisis/gtnhlanth/util/DescTextLocalization.java
@@ -0,0 +1,18 @@
+package com.elisis.gtnhlanth.util;
+
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.StatCollector;
+
+public class DescTextLocalization {
+	
+	public static final String BLUEPRINT_INFO = "Follow the" + EnumChatFormatting.BLUE + " Structure" + EnumChatFormatting.DARK_BLUE + "Lib" + EnumChatFormatting.GRAY + " hologram projector to build the main structure.";
+
+	public static String[] addText(String preFix, int length){
+        String[] text = new String[length];
+        for (int i = 0; i < length; i ++) {
+            text[i] = StatCollector.translateToLocal(preFix + "." + i);
+        }
+        return text;
+    }
+	
+}