From b65ace37de4f585b8089ad413ee877b792da11ca Mon Sep 17 00:00:00 2001 From: NotAPenguin Date: Sat, 3 Aug 2024 23:21:44 +0200 Subject: Waterline rework (#2577) * Add barebones PurificationPlant class * Make simple 3x3 structure to form purification plant * Add base purification unit class and dummy sifter unit MTE * Make sifter unit form * Fix accidental wildcard import * Implement basic linking of units to controller using data stick * Make linking more robust, save bidirectional links, add scanner output * add linking range, error message and unregister old controller when re-linking * Add link status of purification units to waila body * Disable maintenance issues on purification plant units * spotless * Check structure of linked purification units in main controller * Remove all star imports * Small refactor to avoid updating status from main controller * spotless * Attempt to document current code * Convert some comments to javadoc * Implement basic processing cycle, sync it with linked purification units * Make water purification plant drain power * Calculate power drain from active units and remove controller power drain * spotless * Add very barebones recipemap * Fix recipemap name in lang file * spotless * Fix purification unit recipemap name * spotless * more sane amount of max fluid outputs * add some item outputs to sifter unit * Very simple recipe processing, may be buggy * spotless * Implement recipe failure * Implement void protection for purification units * spotless * buff item output odds slightly * Add WIP grade 1 structure * spotless * Store base success chance in recipe metadata and display it in NEI * Fill sifter plant with water * Add comment * Allow construction sifter unit in survival * Implement water boost * Fix water boost allowing output chance to go over 100% * Implement failed recipes outputting lower tier water * Fix typo * Fix deformed purification unit still drawing power * Slightly refactor recipe check so base class can read result * Create empty ModularUI container for purification plant * The great gui struggle part 1 * More gui struggles, we have a button now * Adjust button text and size * gui wars: the rise of the sync * gui wars: a new hope * fix the sync * is pengu old enough to know exceeder? * Fix being able to link the same unit multiple times * Sync status string to client * Sign sifter with my name * Show status somewhat properly * Adjust sifter base chance and structure * Fully implement sifter unit * More tooltip refactoring * Add structure info to sifter tooltip. * nitpicking tooltips * Adding sound to Purification Plant Main Unit. * fix star imports * Add basic coagulator unit, add recipemap for it * Write coagulator tooltip * comma nitpicking * more tooltip work * small refactor to purification plant controller * start work on custom recipemap frontend * Fully implement coagulator * Update structure requirements in tooltips * Move controller text in structure tooltips to be consistent * fix NPE on world load * Add base ph adjustment unit MTE * Add info to main controller and energy hatch check * Fixing tooltip of Main Controller & Energy/Exotic Hatch check. * Create full pH adjustment structure * disallow any voiding on purification unit * Small custom RecipeMap frontend for ph adjustment * Generate random initial pH value * Implement inserting NaOH and HCl to adjust pH * Add easter egg * Implement pH sensor hatch * Properly consume HCl and round pH value to 2 digits * Write ph adjustment unit tooltip * Tooltip nitpicking * Try to fix some structurelib hints * More trying to fix hints * Add industrial strength concrete casing block * Add water loop sound to the game * Document random initial pH in tooltip * Add glass material base * Fix spotless formatting in Textures docs because I cannot take it anymore * Add glass texture * Try adding transparent glass * Transparent glass working * Create pH resistant glass and update pH structure to use it * Create full structure for main purification plant * Create custom water purification casing block * Properly balance ferrous wastewater reprocessing and reduce input by a factor 10 * Add pH factor to NEI tooltip and fix coagulator structure * Structure tooltip for Purification Plant base * Add GT_Block_Glass2 and properly set maxMeta * Add Tinted Industrial Glass blocks * Fix BlockCasing9 not showing custom tooltip * Register tinted glass as EV glass * Add sterile water plant casing and revert tooltip change * Mention required water in sifter tooltip * Add more textures and casings * Add more textures, sounds and add structure info for pH adjustment * Rename sifter unit to clarifier * Rename coagulation unit to flocculation unit * Add activated carbon line * Fix unintended activated carbon recipe * Add activated carbon filter * Add polyaluminium chloride + solution * Add new custom textures by @BlueHero233 * Wip recipe page with new background for flocculation * Fix flocculation background image mostly * Finally aligned the slots * angery mumbles * Finish flocculation recipe page * All the recipe pages! * Add new reworked textures * Fix ph adjustment being t3 instead of t4 * Fix invisible casing * apply chembalance to polyaluminium chloride properly * Fix ferrous wastewater -> flocculation waste liquid * Move flocculation to grade 3 * create ozonation unit with placeholder blocks * add new blocks for ozonation with placeholder textures * Add water to ozonation structure * Create ozone gas material * Add ozone recipe * Add textures for ozone unit * Add sound loop for ozonation * fix * implement ozonation mechanics * Finalize ozonation tooltip * Create dummy plasma heater multi * Update textures for plasma heater * Add grade 5 recipemap * Add hatches to plasma heater multi * Add basic plasma heating unit variables * Implement plasma heating unit mechanics * Add plasma heater tooltip * Add structure info to plasma heater tooltip * fix ozonation tooltip, add frontend * Fix positioning on ozonation tooltip and fix plasma heater crash * Add UV treatment MTE and structure without textures * Revert accidental addition of debug dependencies * Add initial version of uv unit textures * update naquadria casing, add water color gradient * Some minor cleanup and added docs * Create lens housing bus * Add lens bus to UV treatment unit * Add lens indicator hatch * Merge GT_MetaGeneratedItem_03.java * Add lens indicator hatch * Add the lens cycle, uv treatment recipe map and fix eut of flocculation recipe * Implement lens swapping mechanic * Clean up first lens swap * Fix uv recipemap lang and move lens cycle to recipe * Write uv treatment tooltip * Add sounds for uv and plasma steps * Create empty degasifier class * Create temporary debug structure for degasifier * set temp casing index for degasifier * create degasifier control hatch * create slightly less temporary but still temporary structure for degasifier * Start impl of degasifier * fix fluid consumption and nbt loading of degasifier * Degasifier implementation should work now * Rename and reformat some things and start work on degasser tooltiop * give last bit much lower chance of being on to avoid cheesing * Finish degasifier tooltip * Integrate some deleno lore * hopefully fix all moved casing meta ids after merge * Create finalized degasser structure * Integrate more deleno lore * Add even more lore * Create placeholder particle catalysts and fetch particle items from gt++ * Fix wrong casing and recipemap localization * Create parallel config menu * refactor purification recipecheck slightly * implement parallel amount on water i/o and power * add tooltip info about parallel config * fix text * update block names in structure tooltips * create structure tooltip for degasser * create textureless quark catalyst items * add the purple glass * fix lore typos * fix some casing indices * remove concrete floor from water plant and reword tooltip * fix main plant structure and add placeholder structure for t8 step * fix structurecheck for main plant and add random catalyst generation for t8 * implement basic mechanics for particle extractor (wip) * Create plasma heater frontend * implement final mechanics and bugfixes for particle extractor * add recipes for re-aligning quark catalysts * add simple recipes for catalyst alignment * initial replacement of purified water in engraver recipes * add purified water to all wafer cutting recipes * fix purified water amounts * buff quark cyclotron recipe again * extract t8 unit casings into their own icons * Write initial tooltip for t8 module * add purified water to mask recipes * Add recipe comparator to show low tier purified water recipes first * add min casing check to waterline multis * buff ozone production * update t8 structure * make purified water optional again for naq wafers * Fix blockrenderer for purification plant * fix nei previews * fix nei * really fix nei this time * add t8 lore * fix hatch recipe locking blocking automation on some steps * try to solve weirdness with grade 3 recipe * fix issues with recipecheck * fix missing null check * make ph sensor use a strict inequality check * fix min casings on t5 * significantly nerf purified water usage for beamline masks * disable void protection for waterline * small adjustments to t6 unit * more small adjustments to t6 unit to prevent easy automation cheese * fix degasser redstone output and missing return statement * remove water QFT catalyst recipes --------- Co-authored-by: Tianyou Mei Co-authored-by: OlliedeLeeuw Co-authored-by: Ollie_de_Leeuw <154506304+OlliedeLeeuw@users.noreply.github.com> Co-authored-by: Martin Robertz --- .../loaders/oreprocessing/ProcessingCrafting.java | 65 ++--- .../loaders/postload/GT_MachineRecipeLoader.java | 2 + .../postload/chains/GT_PurifiedWaterRecipes.java | 263 +++++++++++++++++++++ .../loaders/postload/recipes/CuttingRecipes.java | 45 +++- .../preload/GT_Loader_Item_Block_And_Fluid.java | 4 + .../preload/GT_Loader_MetaTileEntities.java | 89 ++++++- 6 files changed, 429 insertions(+), 39 deletions(-) create mode 100644 src/main/java/gregtech/loaders/postload/chains/GT_PurifiedWaterRecipes.java (limited to 'src/main/java/gregtech/loaders') diff --git a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrafting.java b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrafting.java index 438da254a2..200ce743c9 100644 --- a/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrafting.java +++ b/src/main/java/gregtech/loaders/oreprocessing/ProcessingCrafting.java @@ -8,6 +8,7 @@ import static gregtech.api.recipe.RecipeMaps.laserEngraverRecipes; import static gregtech.api.util.GT_RecipeBuilder.MINUTES; import static gregtech.api.util.GT_RecipeBuilder.SECONDS; import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.WaferEngravingRecipes; import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; @@ -83,7 +84,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(60 * SECONDS) .eut(TierEU.RECIPE_HV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) @@ -91,7 +92,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(40 * SECONDS) .eut(TierEU.RECIPE_EV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer5.get(1), GT_Utility.copyAmount(0, aStack)) @@ -99,7 +100,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(2 * MINUTES) .eut(TierEU.RECIPE_UV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); } case "craftingLensYellow" -> { @@ -127,7 +128,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .itemOutputs(ItemList.Circuit_Wafer_LPIC.get(1)) .duration(40 * SECONDS) .eut(TierEU.RECIPE_MV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) @@ -135,7 +136,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(30 * SECONDS) .eut(TierEU.RECIPE_HV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) @@ -143,7 +144,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(45 * SECONDS) .eut(TierEU.RECIPE_EV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer4.get(1), GT_Utility.copyAmount(0, aStack)) @@ -151,7 +152,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(30 * SECONDS) .eut(TierEU.RECIPE_IV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer5.get(1), GT_Utility.copyAmount(0, aStack)) @@ -159,7 +160,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(15 * SECONDS) .eut(TierEU.RECIPE_LuV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); } case "craftingLensOrange" -> { @@ -168,28 +169,28 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .itemOutputs(ItemList.Circuit_Wafer_Simple_SoC.get(1)) .duration(15 * SECONDS) .eut(64) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) .itemOutputs(ItemList.Circuit_Wafer_Simple_SoC.get(4)) .duration(15 * SECONDS) .eut(256) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) .itemOutputs(ItemList.Circuit_Wafer_Simple_SoC.get(16)) .duration(15 * SECONDS) .eut(1024) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer4.get(1), GT_Utility.copyAmount(0, aStack)) .itemOutputs(ItemList.Circuit_Wafer_Simple_SoC.get(64)) .duration(15 * SECONDS) .eut(4096) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); } case "craftingLensCyan" -> { @@ -217,7 +218,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .itemOutputs(ItemList.Circuit_Wafer_Ram.get(1)) .duration(60 * SECONDS) .eut(TierEU.RECIPE_MV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) @@ -225,7 +226,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(45 * SECONDS) .eut(TierEU.RECIPE_HV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) @@ -233,7 +234,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(30 * SECONDS) .eut(TierEU.RECIPE_EV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer4.get(1), GT_Utility.copyAmount(0, aStack)) @@ -241,7 +242,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(15 * SECONDS) .eut(TierEU.RECIPE_IV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer5.get(1), GT_Utility.copyAmount(0, aStack)) @@ -249,7 +250,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(7 * SECONDS + 10 * TICKS) .eut(TierEU.RECIPE_LuV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); } case "craftingLensRed" -> { @@ -277,7 +278,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .itemOutputs(ItemList.Circuit_Wafer_ILC.get(1)) .duration(60 * SECONDS) .eut(TierEU.RECIPE_MV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) @@ -285,7 +286,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(45 * SECONDS) .eut(TierEU.RECIPE_HV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) @@ -293,7 +294,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(30 * SECONDS) .eut(TierEU.RECIPE_EV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer4.get(1), GT_Utility.copyAmount(0, aStack)) @@ -301,7 +302,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(1 * MINUTES + 30 * SECONDS) .eut(TierEU.RECIPE_LuV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer5.get(1), GT_Utility.copyAmount(0, aStack)) @@ -309,7 +310,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(1 * MINUTES + 15 * SECONDS) .eut(TierEU.RECIPE_ZPM) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); } case "craftingLensGreen" -> { @@ -335,14 +336,14 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .itemOutputs(ItemList.Circuit_Wafer_ULPIC.get(2)) .duration(30 * SECONDS) .eut(30) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) .itemOutputs(ItemList.Circuit_Wafer_ULPIC.get(8)) .duration(30 * SECONDS) .eut(TierEU.RECIPE_MV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) @@ -350,7 +351,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(1 * MINUTES + 30 * SECONDS) .eut(TierEU.RECIPE_EV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer4.get(1), GT_Utility.copyAmount(0, aStack)) @@ -358,7 +359,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(1 * MINUTES + 15 * SECONDS) .eut(TierEU.RECIPE_IV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer5.get(1), GT_Utility.copyAmount(0, aStack)) @@ -366,7 +367,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(60 * SECONDS) .eut(TierEU.RECIPE_LuV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); } case "craftingLensWhite" -> { @@ -424,7 +425,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(60 * SECONDS) .eut(TierEU.RECIPE_MV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer2.get(1), GT_Utility.copyAmount(0, aStack)) @@ -432,7 +433,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(45 * SECONDS) .eut(TierEU.RECIPE_HV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer3.get(1), GT_Utility.copyAmount(0, aStack)) @@ -440,7 +441,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(30 * SECONDS) .eut(TierEU.RECIPE_EV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer4.get(1), GT_Utility.copyAmount(0, aStack)) @@ -448,7 +449,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(15 * SECONDS) .eut(TierEU.RECIPE_IV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); GT_Values.RA.stdBuilder() .itemInputs(ItemList.Circuit_Silicon_Wafer5.get(1), GT_Utility.copyAmount(0, aStack)) @@ -456,7 +457,7 @@ public class ProcessingCrafting implements gregtech.api.interfaces.IOreRecipeReg .requiresCleanRoom() .duration(7 * SECONDS + 10 * TICKS) .eut(TierEU.RECIPE_LuV) - .addTo(laserEngraverRecipes); + .addTo(WaferEngravingRecipes); } } diff --git a/src/main/java/gregtech/loaders/postload/GT_MachineRecipeLoader.java b/src/main/java/gregtech/loaders/postload/GT_MachineRecipeLoader.java index 7280bccdff..92de5291e1 100644 --- a/src/main/java/gregtech/loaders/postload/GT_MachineRecipeLoader.java +++ b/src/main/java/gregtech/loaders/postload/GT_MachineRecipeLoader.java @@ -4,6 +4,7 @@ import gregtech.api.enums.Materials; import gregtech.loaders.postload.chains.GT_BauxiteRefineChain; import gregtech.loaders.postload.chains.GT_NaniteChain; import gregtech.loaders.postload.chains.GT_PCBFactoryRecipes; +import gregtech.loaders.postload.chains.GT_PurifiedWaterRecipes; import gregtech.loaders.postload.recipes.AlloySmelterRecipes; import gregtech.loaders.postload.recipes.ArcFurnaceRecipes; import gregtech.loaders.postload.recipes.AssemblerRecipes; @@ -120,5 +121,6 @@ public class GT_MachineRecipeLoader implements Runnable { GT_BauxiteRefineChain.run(); GT_NaniteChain.run(); GT_PCBFactoryRecipes.load(); + GT_PurifiedWaterRecipes.run(); } } diff --git a/src/main/java/gregtech/loaders/postload/chains/GT_PurifiedWaterRecipes.java b/src/main/java/gregtech/loaders/postload/chains/GT_PurifiedWaterRecipes.java new file mode 100644 index 0000000000..51cc15ae71 --- /dev/null +++ b/src/main/java/gregtech/loaders/postload/chains/GT_PurifiedWaterRecipes.java @@ -0,0 +1,263 @@ +package gregtech.loaders.postload.chains; + +import static com.github.bartimaeusnek.bartworks.system.material.WerkstoffLoader.FluorBuergerit; +import static gregtech.api.enums.MaterialsBotania.ManaDiamond; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.chemicalBathRecipes; +import static gregtech.api.recipe.RecipeMaps.distillationTowerRecipes; +import static gregtech.api.recipe.RecipeMaps.laserEngraverRecipes; +import static gregtech.api.recipe.RecipeMaps.multiblockChemicalReactorRecipes; +import static gregtech.api.recipe.RecipeMaps.plasmaForgeRecipes; +import static gregtech.api.recipe.RecipeMaps.purificationClarifierRecipes; +import static gregtech.api.recipe.RecipeMaps.purificationDegasifierRecipes; +import static gregtech.api.recipe.RecipeMaps.purificationFlocculationRecipes; +import static gregtech.api.recipe.RecipeMaps.purificationOzonationRecipes; +import static gregtech.api.recipe.RecipeMaps.purificationParticleExtractionRecipes; +import static gregtech.api.recipe.RecipeMaps.purificationPhAdjustmentRecipes; +import static gregtech.api.recipe.RecipeMaps.purificationPlasmaHeatingRecipes; +import static gregtech.api.recipe.RecipeMaps.purificationUVTreatmentRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeConstants.COIL_HEAT; +import static gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitParticleExtractor.BARYONIC_MATTER_OUTPUT; + +import java.util.Arrays; + +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import goodgenerator.items.MyMaterial; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.HeatingCoilLevel; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.recipe.metadata.PurificationPlantBaseChanceKey; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationPlant; +import gtPlusPlus.core.material.Particle; + +public class GT_PurifiedWaterRecipes { + + static final PurificationPlantBaseChanceKey BASE_CHANCE = PurificationPlantBaseChanceKey.INSTANCE; + + public static void run() { + final int duration = GT_MetaTileEntity_PurificationPlant.CYCLE_TIME_TICKS; + + // Grade 1 - Clarifier + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.ActivatedCarbonFilterMesh.get(1)) + .fluidInputs(GT_ModHandler.getDistilledWater(1000L)) + .fluidOutputs(Materials.Grade1PurifiedWater.getFluid(900L)) + .itemOutputs(new ItemStack(Items.stick, 1), Materials.Stone.getDust(1), Materials.Gold.getNuggets(1)) + .outputChances(1000, 500, 100) + .duration(duration) + .eut(TierEU.RECIPE_LuV) + .metadata(BASE_CHANCE, 70.0f) + .addTo(purificationClarifierRecipes); + + // Activated Carbon Line + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Carbon.getDust(1)) + .fluidInputs(Materials.PhosphoricAcid.getFluid(1000L)) + .itemOutputs(Materials.PreActivatedCarbon.getDust(1)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(multiblockChemicalReactorRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(Materials.PreActivatedCarbon.getDust(1)) + .itemOutputs(Materials.DirtyActivatedCarbon.getDust(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .specialValue((int) HeatingCoilLevel.EV.getHeat()) + .addTo(blastFurnaceRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(Materials.DirtyActivatedCarbon.getDust(1)) + .fluidInputs(Materials.Water.getFluid(1000L)) + .itemOutputs(Materials.ActivatedCarbon.getDust(1)) + .fluidOutputs(Materials.PhosphoricAcid.getFluid(1000L)) + .noOptimize() + .duration(2 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(chemicalBathRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + Materials.ActivatedCarbon.getDust(64), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Zinc, 16)) + .itemOutputs(ItemList.ActivatedCarbonFilterMesh.get(1)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + + // Grade 2 - Ozonation + for (ItemStack lens : GT_OreDictUnificator.getOres("craftingLensBlue")) { + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(0, lens)) + .noOptimize() + .fluidInputs(Materials.Air.getGas(10000L)) + .fluidOutputs(Materials.Ozone.getGas(2000L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(laserEngraverRecipes); + } + + // Recipes for ozonation, uses 128kL, 256kL, 512kL, 1m kL at each tier + // 20% boost per tier + // Gets you up to 80%, need to water boost for 95% + for (int tier = 1; tier <= 4; ++tier) { + GT_Values.RA.stdBuilder() + .noOptimize() + .fluidInputs( + Materials.Grade1PurifiedWater.getFluid(1000L), + Materials.Ozone.getGas(1000 * (long) Math.pow(2, (tier + 6)))) + .fluidOutputs(Materials.Grade2PurifiedWater.getFluid(900L)) + .itemOutputs(Materials.Manganese.getDust(1), Materials.Iron.getDust(1), Materials.Sulfur.getDust(1)) + .outputChances(500, 500, 500) + .duration(duration) + .ignoreCollision() + .eut(TierEU.RECIPE_LuV) + .metadata(BASE_CHANCE, tier * 20.0f) + .addTo(purificationOzonationRecipes); + } + + // Grade 3 - Flocculation. + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.Grade2PurifiedWater.getFluid(1000L)) + .fluidOutputs(Materials.Grade3PurifiedWater.getFluid(900L)) + .itemOutputs( + new ItemStack(Items.clay_ball, 1), + Materials.QuartzSand.getDust(1), + Materials.PolyvinylChloride.getNuggets(1)) + .outputChances(1000, 500, 100) + .duration(duration) + .eut(TierEU.RECIPE_ZPM) + .metadata(BASE_CHANCE, 1 * 10.0f) + .addTo(purificationFlocculationRecipes); + + // 2 Al(OH)3 + 3 HCl -> Al2(OH)3 Cl3 + 3 H2O + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Aluminiumhydroxide.getDust(8)) + .fluidInputs(Materials.HydrochloricAcid.getFluid(3000L)) + .fluidOutputs(Materials.PolyAluminiumChloride.getFluid(1000L), Materials.Water.getFluid(3000L)) + .duration(4 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(multiblockChemicalReactorRecipes); + + // Diluted is twice what chem balance would suggest, but it is 2:1 with hydrochloric acid which makes it + // correct I believe. + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.FlocculationWasteLiquid.getFluid(1000L)) + .itemOutputs(Materials.Aluminium.getDust(2)) + .fluidOutputs(Materials.Oxygen.getGas(3000L), Materials.DilutedHydrochloricAcid.getFluid(6000L)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(distillationTowerRecipes); + + // Grade 4 - pH adjustment + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.Grade3PurifiedWater.getFluid(1000L)) + .fluidOutputs(Materials.Grade4PurifiedWater.getFluid(900L)) + .ignoreCollision() + .duration(duration) + .eut(TierEU.RECIPE_ZPM) + .metadata(BASE_CHANCE, 0.0f) + .addTo(purificationPhAdjustmentRecipes); + + // Grade 5 - Plasma Heating + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.Grade4PurifiedWater.getFluid(1000L)) + .fluidOutputs(Materials.Grade5PurifiedWater.getFluid(900L)) + .ignoreCollision() + .duration(duration) + .eut(TierEU.RECIPE_UV) + .metadata(BASE_CHANCE, 0.0f) + .addTo(purificationPlasmaHeatingRecipes); + + // Grade 6 - UV treatment + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.Grade5PurifiedWater.getFluid(1000L)) + .fluidOutputs(Materials.Grade6PurifiedWater.getFluid(900L)) + // These are not actually consumed and are purely for display purposes + .special( + Arrays.asList( + MyMaterial.orundum.get(OrePrefixes.lens, 1), + GT_OreDictUnificator.get(OrePrefixes.lens, Materials.Amber, 1), + GT_OreDictUnificator.get(OrePrefixes.lens, Materials.InfusedAir, 1), + GT_OreDictUnificator.get(OrePrefixes.lens, Materials.Emerald, 1), + GT_OreDictUnificator.get(OrePrefixes.lens, ManaDiamond, 1), + GT_OreDictUnificator.get(OrePrefixes.lens, Materials.BlueTopaz, 1), + GT_OreDictUnificator.get(OrePrefixes.lens, Materials.Amethyst, 1), + FluorBuergerit.get(OrePrefixes.lens, 1), + GT_OreDictUnificator.get(OrePrefixes.lens, Materials.Dilithium, 1))) + .ignoreCollision() + .duration(duration) + .eut(TierEU.RECIPE_UV) + .metadata(BASE_CHANCE, 0.0f) + .addTo(purificationUVTreatmentRecipes); + + // Grade 7 - Degasification + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.Grade6PurifiedWater.getFluid(1000L)) + .fluidOutputs(Materials.Grade7PurifiedWater.getFluid(900L)) + .ignoreCollision() + .duration(duration) + .eut(TierEU.RECIPE_UHV) + .metadata(BASE_CHANCE, 0.0f) + .addTo(purificationDegasifierRecipes); + + // Grade 8 - Quark Extraction + + ItemStack[] catalystInputs = new ItemStack[] { ItemList.Quark_Creation_Catalyst_Up.get(1L), + ItemList.Quark_Creation_Catalyst_Down.get(1L), ItemList.Quark_Creation_Catalyst_Bottom.get(1L), + ItemList.Quark_Creation_Catalyst_Top.get(1L), ItemList.Quark_Creation_Catalyst_Strange.get(1L), + ItemList.Quark_Creation_Catalyst_Charm.get(1L) }; + + // Add re-alignment recipes + for (int i = 0; i < catalystInputs.length; ++i) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Quark_Creation_Catalyst_Unaligned.get(1), GT_Utility.getIntegratedCircuit(i + 1)) + .fluidInputs(Materials.StableBaryonicMatter.getFluid(1000L)) + .itemOutputs(catalystInputs[i]) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_UHV) + // Not sure how I feel about it being in the laser engraver, but I don't see a better multi for it right + // now, + // and we can't really add a new one specifically for this (... for now) + .addTo(laserEngraverRecipes); + } + + // Initial aligned quark catalysts, these are not meant to be done often, and simply exist to get you started + ItemStack[] quarks = new ItemStack[] { // make sure these are in the same order as the list above + Particle.getBaseParticle(Particle.UP), Particle.getBaseParticle(Particle.DOWN), + Particle.getBaseParticle(Particle.BOTTOM), Particle.getBaseParticle(Particle.TOP), + Particle.getBaseParticle(Particle.STRANGE), Particle.getBaseParticle(Particle.CHARM) }; + + for (int i = 0; i < catalystInputs.length; ++i) { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Quark_Catalyst_Housing.get(1), quarks[i]) + .fluidInputs(MaterialsUEVplus.ExcitedDTRC.getFluid(10000L)) + .itemOutputs(catalystInputs[i]) + .metadata(COIL_HEAT, 10800) + .eut(TierEU.RECIPE_UMV) + .duration(5 * MINUTES) + .addTo(plasmaForgeRecipes); + } + + GT_Values.RA.stdBuilder() + .fluidInputs(Materials.Grade7PurifiedWater.getFluid(1000L)) + .fluidOutputs( + Materials.Grade8PurifiedWater.getFluid(900L), + Materials.StableBaryonicMatter.getFluid(BARYONIC_MATTER_OUTPUT)) + .itemOutputs(ItemList.Quark_Creation_Catalyst_Unaligned.get(2L)) + .ignoreCollision() + .duration(duration) + .eut(TierEU.RECIPE_UEV) + .metadata(BASE_CHANCE, 0.0f) + .addTo(purificationParticleExtractionRecipes); + } +} diff --git a/src/main/java/gregtech/loaders/postload/recipes/CuttingRecipes.java b/src/main/java/gregtech/loaders/postload/recipes/CuttingRecipes.java index dd81fd2d66..1d0eeecd8b 100644 --- a/src/main/java/gregtech/loaders/postload/recipes/CuttingRecipes.java +++ b/src/main/java/gregtech/loaders/postload/recipes/CuttingRecipes.java @@ -49,22 +49,36 @@ public class CuttingRecipes implements Runnable { 1 * MINUTES + 20 * SECONDS, TierEU.RECIPE_HV, true); + // Naq wafer also gets recipes using purified water + recipeWithPurifiedWater( + new ItemStack[] { ItemList.Circuit_Silicon_Ingot3.get(1) }, + new ItemStack[] { ItemList.Circuit_Silicon_Wafer3.get(128), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SiliconSG, 16) }, + Materials.Grade1PurifiedWater, + Materials.Grade2PurifiedWater, + (int) ((1 * MINUTES + 20 * SECONDS) * 0.75), + (1 * MINUTES + 20 * SECONDS) / 2, + TierEU.RECIPE_HV); - recipeWithClassicFluids( + recipeWithPurifiedWater( new ItemStack[] { ItemList.Circuit_Silicon_Ingot4.get(1) }, new ItemStack[] { ItemList.Circuit_Silicon_Wafer4.get(64), ItemList.Circuit_Silicon_Wafer4.get(32), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SiliconSG, 32) }, + Materials.Grade3PurifiedWater, + Materials.Grade4PurifiedWater, 2 * MINUTES, - TierEU.RECIPE_EV, - true); + 1 * MINUTES, + TierEU.RECIPE_EV); - recipeWithClassicFluids( + recipeWithPurifiedWater( new ItemStack[] { ItemList.Circuit_Silicon_Ingot5.get(1) }, new ItemStack[] { ItemList.Circuit_Silicon_Wafer5.get(64), ItemList.Circuit_Silicon_Wafer5.get(64), GT_OreDictUnificator.get(OrePrefixes.dust, Materials.SiliconSG, 64) }, + Materials.Grade5PurifiedWater, + Materials.Grade6PurifiedWater, 2 * MINUTES + 40 * SECONDS, - TierEU.RECIPE_IV, - true); + (2 * MINUTES + 40 * SECONDS) / 2, + TierEU.RECIPE_IV); } @@ -225,6 +239,25 @@ public class CuttingRecipes implements Runnable { } + public void recipeWithPurifiedWater(ItemStack[] inputs, ItemStack[] outputs, Materials lowTierWater, + Materials highTierWater, int duration, int boostedDuration, long eut) { + GT_Values.RA.stdBuilder() + .itemInputs(inputs) + .itemOutputs(outputs) + .fluidInputs(lowTierWater.getFluid(100L)) + .duration(duration) + .eut(eut) + .addTo(cutterRecipes); + // Bonus for using higher tier water + GT_Values.RA.stdBuilder() + .itemInputs(inputs) + .itemOutputs(outputs) + .fluidInputs(highTierWater.getFluid(100L)) + .duration(boostedDuration) + .eut(eut) + .addTo(cutterRecipes); + } + public void recipeWithClassicFluids(ItemStack[] inputs, ItemStack[] outputs, int duration, long eut, boolean cleanroomRequired) { if (cleanroomRequired) { diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_Item_Block_And_Fluid.java b/src/main/java/gregtech/loaders/preload/GT_Loader_Item_Block_And_Fluid.java index 118baaf116..00ccea451e 100644 --- a/src/main/java/gregtech/loaders/preload/GT_Loader_Item_Block_And_Fluid.java +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_Item_Block_And_Fluid.java @@ -63,6 +63,7 @@ import gregtech.common.blocks.GT_Block_Casings8; import gregtech.common.blocks.GT_Block_Casings9; import gregtech.common.blocks.GT_Block_Concretes; import gregtech.common.blocks.GT_Block_Drone; +import gregtech.common.blocks.GT_Block_Glass1; import gregtech.common.blocks.GT_Block_Granites; import gregtech.common.blocks.GT_Block_Laser; import gregtech.common.blocks.GT_Block_Machines; @@ -70,6 +71,7 @@ import gregtech.common.blocks.GT_Block_Metal; import gregtech.common.blocks.GT_Block_Ores; import gregtech.common.blocks.GT_Block_Reinforced; import gregtech.common.blocks.GT_Block_Stones; +import gregtech.common.blocks.GT_Block_TintedIndustrialGlass; import gregtech.common.blocks.GT_Cyclotron_Coils; import gregtech.common.blocks.GT_TileEntity_Ores; import gregtech.common.items.GT_DepletetCell_Item; @@ -548,6 +550,8 @@ public class GT_Loader_Item_Block_And_Fluid implements Runnable { GregTech_API.sBlockStones = new GT_Block_Stones(); GregTech_API.sBlockOres1 = new GT_Block_Ores(); GregTech_API.sDroneRender = new GT_Block_Drone(); + GregTech_API.sBlockGlass1 = new GT_Block_Glass1(); + GregTech_API.sBlockTintedGlass = new GT_Block_TintedIndustrialGlass(); GregTech_API.sLaserRender = new GT_Block_Laser(); // meta ID order, DO NOT CHANGE ORDER diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java b/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java index c72459e9cf..9929fbb1c2 100644 --- a/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java @@ -121,6 +121,10 @@ import static gregtech.api.enums.MetaTileEntityIDs.GAS_TURBINE_HV; import static gregtech.api.enums.MetaTileEntityIDs.GAS_TURBINE_IV; import static gregtech.api.enums.MetaTileEntityIDs.GAS_TURBINE_LV; import static gregtech.api.enums.MetaTileEntityIDs.GAS_TURBINE_MV; +import static gregtech.api.enums.MetaTileEntityIDs.HATCH_DEGASIFIER_CONTROL; +import static gregtech.api.enums.MetaTileEntityIDs.HATCH_LENS_HOUSING; +import static gregtech.api.enums.MetaTileEntityIDs.HATCH_LENS_INDICATOR; +import static gregtech.api.enums.MetaTileEntityIDs.HATCH_PH_SENSOR; import static gregtech.api.enums.MetaTileEntityIDs.HIGH_PRESSURE_COAL_BOILER; import static gregtech.api.enums.MetaTileEntityIDs.HIGH_PRESSURE_LAVA_BOILER; import static gregtech.api.enums.MetaTileEntityIDs.HIGH_PRESSURE_SOLAR_BOILER; @@ -318,6 +322,15 @@ import static gregtech.api.enums.MetaTileEntityIDs.PUMP_HV; import static gregtech.api.enums.MetaTileEntityIDs.PUMP_IV; import static gregtech.api.enums.MetaTileEntityIDs.PUMP_LV; import static gregtech.api.enums.MetaTileEntityIDs.PUMP_MV; +import static gregtech.api.enums.MetaTileEntityIDs.PURIFICATION_PLANT_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.PURIFICATION_UNIT_CLARIFIER; +import static gregtech.api.enums.MetaTileEntityIDs.PURIFICATION_UNIT_DEGASIFIER; +import static gregtech.api.enums.MetaTileEntityIDs.PURIFICATION_UNIT_FLOCCULATOR; +import static gregtech.api.enums.MetaTileEntityIDs.PURIFICATION_UNIT_OZONATION; +import static gregtech.api.enums.MetaTileEntityIDs.PURIFICATION_UNIT_PARTICLE_EXTRACTOR; +import static gregtech.api.enums.MetaTileEntityIDs.PURIFICATION_UNIT_PH_ADJUSTMENT; +import static gregtech.api.enums.MetaTileEntityIDs.PURIFICATION_UNIT_PLASMA_HEATER; +import static gregtech.api.enums.MetaTileEntityIDs.PURIFICATION_UNIT_UV_TREATMENT; import static gregtech.api.enums.MetaTileEntityIDs.PYROLYSE_OVEN_CONTROLLER; import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_EV; import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_IV; @@ -591,6 +604,19 @@ import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_Transcenden import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_VacuumFreezer; import gregtech.common.tileentities.machines.multi.drone.GT_MetaTileEntity_DroneCentre; import gregtech.common.tileentities.machines.multi.drone.GT_MetaTileEntity_Hatch_DroneDownLink; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_Hatch_DegasifierControlHatch; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_LensHousing; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_LensIndicator; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationPlant; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitClarifier; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitDegasifier; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitFlocculation; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitOzonation; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitParticleExtractor; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitPhAdjustment; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitPlasmaHeater; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_PurificationUnitUVTreatment; +import gregtech.common.tileentities.machines.multi.purification.GT_MetaTileEntity_pHSensor; import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_AlloySmelter_Bronze; import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_AlloySmelter_Steel; import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Compressor_Bronze; @@ -850,7 +876,57 @@ public class GT_Loader_MetaTileEntities implements Runnable { // TODO CHECK CIRC DTPF_CONTROLLER.ID, "multimachine.plasmaforge", "Dimensionally Transcendent Plasma Forge").getStackForm(1L)); - + ItemList.Machine_Multi_PurificationPlant.set( + new GT_MetaTileEntity_PurificationPlant( + PURIFICATION_PLANT_CONTROLLER.ID, + "multimachine.purificationplant", + "Water Purification Plant").getStackForm(1L)); + ItemList.Machine_Multi_PurificationUnitClarifier.set( + new GT_MetaTileEntity_PurificationUnitClarifier( + PURIFICATION_UNIT_CLARIFIER.ID, + "multimachine.purificationunitclarifier", + "Clarifier Purification Unit").getStackForm(1L)); + ItemList.Machine_Multi_PurificationUnitFlocculator.set( + new GT_MetaTileEntity_PurificationUnitFlocculation( + PURIFICATION_UNIT_FLOCCULATOR.ID, + "multimachine.purificationunitflocculator", + "Flocculation Purification Unit").getStackForm(1L)); + ItemList.Machine_Multi_PurificationUnitPhAdjustment.set( + new GT_MetaTileEntity_PurificationUnitPhAdjustment( + PURIFICATION_UNIT_PH_ADJUSTMENT.ID, + "multimachine.purificationunitphadjustment", + "pH Neutralization Purification Unit").getStackForm(1L)); + ItemList.Machine_Multi_PurificationUnitOzonation.set( + new GT_MetaTileEntity_PurificationUnitOzonation( + PURIFICATION_UNIT_OZONATION.ID, + "multimachine.purificationunitozonation", + "Ozonation Purification Unit").getStackForm(1L)); + ItemList.Machine_Multi_PurificationUnitPlasmaHeater.set( + new GT_MetaTileEntity_PurificationUnitPlasmaHeater( + PURIFICATION_UNIT_PLASMA_HEATER.ID, + "multimachine.purificationunitplasmaheater", + "Extreme Temperature Fluctuation Purification Unit").getStackForm(1L)); + ItemList.Machine_Multi_PurificationUnitUVTreatment.set( + new GT_MetaTileEntity_PurificationUnitUVTreatment( + PURIFICATION_UNIT_UV_TREATMENT.ID, + "multimachine.purificationunituvtreatment", + "High Energy Laser Purification Unit").getStackForm(1L)); + ItemList.Machine_Multi_PurificationUnitDegasifier.set( + new GT_MetaTileEntity_PurificationUnitDegasifier( + PURIFICATION_UNIT_DEGASIFIER.ID, + "multimachine.purificationunitdegasifier", + "Residual Decontaminant Degasser Purification Unit").getStackForm(1L)); + ItemList.Machine_Multi_PurificationUnitParticleExtractor.set( + new GT_MetaTileEntity_PurificationUnitParticleExtractor( + PURIFICATION_UNIT_PARTICLE_EXTRACTOR.ID, + "multimachine.purificationunitextractor", + "Absolute Baryonic Perfection Purification Unit").getStackForm(1L)); + ItemList.Hatch_DegasifierControl.set( + new GT_MetaTileEntity_Hatch_DegasifierControlHatch( + HATCH_DEGASIFIER_CONTROL.ID, + "hatch.degasifiercontrol", + "Degasser Control Hatch", + 8).getStackForm(1L)); ItemList.Machine_Multi_LargeBoiler_Bronze.set( new GT_MetaTileEntity_LargeBoiler_Bronze( LARGE_BRONZE_BOILER_CONTROLLER.ID, @@ -4153,6 +4229,17 @@ public class GT_Loader_MetaTileEntities implements Runnable { // TODO CHECK CIRC "hatch.dataaccess.auto", "Automatable Data Access Hatch", 8).getStackForm(1L)); + ItemList.Hatch_pHSensor.set( + new GT_MetaTileEntity_pHSensor(HATCH_PH_SENSOR.ID, "hatch.phsensor", "pH Sensor Hatch", 7).getStackForm(1)); + ItemList.Hatch_LensHousing.set( + new GT_MetaTileEntity_LensHousing(HATCH_LENS_HOUSING.ID, "hatch.lenshousing", "Lens Housing") + .getStackForm(1L)); + ItemList.Hatch_LensIndicator.set( + new GT_MetaTileEntity_LensIndicator( + HATCH_LENS_INDICATOR.ID, + "hatch.lensindicator", + "Lens Indicator Hatch", + 8).getStackForm(1L)); generateWiresAndPipes(); } -- cgit