From 1b820de08a05070909a267e17f033fcf58ac8710 Mon Sep 17 00:00:00 2001 From: NotAPenguin Date: Mon, 2 Sep 2024 23:17:17 +0200 Subject: The Great Renaming (#3014) * move kekztech to a single root dir * move detrav to a single root dir * move gtnh-lanthanides to a single root dir * move tectech and delete some gross reflection in gt++ * remove more reflection inside gt5u * delete more reflection in gt++ * fix imports * move bartworks and bwcrossmod * fix proxies * move galactigreg and ggfab * move gtneioreplugin * try to fix gt++ bee loader * apply the rename rules to BW * apply rename rules to bwcrossmod * apply rename rules to detrav scanner mod * apply rename rules to galacticgreg * apply rename rules to ggfab * apply rename rules to goodgenerator * apply rename rules to gtnh-lanthanides * apply rename rules to gt++ * apply rename rules to kekztech * apply rename rules to kubatech * apply rename rules to tectech * apply rename rules to gt apply the rename rules to gt * fix tt import * fix mui hopefully * fix coremod except intergalactic * rename assline recipe class * fix a class name i stumbled on * rename StructureUtility to GTStructureUtility to prevent conflict with structurelib * temporary rename of GTTooltipDataCache to old name * fix gt client/server proxy names --- .../common/loaders/ArtificialMicaLine.java | 191 ++++++ .../bartworks/common/loaders/BioCultureLoader.java | 104 ++++ .../java/bartworks/common/loaders/BioItemList.java | 106 ++++ .../bartworks/common/loaders/BioLabLoader.java | 23 + .../bartworks/common/loaders/BioRecipeLoader.java | 211 +++++++ .../ElectricImplosionCompressorRecipes.java | 229 ++++++++ .../java/bartworks/common/loaders/FluidLoader.java | 145 +++++ .../bartworks/common/loaders/ItemRegistry.java | 654 +++++++++++++++++++++ .../common/loaders/LocalisationLoader.java | 62 ++ .../common/loaders/RadioHatchMaterialLoader.java | 365 ++++++++++++ .../bartworks/common/loaders/RecipeLoader.java | 59 ++ .../common/loaders/RegisterGlassTiers.java | 118 ++++ .../common/loaders/RegisterServerCommands.java | 34 ++ .../common/loaders/StaticRecipeChangeLoaders.java | 562 ++++++++++++++++++ .../common/loaders/recipes/Assembler.java | 270 +++++++++ .../common/loaders/recipes/AssemblyLine.java | 81 +++ .../common/loaders/recipes/Autoclave.java | 40 ++ .../common/loaders/recipes/Centrifuge.java | 141 +++++ .../common/loaders/recipes/ChemicalBath.java | 83 +++ .../common/loaders/recipes/ChemicalReactor.java | 28 + .../common/loaders/recipes/CraftingRecipes.java | 468 +++++++++++++++ .../common/loaders/recipes/Electrolyzer.java | 151 +++++ .../common/loaders/recipes/Extractor.java | 44 ++ .../common/loaders/recipes/FakeRecipes.java | 11 + .../common/loaders/recipes/FluidHeater.java | 26 + .../common/loaders/recipes/FluidSolidifier.java | 102 ++++ .../common/loaders/recipes/FormingPress.java | 76 +++ .../common/loaders/recipes/LaserEngraver.java | 27 + .../bartworks/common/loaders/recipes/Mixer.java | 62 ++ .../common/loaders/recipes/Pulverizer.java | 97 +++ .../common/loaders/recipes/PyrolyseOven.java | 27 + 31 files changed, 4597 insertions(+) create mode 100644 src/main/java/bartworks/common/loaders/ArtificialMicaLine.java create mode 100644 src/main/java/bartworks/common/loaders/BioCultureLoader.java create mode 100644 src/main/java/bartworks/common/loaders/BioItemList.java create mode 100644 src/main/java/bartworks/common/loaders/BioLabLoader.java create mode 100644 src/main/java/bartworks/common/loaders/BioRecipeLoader.java create mode 100644 src/main/java/bartworks/common/loaders/ElectricImplosionCompressorRecipes.java create mode 100644 src/main/java/bartworks/common/loaders/FluidLoader.java create mode 100644 src/main/java/bartworks/common/loaders/ItemRegistry.java create mode 100644 src/main/java/bartworks/common/loaders/LocalisationLoader.java create mode 100644 src/main/java/bartworks/common/loaders/RadioHatchMaterialLoader.java create mode 100644 src/main/java/bartworks/common/loaders/RecipeLoader.java create mode 100644 src/main/java/bartworks/common/loaders/RegisterGlassTiers.java create mode 100644 src/main/java/bartworks/common/loaders/RegisterServerCommands.java create mode 100644 src/main/java/bartworks/common/loaders/StaticRecipeChangeLoaders.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/Assembler.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/AssemblyLine.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/Autoclave.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/Centrifuge.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/ChemicalBath.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/ChemicalReactor.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/CraftingRecipes.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/Electrolyzer.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/Extractor.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/FakeRecipes.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/FluidHeater.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/FluidSolidifier.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/FormingPress.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/LaserEngraver.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/Mixer.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/Pulverizer.java create mode 100644 src/main/java/bartworks/common/loaders/recipes/PyrolyseOven.java (limited to 'src/main/java/bartworks/common/loaders') diff --git a/src/main/java/bartworks/common/loaders/ArtificialMicaLine.java b/src/main/java/bartworks/common/loaders/ArtificialMicaLine.java new file mode 100644 index 0000000000..4ec5f2edf8 --- /dev/null +++ b/src/main/java/bartworks/common/loaders/ArtificialMicaLine.java @@ -0,0 +1,191 @@ +package bartworks.common.loaders; + +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.recipe.RecipeMaps.benderRecipes; +import static gregtech.api.recipe.RecipeMaps.blastFurnaceRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes; +import static gregtech.api.recipe.RecipeMaps.mixerRecipes; +import static gregtech.api.recipe.RecipeMaps.vacuumFreezerRecipes; +import static gregtech.api.util.GTRecipeBuilder.SECONDS; +import static gregtech.api.util.GTRecipeBuilder.TICKS; +import static gregtech.api.util.GTRecipeConstants.COIL_HEAT; +import static gregtech.api.util.GTRecipeConstants.UniversalChemical; + +import bartworks.system.material.BWGTMaterialReference; +import bartworks.system.material.WerkstoffLoader; +import gregtech.api.enums.GTValues; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GTModHandler; +import gregtech.api.util.GTUtility; + +public class ArtificialMicaLine { + + public static void runArtificialMicaRecipe() { + // Mg + O = MgO + + GTValues.RA.stdBuilder() + .itemInputs(Materials.Magnesium.getDust(1)) + .itemOutputs(Materials.Magnesia.getDust(2)) + .fluidInputs(Materials.Oxygen.getGas(1000)) + .duration(2 * SECONDS) + .eut(8) + .addTo(UniversalChemical); + // Si + 6HF = H2SiF6 + 4H + + GTValues.RA.stdBuilder() + .itemInputs(Materials.Silicon.getDust(1), Materials.Empty.getCells(4)) + .itemOutputs(Materials.Hydrogen.getCells(4)) + .fluidInputs(Materials.HydrofluoricAcid.getFluid(6000)) + .fluidOutputs(WerkstoffLoader.HexafluorosilicicAcid.getFluidOrGas(1000)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(UniversalChemical); + // K + Cl = KCl + + GTValues.RA.stdBuilder() + .itemInputs(Materials.Potassium.getDust(1), GTUtility.getIntegratedCircuit(2)) + .itemOutputs(Materials.RockSalt.getDust(2)) + .fluidInputs(Materials.Chlorine.getGas(1000)) + .duration(20 * TICKS) + .eut(8) + .addTo(UniversalChemical); + + // 2KCl + H2SiF6 = 2HCl + K2SiF6 + GTValues.RA.stdBuilder() + .itemInputs(Materials.RockSalt.getDust(4)) + .itemOutputs(WerkstoffLoader.Potassiumfluorosilicate.get(OrePrefixes.dust, 9)) + .fluidInputs(WerkstoffLoader.HexafluorosilicicAcid.getFluidOrGas(1000)) + .fluidOutputs(Materials.HydrochloricAcid.getFluid(2000)) + .duration(1 * SECONDS) + .eut(8) + .addTo(mixerRecipes); + + // 2K + CO2 + O = K2CO3 + + GTValues.RA.stdBuilder() + .itemInputs(Materials.Potassium.getDust(2), Materials.CarbonDioxide.getCells(1)) + .itemOutputs(WerkstoffLoader.PotassiumCarbonate.get(OrePrefixes.dust, 6), Materials.Empty.getCells(1)) + .fluidInputs(Materials.Oxygen.getGas(1000)) + .duration(2 * SECONDS) + .eut(8) + .addTo(UniversalChemical); + // K2O + CO2 = K2CO3 + + GTValues.RA.stdBuilder() + .itemInputs(Materials.Potash.getDust(3), Materials.CarbonDioxide.getCells(1)) + .itemOutputs(WerkstoffLoader.PotassiumCarbonate.get(OrePrefixes.dust, 6), Materials.Empty.getCells(1)) + .duration(2 * SECONDS) + .eut(8) + .addTo(UniversalChemical); + + // 55Quartz Dust + 20K2SiF6 + 12Al2O3 + 4K2CO3 = 91Raw Fluorophlogopite Dust + GTValues.RA.stdBuilder() + .itemInputs( + Materials.QuartzSand.getDust(55), + WerkstoffLoader.Potassiumfluorosilicate.get(OrePrefixes.dust, 20), + WerkstoffLoader.Alumina.get(OrePrefixes.dust, 12), + WerkstoffLoader.PotassiumCarbonate.get(OrePrefixes.dust, 4), + GTUtility.getIntegratedCircuit(4)) + .itemOutputs( + WerkstoffLoader.RawFluorophlogopite.get(OrePrefixes.dust, 64), + WerkstoffLoader.RawFluorophlogopite.get(OrePrefixes.dust, 27)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(mixerRecipes); + + // 55Quartzite/Nether Quartz Dust + 20K2SiF6 + 57Al2O3 + 4K2CO3 = 136Raw Fluorophlogopite Dust + GTValues.RA.stdBuilder() + .itemInputs( + Materials.Quartzite.getDust(55), + WerkstoffLoader.Potassiumfluorosilicate.get(OrePrefixes.dust, 20), + WerkstoffLoader.Alumina.get(OrePrefixes.dust, 57), + WerkstoffLoader.PotassiumCarbonate.get(OrePrefixes.dust, 4), + GTUtility.getIntegratedCircuit(4)) + .itemOutputs( + WerkstoffLoader.RawFluorophlogopite.get(OrePrefixes.dust, 64), + WerkstoffLoader.RawFluorophlogopite.get(OrePrefixes.dust, 64), + WerkstoffLoader.RawFluorophlogopite.get(OrePrefixes.dust, 8)) + .fluidInputs() + .fluidOutputs() + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(mixerRecipes); + + GTValues.RA.stdBuilder() + .itemInputs( + Materials.NetherQuartz.getDust(55), + WerkstoffLoader.Potassiumfluorosilicate.get(OrePrefixes.dust, 20), + WerkstoffLoader.Alumina.get(OrePrefixes.dust, 57), + WerkstoffLoader.PotassiumCarbonate.get(OrePrefixes.dust, 4), + GTUtility.getIntegratedCircuit(4)) + .itemOutputs( + WerkstoffLoader.RawFluorophlogopite.get(OrePrefixes.dust, 64), + WerkstoffLoader.RawFluorophlogopite.get(OrePrefixes.dust, 64), + WerkstoffLoader.RawFluorophlogopite.get(OrePrefixes.dust, 8)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(mixerRecipes); + + // 62Certus Quartz Dust + 10K2SiF6 + 12Al2O3 + 7K2CO3 = 91Raw Fluorophlogopite Dust + GTValues.RA.stdBuilder() + .itemInputs( + Materials.CertusQuartz.getDust(62), + WerkstoffLoader.Potassiumfluorosilicate.get(OrePrefixes.dust, 10), + WerkstoffLoader.Alumina.get(OrePrefixes.dust, 12), + WerkstoffLoader.PotassiumCarbonate.get(OrePrefixes.dust, 7), + GTUtility.getIntegratedCircuit(4)) + .itemOutputs( + WerkstoffLoader.RawFluorophlogopite.get(OrePrefixes.dust, 64), + WerkstoffLoader.RawFluorophlogopite.get(OrePrefixes.dust, 27)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(mixerRecipes); + + // MgO(s) = MgO(l) + + GTValues.RA.stdBuilder() + .itemInputs(Materials.Magnesia.getDust(1)) + .fluidOutputs(Materials.Magnesia.getMolten(144)) + .duration(20 * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(fluidExtractionRecipes); + + // 27Raw Fluorophlogopite Dust + 720MgO(l) = 4608Fluorophlogopite(l) + GTValues.RA.stdBuilder() + .itemInputs(WerkstoffLoader.RawFluorophlogopite.get(OrePrefixes.dust, 27)) + .itemOutputs(Materials.Glass.getDust(1)) + .fluidInputs(BWGTMaterialReference.Magnesia.getMolten(720)) + .fluidOutputs(WerkstoffLoader.HotFluorophlogopite.getFluidOrGas(4608)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_HV) + .metadata(COIL_HEAT, 1700) + .addTo(blastFurnaceRecipes); + + // 144Fluorophlogopite(l) = Fluorophlogopite + GTValues.RA.stdBuilder() + .itemInputs(ItemList.Shape_Mold_Plate.get(0)) + .itemOutputs(WerkstoffLoader.Fluorophlogopite.get(OrePrefixes.plate, 1)) + .fluidInputs(WerkstoffLoader.HotFluorophlogopite.getFluidOrGas(144)) + .duration(10 * TICKS) + .eut(TierEU.RECIPE_MV) + .noOptimize() + .addTo(vacuumFreezerRecipes); + + // Fluorophlogopite = 4Insulator Foil + if (NewHorizonsCoreMod.isModLoaded()) { + + GTValues.RA.stdBuilder() + .itemInputs( + WerkstoffLoader.Fluorophlogopite.get(OrePrefixes.plate, 1), + GTUtility.getIntegratedCircuit(1)) + .itemOutputs(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MicaInsulatorFoil", 4)) + .duration(10 * TICKS) + .eut(600) + .addTo(benderRecipes); + + } + } +} diff --git a/src/main/java/bartworks/common/loaders/BioCultureLoader.java b/src/main/java/bartworks/common/loaders/BioCultureLoader.java new file mode 100644 index 0000000000..f97f23347f --- /dev/null +++ b/src/main/java/bartworks/common/loaders/BioCultureLoader.java @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +package bartworks.common.loaders; + +import java.awt.Color; + +import net.minecraft.item.EnumRarity; + +import bartworks.util.BioCulture; +import bartworks.util.BioDNA; +import bartworks.util.BioData; +import bartworks.util.BioPlasmid; + +public class BioCultureLoader { + + public static final BioData BIO_DATA_BETA_LACMATASE = BioData + .createAndRegisterBioData("beta-Lactamase", EnumRarity.uncommon, 10000, 0); + private static final BioData BIO_DATA_YEAST = BioData + .createAndRegisterBioData("Saccharomyces cerevisiae", EnumRarity.common); + private static final BioDNA BIO_DNA_WHINE_YEAST = BioDNA + .createAndRegisterBioDNA("Saccharomyces cerevisiae var bayanus", EnumRarity.uncommon); + private static final BioDNA BIO_DNA_BEER_YEAST = BioDNA + .createAndRegisterBioDNA("Saccharomyces cerevisiae var cerevisiae", EnumRarity.uncommon); + private static final BioData eColiData = BioData + .createAndRegisterBioData("Escherichia koli", EnumRarity.uncommon, 10000, 0); + private static final BioDNA BIO_DNA_ANAEROBIC_OIL = BioDNA + .createAndRegisterBioDNA("Pseudomonas Veronii", EnumRarity.uncommon); + private static final BioData BIO_DATA_ANAEROBIC_OIL = BioData + .createAndRegisterBioData("Pseudomonas Veronii", EnumRarity.uncommon, 5000, 1); + public static BioCulture CommonYeast; + public static BioCulture WhineYeast; + public static BioCulture BeerYeast; + public static BioCulture rottenFleshBacteria; + public static BioCulture eColi; + public static BioCulture anaerobicOil; + public static BioCulture generalPurposeFermentingBacteria; + + public static void run() { + BioCultureLoader.CommonYeast = BioCulture.createAndRegisterBioCulture( + new Color(255, 248, 200), + "Saccharomyces cerevisiae", + BioPlasmid.convertDataToPlasmid(BioCultureLoader.BIO_DATA_YEAST), + BioDNA.convertDataToDNA(BioCultureLoader.BIO_DATA_YEAST), + true); + BioCultureLoader.WhineYeast = BioCulture.createAndRegisterBioCulture( + new Color(255, 248, 200), + "Saccharomyces cerevisiae var bayanus", + BioPlasmid.convertDataToPlasmid(BioCultureLoader.BIO_DNA_WHINE_YEAST), + BioCultureLoader.BIO_DNA_WHINE_YEAST, + EnumRarity.uncommon, + true); + BioCultureLoader.BeerYeast = BioCulture.createAndRegisterBioCulture( + new Color(255, 248, 200), + "Saccharomyces cerevisiae var cerevisiae", + BioPlasmid.convertDataToPlasmid(BioCultureLoader.BIO_DNA_BEER_YEAST), + BioCultureLoader.BIO_DNA_BEER_YEAST, + EnumRarity.uncommon, + true); + BioCultureLoader.rottenFleshBacteria = BioCulture.createAndRegisterBioCulture( + new Color(110, 40, 25), + "Escherichia cadaver", + BioPlasmid.convertDataToPlasmid(BioCultureLoader.BIO_DATA_BETA_LACMATASE), + BioDNA.convertDataToDNA(BioCultureLoader.BIO_DATA_BETA_LACMATASE), + false); + BioCultureLoader.eColi = BioCulture.createAndRegisterBioCulture( + new Color(149, 132, 75), + "Escherichia koli", + BioPlasmid.convertDataToPlasmid(BioCultureLoader.eColiData), + BioDNA.convertDataToDNA(BioCultureLoader.eColiData), + true); + BioCultureLoader.anaerobicOil = BioCulture.createAndRegisterBioCulture( + new Color(0, 0, 0), + "Pseudomonas Veronii", + BioPlasmid.convertDataToPlasmid(BioCultureLoader.BIO_DNA_ANAEROBIC_OIL), + BioDNA.convertDataToDNA(BioCultureLoader.BIO_DATA_ANAEROBIC_OIL), + true); + BioCultureLoader.generalPurposeFermentingBacteria = BioCulture.createAndRegisterBioCulture( + new Color(127, 69, 26), + "Saccharomyces escherichia", + BioCultureLoader.CommonYeast.getPlasmid(), + BioCultureLoader.eColi.getdDNA(), + EnumRarity.epic, + true); + + BioCultureLoader.CommonYeast.setLocalisedName("Common Yeast"); + BioCultureLoader.WhineYeast.setLocalisedName("Whine Yeast"); + BioCultureLoader.BeerYeast.setLocalisedName("Beer Yeast"); + BioCultureLoader.rottenFleshBacteria.setLocalisedName("Rotten Flesh Bacteria"); + BioCultureLoader.eColi.setLocalisedName("eColi Bacteria"); + BioCultureLoader.anaerobicOil.setLocalisedName("Anaerobic Oil Bacteria"); + BioCultureLoader.generalPurposeFermentingBacteria.setLocalisedName("General Purpose Fermenting Bacteria"); + } +} diff --git a/src/main/java/bartworks/common/loaders/BioItemList.java b/src/main/java/bartworks/common/loaders/BioItemList.java new file mode 100644 index 0000000000..d845c5048d --- /dev/null +++ b/src/main/java/bartworks/common/loaders/BioItemList.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +package bartworks.common.loaders; + +import java.util.Collection; +import java.util.HashSet; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +import bartworks.common.items.ItemLabModule; +import bartworks.common.items.ItemLabParts; +import bartworks.util.BioCulture; +import bartworks.util.BioDNA; +import bartworks.util.BioData; +import bartworks.util.BioPlasmid; +import cpw.mods.fml.common.registry.GameRegistry; + +public class BioItemList { + + private BioItemList() {} + + private static final Item mItemBioLabParts = new ItemLabModule( + new String[] { "DNAExtractionModule", "PCRThermoclyclingModule", "PlasmidSynthesisModule", + "TransformationModule", "ClonalCellularSynthesisModule" }); + public static final ItemStack[] mBioLabParts = { new ItemStack(BioItemList.mItemBioLabParts), + new ItemStack(BioItemList.mItemBioLabParts, 1, 1), new ItemStack(BioItemList.mItemBioLabParts, 1, 2), + new ItemStack(BioItemList.mItemBioLabParts, 1, 3), new ItemStack(BioItemList.mItemBioLabParts, 1, 4) }; + private static final Item vanillaBioLabParts = new ItemLabParts( + new String[] { "petriDish", "DNASampleFlask", "PlasmidCell", "DetergentPowder", "Agarose", "IncubationModule", + "PlasmaMembrane" }); + + public static void registerBioItems() { + GameRegistry.registerItem(BioItemList.mItemBioLabParts, "BioLabModules"); + GameRegistry.registerItem(BioItemList.vanillaBioLabParts, "BioLabParts"); + } + + public static Collection getAllPetriDishes() { + HashSet ret = new HashSet<>(); + for (BioCulture Culture : BioCulture.BIO_CULTURE_ARRAY_LIST) { + ret.add(BioItemList.getPetriDish(Culture)); + } + return ret; + } + + public static Collection getAllDNASampleFlasks() { + HashSet ret = new HashSet<>(); + for (BioData dna : BioData.BIO_DATA_ARRAY_LIST) { + ret.add(BioItemList.getDNASampleFlask(BioDNA.convertDataToDNA(dna))); + } + return ret; + } + + public static Collection getAllPlasmidCells() { + HashSet ret = new HashSet<>(); + for (BioData dna : BioData.BIO_DATA_ARRAY_LIST) { + ret.add(BioItemList.getPlasmidCell(BioPlasmid.convertDataToPlasmid(dna))); + } + return ret; + } + + public static ItemStack getPetriDish(BioCulture Culture) { + if (Culture == null) return new ItemStack(BioItemList.vanillaBioLabParts); + ItemStack ret = new ItemStack(BioItemList.vanillaBioLabParts); + ret.setTagCompound(BioCulture.getNBTTagFromCulture(Culture)); + return ret; + } + + public static ItemStack getDNASampleFlask(BioDNA dna) { + if (dna == null) return new ItemStack(BioItemList.vanillaBioLabParts, 1, 1); + + ItemStack ret = new ItemStack(BioItemList.vanillaBioLabParts, 1, 1); + ret.setTagCompound(BioData.getNBTTagFromBioData(dna)); + return ret; + } + + public static ItemStack getPlasmidCell(BioPlasmid plasmid) { + if (plasmid == null) return new ItemStack(BioItemList.vanillaBioLabParts, 1, 2); + ItemStack ret = new ItemStack(BioItemList.vanillaBioLabParts, 1, 2); + ret.setTagCompound(BioData.getNBTTagFromBioData(plasmid)); + return ret; + } + + /** + * 1 - Detergent Powder 2 - Agarose 3 - Incubation Module 4 - Plasma Membrane others are null + * + * @param selection see above + * @return the selected Item + */ + public static ItemStack getOther(int selection) { + if (selection < 1 || selection > 4) return null; + + return new ItemStack(BioItemList.vanillaBioLabParts, 1, 2 + selection); + } +} diff --git a/src/main/java/bartworks/common/loaders/BioLabLoader.java b/src/main/java/bartworks/common/loaders/BioLabLoader.java new file mode 100644 index 0000000000..4a625ea33c --- /dev/null +++ b/src/main/java/bartworks/common/loaders/BioLabLoader.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +package bartworks.common.loaders; + +public class BioLabLoader { + + public static void run() { + FluidLoader.run(); + BioItemList.registerBioItems(); + BioRecipeLoader.run(); + } +} diff --git a/src/main/java/bartworks/common/loaders/BioRecipeLoader.java b/src/main/java/bartworks/common/loaders/BioRecipeLoader.java new file mode 100644 index 0000000000..77ae6b8c2c --- /dev/null +++ b/src/main/java/bartworks/common/loaders/BioRecipeLoader.java @@ -0,0 +1,211 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +package bartworks.common.loaders; + +import static bartworks.API.recipe.BartWorksRecipeMaps.bacterialVatRecipes; +import static bartworks.API.recipe.BartWorksRecipeMaps.bioLabRecipes; +import static gregtech.api.enums.Mods.CropsPlusPlus; +import static gregtech.api.util.GTRecipeBuilder.MINUTES; +import static gregtech.api.util.GTRecipeBuilder.SECONDS; +import static gregtech.api.util.GTRecipeBuilder.TICKS; +import static gregtech.api.util.GTRecipeConstants.SIEVERTS; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import gregtech.api.enums.GTValues; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.util.GTOreDictUnificator; +import gregtech.api.util.GTUtility; + +public class BioRecipeLoader { + + public static void run() { + registerWaterBasedBioLabIncubations(); + registerBacterialVatRecipes(); + } + + public static void registerWaterBasedBioLabIncubations() { + FluidStack[] easyFluids = { Materials.Water.getFluid(1000L), + FluidRegistry.getFluidStack("ic2distilledwater", 1000) }; + for (FluidStack fluidStack : easyFluids) { + + GTValues.RA.stdBuilder() + .itemInputs(BioItemList.getPetriDish(null), new ItemStack(Items.rotten_flesh)) + .itemOutputs(BioItemList.getPetriDish(BioCultureLoader.rottenFleshBacteria)) + .outputChances(33_00) + .fluidInputs(fluidStack) + .duration(25 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(bioLabRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(BioItemList.getPetriDish(null), new ItemStack(Items.fermented_spider_eye)) + .itemOutputs(BioItemList.getPetriDish(BioCultureLoader.eColi)) + .outputChances(45_00) + .fluidInputs(fluidStack) + .duration(25 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(bioLabRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(BioItemList.getPetriDish(null), ItemList.Food_Dough.get(1L)) + .itemOutputs(BioItemList.getPetriDish(BioCultureLoader.CommonYeast)) + .outputChances(75_00) + .fluidInputs(fluidStack) + .duration(25 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(bioLabRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(BioItemList.getPetriDish(null), ItemList.Food_Dough_Sugar.get(1L)) + .itemOutputs(BioItemList.getPetriDish(BioCultureLoader.WhineYeast)) + .outputChances(25_00) + .fluidInputs(fluidStack) + .duration(25 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(bioLabRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(BioItemList.getPetriDish(null), ItemList.Bottle_Wine.get(1L)) + .itemOutputs(BioItemList.getPetriDish(BioCultureLoader.WhineYeast)) + .outputChances(33_00) + .fluidInputs(fluidStack) + .duration(25 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(bioLabRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(BioItemList.getPetriDish(null), ItemList.Bottle_Beer.get(1L)) + .itemOutputs(BioItemList.getPetriDish(BioCultureLoader.BeerYeast)) + .outputChances(25_00) + .fluidInputs(fluidStack) + .duration(25 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(bioLabRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(BioItemList.getPetriDish(null), ItemList.Bottle_Dark_Beer.get(1L)) + .itemOutputs(BioItemList.getPetriDish(BioCultureLoader.BeerYeast)) + .outputChances(33_00) + .fluidInputs(fluidStack) + .duration(25 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(bioLabRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(BioItemList.getPetriDish(null), new ItemStack(Blocks.dirt)) + .itemOutputs(BioItemList.getPetriDish(BioCultureLoader.anaerobicOil)) + .outputChances(100) + .fluidInputs(fluidStack) + .duration(1 * MINUTES + 15 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(bioLabRecipes); + } + } + + public static void registerWaterBasedBacterialVatRecipes() { + FluidStack[] easyFluids = { Materials.Water.getFluid(1000L), + FluidRegistry.getFluidStack("ic2distilledwater", 1000) }; + for (FluidStack fluidStack : easyFluids) { + if (CropsPlusPlus.isModLoaded()) { + GTValues.RA.stdBuilder() + .itemInputs(GTUtility.getIntegratedCircuit(2), new ItemStack(Items.sugar, 64)) + .special(BioItemList.getPetriDish(BioCultureLoader.CommonYeast)) + .fluidInputs(new FluidStack(fluidStack, 100)) + .fluidOutputs(FluidRegistry.getFluidStack("potion.ghp", 1)) + .duration(17 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_EV) + .noOptimize() + .addTo(bacterialVatRecipes); + } + + GTValues.RA.stdBuilder() + .itemInputs(ItemList.Crop_Drop_Grapes.get(16)) + .special(BioItemList.getPetriDish(BioCultureLoader.WhineYeast)) + .fluidInputs(new FluidStack(fluidStack, 100)) + .fluidOutputs(FluidRegistry.getFluidStack("potion.wine", 12)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .noOptimize() + .addTo(bacterialVatRecipes); + + GTValues.RA.stdBuilder() + .itemInputs( + new ItemStack(Items.sugar, 4), + ItemList.IC2_Hops.get(16L), + GTOreDictUnificator.get(OrePrefixes.dust, Materials.Wheat, 8L)) + .special(BioItemList.getPetriDish(BioCultureLoader.BeerYeast)) + .fluidInputs(new FluidStack(fluidStack, 100)) + .fluidOutputs(FluidRegistry.getFluidStack("potion.beer", 5)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .noOptimize() + .addTo(bacterialVatRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(ItemList.IC2_Hops.get(32L), GTOreDictUnificator.get(OrePrefixes.dust, Materials.Wheat, 16L)) + .special(BioItemList.getPetriDish(BioCultureLoader.BeerYeast)) + .fluidInputs(new FluidStack(fluidStack, 100)) + .fluidOutputs(FluidRegistry.getFluidStack("potion.darkbeer", 10)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .noOptimize() + .addTo(bacterialVatRecipes); + } + } + + public static void registerBacterialVatRecipes() { + registerWaterBasedBacterialVatRecipes(); + + GTValues.RA.stdBuilder() + .special(BioItemList.getPetriDish(BioCultureLoader.WhineYeast)) + .fluidInputs(FluidRegistry.getFluidStack("potion.grapejuice", 100)) + .fluidOutputs(FluidRegistry.getFluidStack("potion.wine", 12)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .noOptimize() + .addTo(bacterialVatRecipes); + + GTValues.RA.stdBuilder() + .special(BioItemList.getPetriDish(BioCultureLoader.anaerobicOil)) + .fluidInputs(Materials.FermentedBiomass.getFluid(10000)) + .fluidOutputs(new FluidStack(FluidLoader.fulvicAcid, 1000)) + .duration(2 * MINUTES + 17 * SECONDS + 8 * TICKS) + .eut(TierEU.RECIPE_LV) + .noOptimize() + .addTo(bacterialVatRecipes); + } + + public static void runOnServerStarted() { + RecipeMaps.fermentingRecipes.getAllRecipes() + .forEach( + recipe -> GTValues.RA.stdBuilder() + .special(BioItemList.getPetriDish(BioCultureLoader.generalPurposeFermentingBacteria)) + .fluidInputs(recipe.mFluidInputs) + .fluidOutputs(recipe.mFluidOutputs) + .duration(recipe.mDuration) + .eut(recipe.mEUt) + .metadata(SIEVERTS, (int) GTUtility.getTier(recipe.mEUt)) + .addTo(bacterialVatRecipes)); + + } +} diff --git a/src/main/java/bartworks/common/loaders/ElectricImplosionCompressorRecipes.java b/src/main/java/bartworks/common/loaders/ElectricImplosionCompressorRecipes.java new file mode 100644 index 0000000000..9e1d896272 --- /dev/null +++ b/src/main/java/bartworks/common/loaders/ElectricImplosionCompressorRecipes.java @@ -0,0 +1,229 @@ +package bartworks.common.loaders; + +import static bartworks.API.recipe.BartWorksRecipeMaps.electricImplosionCompressorRecipes; +import static goodgenerator.loader.Loaders.highDensityPlutonium; +import static goodgenerator.loader.Loaders.highDensityPlutoniumNugget; +import static goodgenerator.loader.Loaders.highDensityThorium; +import static goodgenerator.loader.Loaders.highDensityThoriumNugget; +import static goodgenerator.loader.Loaders.highDensityUranium; +import static goodgenerator.loader.Loaders.highDensityUraniumNugget; +import static gregtech.api.enums.GTValues.M; +import static gregtech.api.enums.Mods.Avaritia; +import static gregtech.api.enums.Mods.EternalSingularity; +import static gregtech.api.enums.Mods.OpenComputers; +import static gregtech.api.enums.Mods.SuperSolarPanels; +import static gregtech.api.enums.Mods.UniversalSingularities; +import static gregtech.api.util.GTModHandler.getModItem; +import static gregtech.api.util.GTRecipeBuilder.MINUTES; +import static gregtech.api.util.GTRecipeBuilder.SECONDS; +import static gregtech.api.util.GTRecipeBuilder.TICKS; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GTValues; +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.util.GTOreDictUnificator; +import gregtech.api.util.GTUtility; + +public class ElectricImplosionCompressorRecipes implements Runnable { + + @Override + public void run() { + // Custom electric implosion compressor recipes. Cannot be overclocked. + + if (EternalSingularity.isModLoaded()) { + + GTValues.RA.stdBuilder() + .itemOutputs(getModItem(EternalSingularity.ID, "eternal_singularity", 1L)) + .fluidInputs(MaterialsUEVplus.SpaceTime.getMolten(72L)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_UMV) + .noOptimize() + .addTo(electricImplosionCompressorRecipes); + + if (UniversalSingularities.isModLoaded()) { + // Raw Exposed Optical Chip + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Circuit_Silicon_Wafer7.get(1L), + // Fluxed Electrum Singularity. + getModItem(UniversalSingularities.ID, "universal.general.singularity", 1L, 20)) + .itemOutputs(ItemList.Circuit_Chip_Optical.get(16L)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_UMV) + .noOptimize() + .addTo(electricImplosionCompressorRecipes); + + GTValues.RA.stdBuilder() + .itemInputs( + // fluxed electrum singularity + getModItem(UniversalSingularities.ID, "universal.general.singularity", 1L, 20)) + .fluidInputs(MaterialsUEVplus.Mellion.getMolten(4 * 144L)) + // spaghettic singularity + .itemOutputs(getModItem(EternalSingularity.ID, "combined_singularity", 1L, 2)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_UMV) + .addTo(electricImplosionCompressorRecipes); + + GTValues.RA.stdBuilder() + .itemInputs( + // iron singularity + getModItem(Avaritia.ID, "Singularity", 1L, 0)) + .fluidInputs(MaterialsUEVplus.Creon.getMolten(4 * 144L)) + // cryptic singularity + .itemOutputs(getModItem(EternalSingularity.ID, "combined_singularity", 1L, 4)) + .duration(1 * SECONDS) + .eut(TierEU.RECIPE_UMV) + .addTo(electricImplosionCompressorRecipes); + } + } + + GTValues.RA.stdBuilder() + .itemInputs(new ItemStack(highDensityPlutoniumNugget, 5)) + .itemOutputs(new ItemStack(highDensityPlutonium, 1)) + .fluidInputs(Materials.Neutronium.getMolten(72L)) + .duration(1) + .eut(TierEU.RECIPE_UEV) + .noOptimize() + .addTo(electricImplosionCompressorRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(new ItemStack(highDensityUraniumNugget, 5)) + .itemOutputs(new ItemStack(highDensityUranium, 1)) + .fluidInputs(Materials.Neutronium.getMolten(72L)) + .duration(1) + .eut(TierEU.RECIPE_UEV) + .noOptimize() + .addTo(electricImplosionCompressorRecipes); + + GTValues.RA.stdBuilder() + .itemInputs(new ItemStack(highDensityThoriumNugget, 5)) + .itemOutputs(new ItemStack(highDensityThorium, 1)) + .fluidInputs(Materials.Neutronium.getMolten(72L)) + .duration(1) + .eut(TierEU.RECIPE_UEV) + .noOptimize() + .addTo(electricImplosionCompressorRecipes); + + // Magneto material recipe for base fluid. + GTValues.RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.nanite, MaterialsUEVplus.WhiteDwarfMatter, 1L), + GTOreDictUnificator.get(OrePrefixes.nanite, MaterialsUEVplus.Universium, 1L), + GTOreDictUnificator.get(OrePrefixes.nanite, MaterialsUEVplus.BlackDwarfMatter, 1L)) + .fluidInputs(MaterialsUEVplus.RawStarMatter.getFluid(64 * 144L)) + .fluidOutputs(MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter.getMolten(16 * 144L)) + .duration(4 * SECONDS) + .eut(TierEU.RECIPE_UXV) + .noOptimize() + .addTo(electricImplosionCompressorRecipes); + + // Infinity Catalyst + GTValues.RA.stdBuilder() + .itemInputs(GTOreDictUnificator.get(OrePrefixes.dust, Materials.InfinityCatalyst, 64L)) + .itemOutputs(getModItem(Avaritia.ID, "Resource", 1L, 5)) + .duration(1) + .eut(TierEU.RECIPE_UIV) + .noOptimize() + .addTo(electricImplosionCompressorRecipes); + + if (UniversalSingularities.isModLoaded()) { + // Fluxed Singularity + GTValues.RA.stdBuilder() + .itemInputs(GTOreDictUnificator.get(OrePrefixes.block, Materials.ElectrumFlux, 16L)) + .itemOutputs(getModItem(UniversalSingularities.ID, "universal.general.singularity", 1L, 20)) + .duration(1) + .eut(TierEU.RECIPE_UIV) + .noOptimize() + .addTo(electricImplosionCompressorRecipes); + + // Iron Singularity + GTValues.RA.stdBuilder() + .itemOutputs(getModItem(Avaritia.ID, "Singularity", 1L, 0)) + .fluidInputs(Materials.Iron.getMolten(7296 * 9 * 144L)) + .duration(1) + .eut(TierEU.RECIPE_UIV) + .noOptimize() + .addTo(electricImplosionCompressorRecipes); + + // Copper Singularity + GTValues.RA.stdBuilder() + .fluidInputs(Materials.Copper.getMolten(3648 * 9 * 144L)) + .itemOutputs(getModItem(Avaritia.ID, "Singularity", 1L, 5)) + .duration(1 * TICKS) + .eut(TierEU.RECIPE_UIV) + .addTo(electricImplosionCompressorRecipes); + + ItemStack diamondBlocks = GTUtility + .copyAmountUnsafe(729, GTOreDictUnificator.get(OrePrefixes.block, Materials.Diamond, 1L)); + // Diamond Singularity + GTValues.RA.stdBuilder() + .itemInputs(diamondBlocks) + .itemOutputs(getModItem(UniversalSingularities.ID, "universal.vanilla.singularity", 1L, 2)) + .duration(1 * TICKS) + .eut(TierEU.RECIPE_UIV) + .addTo(electricImplosionCompressorRecipes); + } + // MHDCSM V2 + GTValues.RA.stdBuilder() + .itemInputs(MaterialsUEVplus.Eternity.getNanite(1), MaterialsUEVplus.Universium.getNanite(1)) + .fluidInputs(MaterialsUEVplus.RawStarMatter.getFluid(128 * 144L)) + .fluidOutputs(MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter.getMolten(32 * 144L)) + .duration(4 * SECONDS) + .eut(TierEU.RECIPE_MAX) + .noOptimize() + .addTo(electricImplosionCompressorRecipes); + + this.addMagnetohydrodynamicallyConstrainedStarMatterPartRecipes(); + } + + private void addMagnetohydrodynamicallyConstrainedStarMatterPartRecipes() { + + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.frameGt, 1, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.nugget, 9, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.ingot, 1, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.plate, 1, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.plateDense, 1, 3); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.stick, 2, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.round, 8, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.bolt, 8, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.screw, 8, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.ring, 4, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.foil, 8, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.itemCasing, 2, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.gearGtSmall, 1, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.rotor, 1, 2); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.stickLong, 1, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.springSmall, 2, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.spring, 1, 1); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.gearGt, 1, 2); + this.addWhiteDwarfMagnetoEICRecipe(OrePrefixes.wireFine, 8, 1); + } + + private void addWhiteDwarfMagnetoEICRecipe(final OrePrefixes part, final int multiplier, + final int circuitMultiplier) { + + final int partFraction = (int) (144 * part.mMaterialAmount / M); + + GTValues.RA.stdBuilder() + .itemInputs( + new Object[] { OrePrefixes.circuit.get(Materials.UHV), circuitMultiplier }, + getModItem(SuperSolarPanels.ID, "solarsplitter", 1, 0), + getModItem(OpenComputers.ID, "hologram2", circuitMultiplier, 0), + GTOreDictUnificator.get(part, MaterialsUEVplus.Eternity, multiplier)) + .itemOutputs( + GTOreDictUnificator + .get(part, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, multiplier)) + .fluidInputs( + MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter + .getMolten((long) partFraction * multiplier)) + .duration((int) (multiplier * (20 * partFraction / 144.0))) + .eut(TierEU.RECIPE_UXV) + .noOptimize() + .addTo(electricImplosionCompressorRecipes); + } +} diff --git a/src/main/java/bartworks/common/loaders/FluidLoader.java b/src/main/java/bartworks/common/loaders/FluidLoader.java new file mode 100644 index 0000000000..b5f8283aa0 --- /dev/null +++ b/src/main/java/bartworks/common/loaders/FluidLoader.java @@ -0,0 +1,145 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +package bartworks.common.loaders; + +import static gregtech.api.enums.Mods.Gendustry; +import static gregtech.api.enums.Mods.GregTech; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.util.GTRecipeBuilder.SECONDS; + +import java.awt.Color; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import bartworks.API.SideReference; +import bartworks.client.renderer.RendererGlassBlock; +import bartworks.client.renderer.RendererSwitchingColorFluid; +import bartworks.common.blocks.BlockBioFluid; +import bartworks.common.tileentities.classic.TileEntityDimIDBridge; +import bartworks.util.BioCulture; +import cpw.mods.fml.client.registry.RenderingRegistry; +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.GregTechAPI; +import gregtech.api.enums.FluidState; +import gregtech.api.enums.GTValues; +import gregtech.api.enums.Materials; +import gregtech.api.enums.TierEU; +import gregtech.api.fluid.GTFluidFactory; +import gregtech.api.util.GTUtility; +import gregtech.common.items.MetaGeneratedItem98; + +public class FluidLoader { + + public static IIcon autogenIIcon; + public static Fluid ff; + public static int renderID; + public static Block bioFluidBlock; + public static Fluid[] BioLabFluidMaterials; + public static ItemStack[] BioLabFluidCells; + + // OilProcessing chain + public static Fluid fulvicAcid, heatedfulvicAcid, Kerogen; + + public static void run() { + renderID = RenderingRegistry.getNextAvailableRenderId(); + ff = new Fluid("BWfakeFluid"); + GregTechAPI.sGTBlockIconload.add( + () -> ff.setIcons( + GregTechAPI.sBlockIcons + .registerIcon(GregTech.getResourcePath("fluids", "fluid.molten.autogenerated")))); + fulvicAcid = createAndRegisterFluid("Fulvic Acid", new Color(20, 20, 20)); + heatedfulvicAcid = createAndRegisterFluid("Heated Fulvic Acid", new Color(40, 20, 20), 720); + Kerogen = createAndRegisterFluid("Kerogen", new Color(85, 85, 85)); + BioLabFluidMaterials = new Fluid[] { createAndRegisterFluid("FluorecentdDNA", new Color(125, 50, 170)), + createAndRegisterFluid("EnzymesSollution", new Color(240, 200, 125)), + createAndRegisterFluid("Penicillin", new Color(255, 255, 255)), + createAndRegisterFluid("Polymerase", new Color(110, 180, 110)) }; + + BioLabFluidCells = new ItemStack[BioLabFluidMaterials.length]; + + MetaGeneratedItem98.FluidCell[] fluidCells = { MetaGeneratedItem98.FluidCell.FLUORESCENT_DNA, + MetaGeneratedItem98.FluidCell.ENZYME_SOLUTION, MetaGeneratedItem98.FluidCell.PENICILLIN, + MetaGeneratedItem98.FluidCell.POLYMERASE, }; + for (int i = 0; i < fluidCells.length; i++) { + BioLabFluidCells[i] = fluidCells[i].get(); + } + + FluidStack dnaFluid = Gendustry.isModLoaded() ? FluidRegistry.getFluidStack("liquiddna", 100) + : Materials.Biomass.getFluid(100L); + for (BioCulture B : BioCulture.BIO_CULTURE_ARRAY_LIST) { + if (B.isBreedable()) { + B.setFluid( + GTFluidFactory.builder( + B.getName() + .replace(" ", "") + .toLowerCase() + "fluid") + .withTextureName("molten.autogenerated") + .withColorRGBA( + new short[] { (short) B.getColor() + .getRed(), + (short) B.getColor() + .getBlue(), + (short) B.getColor() + .getGreen() }) + .withLocalizedName(B.getLocalisedName() + " Fluid") + .withStateAndTemperature(FluidState.LIQUID, 300) + .buildAndRegister() + .asFluid()); + + GTValues.RA.stdBuilder() + .itemInputs(GTUtility.getIntegratedCircuit(10)) + .fluidInputs(new FluidStack(B.getFluid(), 1000)) + .fluidOutputs(dnaFluid) + .duration(25 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(centrifugeRecipes); + } + } + + bioFluidBlock = new BlockBioFluid(); + GameRegistry.registerBlock(bioFluidBlock, "coloredFluidBlock"); + GameRegistry.registerTileEntity(TileEntityDimIDBridge.class, "bwTEDimIDBridge"); + if (SideReference.Side.Client) { + RendererSwitchingColorFluid.register(); + RendererGlassBlock.register(); + } + } + + public static Fluid createAndRegisterFluid(String Name, Color color) { + return GTFluidFactory.builder(Name) + .withTextureName("molten.autogenerated") + .withColorRGBA( + new short[] { (short) color.getRed(), (short) color.getGreen(), (short) color.getBlue(), + (short) color.getAlpha() }) + .withStateAndTemperature(FluidState.LIQUID, 300) + .buildAndRegister() + .asFluid(); + } + + public static Fluid createAndRegisterFluid(String Name, Color color, int temperature) { + return GTFluidFactory.builder(Name) + .withTextureName("molten.autogenerated") + .withColorRGBA( + new short[] { (short) color.getRed(), (short) color.getGreen(), (short) color.getBlue(), + (short) color.getAlpha() }) + .withStateAndTemperature(FluidState.LIQUID, temperature) + .buildAndRegister() + .asFluid(); + } +} diff --git a/src/main/java/bartworks/common/loaders/ItemRegistry.java b/src/main/java/bartworks/common/loaders/ItemRegistry.java new file mode 100644 index 0000000000..4cf95866a1 --- /dev/null +++ b/src/main/java/bartworks/common/loaders/ItemRegistry.java @@ -0,0 +1,654 @@ +/* + * Copyright (c) 2018-2020 bartimaeusnek Permission is hereby granted, free of charge, to any person obtaining a copy of + * this software and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: The above copyright notice and this permission notice shall be included in all copies or substantial + * portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, + * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +package bartworks.common.loaders; + +import static gregtech.api.enums.MetaTileEntityIDs.AcidGeneratorEV; +import static gregtech.api.enums.MetaTileEntityIDs.AcidGeneratorHV; +import static gregtech.api.enums.MetaTileEntityIDs.AcidGeneratorLV; +import static gregtech.api.enums.MetaTileEntityIDs.AcidGeneratorMV; +import static gregtech.api.enums.MetaTileEntityIDs.CircuitAssemblyLine; +import static gregtech.api.enums.MetaTileEntityIDs.CompressedFluidHatch; +import static gregtech.api.enums.MetaTileEntityIDs.DeepEarthHeatingPump; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_EV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_HV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_IV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_LV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_MAX; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_MV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_UEV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_UIV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_UMV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_UV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_UXV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode12A_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_EV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_HV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_IV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_LV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_MAX; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_MV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_UEV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_UIV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_UMV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_UV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_UXV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode16A_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_EV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_HV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_IV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_LV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_MAX; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_MV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_UEV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_UIV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_UMV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_UV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_UXV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode2A_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_EV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_HV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_IV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_LV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_MAX; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_MV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_UEV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_UIV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_UMV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_UV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_UXV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode4A_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_EV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_HV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_IV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_LV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_MAX; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_MV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_UEV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_UIV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_UMV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_UV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_UXV; +import static gregtech.api.enums.MetaTileEntityIDs.Diode8A_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.ElectricImplosionCompressor; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_EV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_HV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_IV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_LV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_MAX; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_MV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_UEV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_UIV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_UMV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_UV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_UXV; +import static gregtech.api.enums.MetaTileEntityIDs.EnergyDistributor_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.GiantOutputH