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/postload/GT_MachineRecipeLoader.java | 2 + .../postload/chains/GT_PurifiedWaterRecipes.java | 263 +++++++++++++++++++++ .../loaders/postload/recipes/CuttingRecipes.java | 45 +++- 3 files changed, 304 insertions(+), 6 deletions(-) create mode 100644 src/main/java/gregtech/loaders/postload/chains/GT_PurifiedWaterRecipes.java (limited to 'src/main/java/gregtech/loaders/postload') 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) { -- cgit