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 --- src/main/java/tectech/loader/MainLoader.java | 206 ++ .../java/tectech/loader/NetworkDispatcher.java | 25 + src/main/java/tectech/loader/TecTechConfig.java | 271 ++ .../tectech/loader/gui/CreativeTabTecTech.java | 36 + src/main/java/tectech/loader/recipe/Assembler.java | 3091 ++++++++++++++++ .../java/tectech/loader/recipe/AssemblyLine.java | 169 + .../tectech/loader/recipe/BaseRecipeLoader.java | 49 + .../tectech/loader/recipe/CircuitAssembler.java | 54 + src/main/java/tectech/loader/recipe/Crafting.java | 57 + src/main/java/tectech/loader/recipe/Extractor.java | 67 + src/main/java/tectech/loader/recipe/Godforge.java | 675 ++++ .../loader/recipe/ResearchStationAssemblyLine.java | 3709 ++++++++++++++++++++ .../java/tectech/loader/thing/CoverLoader.java | 47 + .../java/tectech/loader/thing/MachineLoader.java | 2532 +++++++++++++ src/main/java/tectech/loader/thing/MuTeLoader.java | 21 + .../java/tectech/loader/thing/ThingsLoader.java | 93 + 16 files changed, 11102 insertions(+) create mode 100644 src/main/java/tectech/loader/MainLoader.java create mode 100644 src/main/java/tectech/loader/NetworkDispatcher.java create mode 100644 src/main/java/tectech/loader/TecTechConfig.java create mode 100644 src/main/java/tectech/loader/gui/CreativeTabTecTech.java create mode 100644 src/main/java/tectech/loader/recipe/Assembler.java create mode 100644 src/main/java/tectech/loader/recipe/AssemblyLine.java create mode 100644 src/main/java/tectech/loader/recipe/BaseRecipeLoader.java create mode 100644 src/main/java/tectech/loader/recipe/CircuitAssembler.java create mode 100644 src/main/java/tectech/loader/recipe/Crafting.java create mode 100644 src/main/java/tectech/loader/recipe/Extractor.java create mode 100644 src/main/java/tectech/loader/recipe/Godforge.java create mode 100644 src/main/java/tectech/loader/recipe/ResearchStationAssemblyLine.java create mode 100644 src/main/java/tectech/loader/thing/CoverLoader.java create mode 100644 src/main/java/tectech/loader/thing/MachineLoader.java create mode 100644 src/main/java/tectech/loader/thing/MuTeLoader.java create mode 100644 src/main/java/tectech/loader/thing/ThingsLoader.java (limited to 'src/main/java/tectech/loader') diff --git a/src/main/java/tectech/loader/MainLoader.java b/src/main/java/tectech/loader/MainLoader.java new file mode 100644 index 0000000000..801653ca4b --- /dev/null +++ b/src/main/java/tectech/loader/MainLoader.java @@ -0,0 +1,206 @@ +package tectech.loader; + +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.enums.Mods.TwilightForest; +import static tectech.TecTech.LOGGER; +import static tectech.TecTech.configTecTech; +import static tectech.TecTech.creativeTabTecTech; +import static tectech.TecTech.proxy; +import static tectech.loader.TecTechConfig.DEBUG_MODE; + +import java.util.HashMap; + +import net.minecraft.block.Block; +import net.minecraft.util.DamageSource; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import cpw.mods.fml.common.ProgressManager; +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.GregTechAPI; +import gregtech.api.enums.Materials; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.util.GTRecipe; +import tectech.TecTech; +import tectech.loader.gui.CreativeTabTecTech; +import tectech.loader.recipe.BaseRecipeLoader; +import tectech.loader.recipe.ResearchStationAssemblyLine; +import tectech.loader.thing.CoverLoader; +import tectech.loader.thing.MachineLoader; +import tectech.loader.thing.ThingsLoader; +import tectech.thing.casing.TTCasingsContainer; +import tectech.thing.metaTileEntity.Textures; + +@SuppressWarnings("deprecation") +public final class MainLoader { + + public static DamageSource microwaving; + + private MainLoader() {} + + public static void preLoad() { + creativeTabTecTech = new CreativeTabTecTech("TecTech"); + + // set expanded texture arrays for tiers + try { + Textures.run(); + } catch (Throwable t) { + LOGGER.error("Loading textures...", t); + } + } + + public static void load() { + ProgressManager.ProgressBar progressBarLoad = ProgressManager.push("TecTech Loader", 6); + + progressBarLoad.step("Regular Things"); + new ThingsLoader().run(); + LOGGER.info("Block/Item Init Done"); + + progressBarLoad.step("Machine Things"); + new MachineLoader().run(); + LOGGER.info("Machine Init Done"); + + progressBarLoad.step("Cover Things"); + new CoverLoader().run(); + LOGGER.info("Cover Init Done"); + + progressBarLoad.step("Add damage types"); + microwaving = new DamageSource("microwaving").setDamageBypassesArmor(); + LOGGER.info("Damage types addition Done"); + + progressBarLoad.step("Register Packet Dispatcher"); + new NetworkDispatcher(); + LOGGER.info("Packet Dispatcher registered"); + + progressBarLoad.step("Register GUI Handler"); + proxy.registerRenderInfo(); + LOGGER.info("GUI Handler registered"); + + ProgressManager.pop(progressBarLoad); + } + + public static void postLoad() { + ProgressManager.ProgressBar progressBarPostLoad = ProgressManager.push("TecTech Post Loader", 4); + + progressBarPostLoad.step("Dreamcraft Compatibility"); + if (NewHorizonsCoreMod.isModLoaded()) { + try { + Class clazz = Class.forName("com.dreammaster.gthandler.casings.GT_Container_CasingsNH"); + TTCasingsContainer.sBlockCasingsNH = (Block) clazz.getField("sBlockCasingsNH") + .get(null); + + if (TTCasingsContainer.sBlockCasingsNH == null) { + throw new NullPointerException("sBlockCasingsNH Is not set at this time"); + } + } catch (Exception e) { + throw new Error("Unable to get NH casings", e); + } + } + + progressBarPostLoad.step("Recipes"); + new BaseRecipeLoader().run(); + TecTech.LOGGER.info("Recipe Init Done"); + + if (!configTecTech.DISABLE_BLOCK_HARDNESS_NERF) { + progressBarPostLoad.step("Nerf blocks blast resistance"); + adjustTwilightBlockResistance(); + TecTech.LOGGER.info("Blocks nerf done"); + } else { + progressBarPostLoad.step("Do not nerf blocks blast resistance"); + TecTech.LOGGER.info("Blocks were not nerfed"); + } + + // ProgressManager.pop(progressBarPostLoad); + } + + public static void addAfterGregTechPostLoadRunner() { + GregTechAPI.sAfterGTPostload.add(() -> { + if (TecTech.configTecTech.NERF_FUSION) { + FixBrokenFusionRecipes(); + } + }); + } + + private static void FixBrokenFusionRecipes() { + HashMap binds = new HashMap<>(); + for (Materials material : Materials.values()) { + FluidStack p = material.getPlasma(1); + if (p != null) { + if (DEBUG_MODE) { + LOGGER.info("Found Plasma of " + material.mName); + } + if (material.mElement != null && (material.mElement.mProtons >= Materials.Iron.mElement.mProtons + || -material.mElement.mProtons >= Materials.Iron.mElement.mProtons + || material.mElement.mNeutrons >= Materials.Iron.mElement.mNeutrons + || -material.mElement.mNeutrons >= Materials.Iron.mElement.mNeutrons)) { + if (DEBUG_MODE) { + LOGGER.info("Attempting to bind " + material.mName); + } + if (material.getMolten(1) != null) { + binds.put( + p.getFluid(), + material.getMolten(1) + .getFluid()); + } else if (material.getGas(1) != null) { + binds.put( + p.getFluid(), + material.getGas(1) + .getFluid()); + } else if (material.getFluid(1) != null) { + binds.put( + p.getFluid(), + material.getFluid(1) + .getFluid()); + } else { + binds.put( + p.getFluid(), + Materials.Iron.getMolten(1) + .getFluid()); + } + } + } + } + for (GTRecipe r : RecipeMaps.fusionRecipes.getAllRecipes()) { + Fluid fluid = binds.get(r.mFluidOutputs[0].getFluid()); + if (fluid != null) { + if (DEBUG_MODE) { + LOGGER.info("Nerfing Recipe " + r.mFluidOutputs[0].getUnlocalizedName()); + } + r.mFluidOutputs[0] = new FluidStack(fluid, r.mFluidOutputs[0].amount); + } + fluid = binds.get(r.mFluidInputs[0].getFluid()); + if (fluid != null) { + if (DEBUG_MODE) { + LOGGER.info("Fixing plasma use in Recipe " + r.mFluidInputs[0].getUnlocalizedName()); + } + r.mFluidInputs[0] = new FluidStack(fluid, r.mFluidInputs[0].amount); + } + fluid = binds.get(r.mFluidInputs[1].getFluid()); + if (fluid != null) { + if (DEBUG_MODE) { + LOGGER.info("Fixing plasma use in Recipe " + r.mFluidInputs[1].getUnlocalizedName()); + } + r.mFluidInputs[1] = new FluidStack(fluid, r.mFluidInputs[1].amount); + } + } + } + + private static void safeSetResistance(Block block, float resistance) { + if (block != null) { + block.setResistance(resistance); + } + } + + private static void adjustTwilightBlockResistance() { + if (TwilightForest.isModLoaded()) { + safeSetResistance(GameRegistry.findBlock("TwilightForest", "tile.TFShield"), 30); + safeSetResistance(GameRegistry.findBlock("TwilightForest", "tile.TFThorns"), 10); + safeSetResistance(GameRegistry.findBlock("TwilightForest", "tile.TFTowerTranslucent"), 30); + safeSetResistance(GameRegistry.findBlock("TwilightForest", "tile.TFDeadrock"), 5); + } + } + + public static void onLoadCompleted() { + new ResearchStationAssemblyLine().runLateRecipes(); + } +} diff --git a/src/main/java/tectech/loader/NetworkDispatcher.java b/src/main/java/tectech/loader/NetworkDispatcher.java new file mode 100644 index 0000000000..dd46715450 --- /dev/null +++ b/src/main/java/tectech/loader/NetworkDispatcher.java @@ -0,0 +1,25 @@ +package tectech.loader; + +import static tectech.Reference.MODID; + +import tectech.mechanics.pipe.PipeActivityMessage; +import tectech.mechanics.spark.RendererMessage; + +public class NetworkDispatcher extends eu.usrv.yamcore.network.PacketDispatcher { + + public static NetworkDispatcher INSTANCE; + + public NetworkDispatcher() { + super(MODID); + INSTANCE = this; + registerPackets(); + } + + @Override + public void registerPackets() { + registerMessage(PipeActivityMessage.ServerHandler.class, PipeActivityMessage.PipeActivityQuery.class); + registerMessage(PipeActivityMessage.ClientHandler.class, PipeActivityMessage.PipeActivityData.class); + + registerMessage(RendererMessage.ClientHandler.class, RendererMessage.RendererData.class); + } +} diff --git a/src/main/java/tectech/loader/TecTechConfig.java b/src/main/java/tectech/loader/TecTechConfig.java new file mode 100644 index 0000000000..06ded34e01 --- /dev/null +++ b/src/main/java/tectech/loader/TecTechConfig.java @@ -0,0 +1,271 @@ +package tectech.loader; + +import java.io.File; + +import net.minecraft.launchwrapper.Launch; + +import eu.usrv.yamcore.config.ConfigManager; + +public class TecTechConfig extends ConfigManager { + + public TecTechConfig(File pConfigBaseDirectory, String pModCollectionDirectory, String pModID) { + super(pConfigBaseDirectory, pModCollectionDirectory, pModID); + } + + // final static to allow compiler to remove the debug code when this is false + public static boolean DEBUG_MODE = false; + public static boolean POWERLESS_MODE = false; + /** + * Not complete; enabled by default only in dev env + */ + public boolean ENABLE_GOD_FORGE; + + public boolean BOOM_ENABLE; + public boolean DISABLE_BLOCK_HARDNESS_NERF; + public boolean EASY_SCAN; + public boolean NERF_FUSION; + public boolean ENABLE_TURRET_EXPLOSIONS; + public float TURRET_DAMAGE_FACTOR; + public float TURRET_EXPLOSION_FACTOR; + + public boolean MOD_ADMIN_ERROR_LOGS; + + public boolean TESLA_MULTI_GAS_OUTPUT; + public float TESLA_MULTI_LOSS_FACTOR_OVERDRIVE; + public int TESLA_MULTI_LOSS_PER_BLOCK_T0; + public int TESLA_MULTI_LOSS_PER_BLOCK_T1; + public int TESLA_MULTI_LOSS_PER_BLOCK_T2; + public int TESLA_MULTI_PLASMA_PER_SECOND_T1_HELIUM; + public int TESLA_MULTI_PLASMA_PER_SECOND_T1_NITROGEN; + public int TESLA_MULTI_PLASMA_PER_SECOND_T2_RADON; + public int TESLA_MULTI_RANGE_COEFFICIENT_PLASMA_T1; + public int TESLA_MULTI_RANGE_COEFFICIENT_PLASMA_T2; + public int TESLA_MULTI_RANGE_COVER; + public int TESLA_MULTI_RANGE_TOWER; + public int TESLA_MULTI_RANGE_TRANSCEIVER; + public float TESLA_SINGLE_LOSS_FACTOR_OVERDRIVE; + public int TESLA_SINGLE_LOSS_PER_BLOCK; + public int TESLA_SINGLE_RANGE; + public boolean TESLA_VISUAL_EFFECT; + + /** + * This loading phases do not correspond to mod loading phases! + */ + @Override + protected void PreInit() { + + BOOM_ENABLE = true; + DISABLE_BLOCK_HARDNESS_NERF = false; + EASY_SCAN = false; + NERF_FUSION = false; + ENABLE_TURRET_EXPLOSIONS = true; + TURRET_DAMAGE_FACTOR = 10; + TURRET_EXPLOSION_FACTOR = 1; + + MOD_ADMIN_ERROR_LOGS = false; + + TESLA_MULTI_GAS_OUTPUT = false; + TESLA_MULTI_LOSS_FACTOR_OVERDRIVE = 0.25F; + TESLA_MULTI_LOSS_PER_BLOCK_T0 = 1; + TESLA_MULTI_LOSS_PER_BLOCK_T1 = 1; + TESLA_MULTI_LOSS_PER_BLOCK_T2 = 1; + TESLA_MULTI_PLASMA_PER_SECOND_T1_HELIUM = 100; + TESLA_MULTI_PLASMA_PER_SECOND_T1_NITROGEN = 50; + TESLA_MULTI_PLASMA_PER_SECOND_T2_RADON = 50; + TESLA_MULTI_RANGE_COEFFICIENT_PLASMA_T1 = 2; + TESLA_MULTI_RANGE_COEFFICIENT_PLASMA_T2 = 4; + TESLA_MULTI_RANGE_COVER = 16; + TESLA_MULTI_RANGE_TOWER = 32; + TESLA_MULTI_RANGE_TRANSCEIVER = 16; + TESLA_SINGLE_LOSS_FACTOR_OVERDRIVE = 0.25F; + TESLA_SINGLE_LOSS_PER_BLOCK = 1; + TESLA_SINGLE_RANGE = 20; + TESLA_VISUAL_EFFECT = true; + + ENABLE_GOD_FORGE = (boolean) Launch.blackboard.get("fml.deobfuscatedEnvironment"); + } + + /** + * This loading phases do not correspond to mod loading phases! + */ + @Override + protected void Init() { + DEBUG_MODE = _mainConfig + .getBoolean("DebugMode", "debug", DEBUG_MODE, "Enables logging and other purely debug features"); + POWERLESS_MODE = _mainConfig + .getBoolean("PowerlessMode", "debug", POWERLESS_MODE, "Enables 0EU/t multi block machinery"); + ENABLE_GOD_FORGE = _mainConfig.getBoolean( + "EnableGodForge", + "debug", + ENABLE_GOD_FORGE, + "Enables the in progress God Forge; enabled automatically in dev env"); + + BOOM_ENABLE = _mainConfig.getBoolean( + "BoomEnable", + "features", + BOOM_ENABLE, + "Set to false to disable explosions on everything bad that you can do"); + DISABLE_BLOCK_HARDNESS_NERF = _mainConfig.getBoolean( + "DisableBlockHardnessNerf", + "features", + DISABLE_BLOCK_HARDNESS_NERF, + "Set to true to disable the block hardness nerf"); + EASY_SCAN = _mainConfig.getBoolean( + "EasyScan", + "features", + EASY_SCAN, + "Enables tricorder to scan EM i/o hatches directly, too CHEEKY"); + NERF_FUSION = _mainConfig.getBoolean( + "NerfFusion", + "features", + NERF_FUSION, + "Set to true to enable removal of plasmas heavier than Fe and other weird ones"); + ENABLE_TURRET_EXPLOSIONS = _mainConfig.getBoolean( + "TurretBoomEnable", + "features", + ENABLE_TURRET_EXPLOSIONS, + "Set to false to disable explosions caused by EM turrets"); + TURRET_DAMAGE_FACTOR = _mainConfig.getFloat( + "TurretDamageFactor", + "features", + TURRET_DAMAGE_FACTOR, + 0, + Short.MAX_VALUE, + "Damage is multiplied by this number"); + TURRET_EXPLOSION_FACTOR = _mainConfig.getFloat( + "TurretExplosionFactor", + "features", + TURRET_EXPLOSION_FACTOR, + 0, + Short.MAX_VALUE, + "Explosion strength is multiplied by this number"); + + MOD_ADMIN_ERROR_LOGS = _mainConfig.getBoolean( + "AdminErrorLog", + "modules", + MOD_ADMIN_ERROR_LOGS, + "If set to true, every op/admin will receive all errors occurred during the startup phase as in game message on join"); + + TESLA_MULTI_GAS_OUTPUT = _mainConfig.getBoolean( + "TeslaMultiGasOutput", + "tesla_tweaks", + TESLA_MULTI_GAS_OUTPUT, + "Set to true to enable outputting plasmas as gasses from the tesla tower with a 1:1 ratio"); + TESLA_MULTI_LOSS_FACTOR_OVERDRIVE = _mainConfig.getFloat( + "TeslaMultiLossFactorOverdrive", + "tesla_tweaks", + TESLA_MULTI_LOSS_FACTOR_OVERDRIVE, + 0, + 1, + "Additional Tesla Tower power loss per amp as a factor of the tier voltage"); + TESLA_MULTI_LOSS_PER_BLOCK_T0 = _mainConfig.getInt( + "TeslaMultiLossPerBlockT0", + "tesla_tweaks", + TESLA_MULTI_LOSS_PER_BLOCK_T0, + 0, + Integer.MAX_VALUE, + "Tesla Tower power transmission loss per block per amp using no plasmas"); + TESLA_MULTI_LOSS_PER_BLOCK_T1 = _mainConfig.getInt( + "TeslaMultiLossPerBlockT1", + "tesla_tweaks", + TESLA_MULTI_LOSS_PER_BLOCK_T1, + 0, + Integer.MAX_VALUE, + "Tesla Tower power transmission loss per block per amp using helium or nitrogen plasma"); + TESLA_MULTI_LOSS_PER_BLOCK_T2 = _mainConfig.getInt( + "TeslaMultiLossPerBlockT2", + "tesla_tweaks", + TESLA_MULTI_LOSS_PER_BLOCK_T2, + 0, + Integer.MAX_VALUE, + "Tesla Tower power transmission loss per block per amp using radon plasma"); + TESLA_MULTI_PLASMA_PER_SECOND_T1_HELIUM = _mainConfig.getInt( + "TeslaMultiPlasmaPerSecondT1Helium", + "tesla_tweaks", + TESLA_MULTI_PLASMA_PER_SECOND_T1_HELIUM, + 0, + Integer.MAX_VALUE, + "Tesla Tower helium plasma consumed each second the tesla tower is active"); + TESLA_MULTI_PLASMA_PER_SECOND_T1_NITROGEN = _mainConfig.getInt( + "TeslaMultiPlasmaPerSecondT1Nitrogen", + "tesla_tweaks", + TESLA_MULTI_PLASMA_PER_SECOND_T1_NITROGEN, + 0, + Integer.MAX_VALUE, + "Tesla Tower nitrogen plasma consumed each second the tesla tower is active"); + TESLA_MULTI_PLASMA_PER_SECOND_T2_RADON = _mainConfig.getInt( + "TeslaMultiPlasmaPerSecondT2Radon", + "tesla_tweaks", + TESLA_MULTI_PLASMA_PER_SECOND_T2_RADON, + 0, + Integer.MAX_VALUE, + "Tesla Tower radon plasma consumed each second the tesla tower is active"); + TESLA_MULTI_RANGE_COEFFICIENT_PLASMA_T1 = _mainConfig.getInt( + "TeslaMultiRangeCoefficientPlasmaT1", + "tesla_tweaks", + TESLA_MULTI_RANGE_COEFFICIENT_PLASMA_T1, + 0, + Integer.MAX_VALUE, + "Tesla Tower T1 Plasmas Range Multiplier"); + TESLA_MULTI_RANGE_COEFFICIENT_PLASMA_T2 = _mainConfig.getInt( + "TeslaMultiRangeCoefficientPlasmaT2", + "tesla_tweaks", + TESLA_MULTI_RANGE_COEFFICIENT_PLASMA_T2, + 0, + Integer.MAX_VALUE, + "Tesla Tower T2 Plasmas Range Multiplier"); + TESLA_MULTI_RANGE_COVER = _mainConfig.getInt( + "TeslaMultiRangeCover", + "tesla_tweaks", + TESLA_MULTI_RANGE_COVER, + 0, + Integer.MAX_VALUE, + "Tesla Tower to Tesla Coil Rich Edition Cover max range"); + TESLA_MULTI_RANGE_TOWER = _mainConfig.getInt( + "TeslaMultiRangeTower", + "tesla_tweaks", + TESLA_MULTI_RANGE_TOWER, + 0, + Integer.MAX_VALUE, + "Tesla Tower to Tower max range"); + TESLA_MULTI_RANGE_TRANSCEIVER = _mainConfig.getInt( + "TeslaMultiRangeTransceiver", + "tesla_tweaks", + TESLA_MULTI_RANGE_TRANSCEIVER, + 0, + Integer.MAX_VALUE, + "Tesla Tower to Transceiver max range"); + TESLA_SINGLE_LOSS_FACTOR_OVERDRIVE = _mainConfig.getFloat( + "TeslaSingleLossFactorOverdrive", + "tesla_tweaks", + TESLA_SINGLE_LOSS_FACTOR_OVERDRIVE, + 0, + 1, + "Additional Tesla Transceiver power loss per amp as a factor of the tier voltage"); + TESLA_SINGLE_LOSS_PER_BLOCK = _mainConfig.getInt( + "TeslaSingleLossPerBlock", + "tesla_tweaks", + TESLA_SINGLE_LOSS_PER_BLOCK, + 0, + Integer.MAX_VALUE, + "Tesla Transceiver power transmission loss per block per amp"); + TESLA_SINGLE_RANGE = _mainConfig.getInt( + "TeslaSingleRange", + "tesla_tweaks", + TESLA_SINGLE_RANGE, + 0, + Integer.MAX_VALUE, + "Tesla Transceiver to max range"); + TESLA_VISUAL_EFFECT = _mainConfig.getBoolean( + "EnableTeslaVisualEffect", + "tesla_tweaks", + TESLA_VISUAL_EFFECT, + "Set true to enable the cool visual effect when tesla tower running."); + } + + /** + * This loading phases do not correspond to mod loading phases! + */ + @Override + protected void PostInit() {} +} diff --git a/src/main/java/tectech/loader/gui/CreativeTabTecTech.java b/src/main/java/tectech/loader/gui/CreativeTabTecTech.java new file mode 100644 index 0000000000..d098d375c4 --- /dev/null +++ b/src/main/java/tectech/loader/gui/CreativeTabTecTech.java @@ -0,0 +1,36 @@ +package tectech.loader.gui; + +import java.util.List; + +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTechAPI; +import tectech.thing.CustomItemList; +import tectech.thing.casing.TTCasingsContainer; + +public class CreativeTabTecTech extends CreativeTabs { + + public CreativeTabTecTech(String name) { + super(name); + } + + @SideOnly(Side.CLIENT) + @Override + public Item getTabIconItem() { + return Item.getItemFromBlock(TTCasingsContainer.sBlockCasingsTT); // High power casing + } + + @Override + public void displayAllReleventItems(List stuffToShow) { + for (CustomItemList item : CustomItemList.values()) { + if (item.hasBeenSet() && item.getBlock() == GregTechAPI.sBlockMachines) { + stuffToShow.add(item.get(1)); + } + } + super.displayAllReleventItems(stuffToShow); + } +} diff --git a/src/main/java/tectech/loader/recipe/Assembler.java b/src/main/java/tectech/loader/recipe/Assembler.java new file mode 100644 index 0000000000..eee8182184 --- /dev/null +++ b/src/main/java/tectech/loader/recipe/Assembler.java @@ -0,0 +1,3091 @@ +package tectech.loader.recipe; + +import static bartworks.common.loaders.ItemRegistry.bw_realglas; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.util.GTRecipeBuilder.MINUTES; +import static gregtech.api.util.GTRecipeBuilder.SECONDS; +import static gregtech.api.util.GTRecipeBuilder.TICKS; + +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import com.gtnewhorizon.structurelib.StructureLibAPI; + +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.GTModHandler; +import gregtech.api.util.GTOreDictUnificator; +import gregtech.api.util.GTUtility; +import tectech.thing.CustomItemList; +import tectech.thing.block.BlockQuantumGlass; + +public class Assembler implements Runnable { + + @Override + public void run() { + + cleanroomRecipes(); + + for (int i = 0; i <= 15; i++) { + GTValues.RA.stdBuilder() + .itemInputs( + GTUtility.getIntegratedCircuit(i + 1), + GTOreDictUnificator.get(OrePrefixes.dust, Materials.Cobalt, 1)) + .itemOutputs(new ItemStack(StructureLibAPI.getBlockHint(), 1, i)) + .fluidInputs(Materials.Aluminium.getMolten(864)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + } + + // Quantum Glass + GTValues.RA.stdBuilder() + .itemInputs(CustomItemList.eM_Containment.get(1), GTModHandler.getIC2Item("reinforcedGlass", 1L)) + .itemOutputs(new ItemStack(BlockQuantumGlass.INSTANCE, 1)) + .fluidInputs( + BaseRecipeLoader.getOrDefault("Trinium", Materials.Osmium) + .getMolten(576)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_UV) + .addTo(assemblerRecipes); + + // recipe for assline data hatches + GTValues.RA.stdBuilder() + .itemInputs(ItemList.Hatch_DataAccess_EV.get(1), CustomItemList.dataIn_Hatch.get(1)) + .itemOutputs(CustomItemList.dataInAss_Hatch.get(1)) + .duration(1 * MINUTES + 42 * SECONDS + 8 * TICKS) + .eut(12000) + .addTo(assemblerRecipes); + GTValues.RA.stdBuilder() + .itemInputs(ItemList.Hatch_DataAccess_EV.get(1), CustomItemList.dataOut_Hatch.get(1)) + .itemOutputs(CustomItemList.dataOutAss_Hatch.get(1)) + .duration(1 * MINUTES + 42 * SECONDS + 8 * TICKS) + .eut(12000) + .addTo(assemblerRecipes); + + // High Power Casing + GTValues.RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.frameGt, Materials.Iridium, 1), + GTOreDictUnificator.get(OrePrefixes.plateDouble, Materials.Iridium, 6), + GTOreDictUnificator.get(OrePrefixes.circuit, Materials.LuV, 1), + GTOreDictUnificator.get(OrePrefixes.wireFine, Materials.Cobalt, 16), + GTOreDictUnificator.get(OrePrefixes.wireFine, Materials.Copper, 16), + GTOreDictUnificator.get(OrePrefixes.wireGt02, Materials.NiobiumTitanium, 2)) + .itemOutputs(CustomItemList.eM_Power.get(1)) + .fluidInputs(Materials.TungstenSteel.getMolten(576)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(assemblerRecipes); + // Computer Casing + GTValues.RA.stdBuilder() + .itemInputs( + CustomItemList.eM_Power.get(1), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.StainlessSteel, 8), + GTOreDictUnificator.get(OrePrefixes.circuit, Materials.ZPM, 1), + GTOreDictUnificator.get(OrePrefixes.wireGt02, Materials.NiobiumTitanium, 2)) + .itemOutputs(CustomItemList.eM_Computer_Casing.get(1)) + .fluidInputs(Materials.Aluminium.getMolten(1296)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .addTo(assemblerRecipes); + // Computer Vent Casing + GTValues.RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.frameGt, Materials.StainlessSteel, 1), + ItemList.Electric_Motor_IV.get(2), + GTOreDictUnificator.get(OrePrefixes.rotor, Materials.StainlessSteel, 2), + GTOreDictUnificator.get(OrePrefixes.pipeTiny, Materials.StainlessSteel, 16), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Copper, 16), + GTOreDictUnificator.get( + OrePrefixes.wireGt01, + BaseRecipeLoader.getOrDefault("SuperconductorIV", Materials.SuperconductorUHV), + 1)) + .itemOutputs(CustomItemList.eM_Computer_Vent.get(1)) + .fluidInputs(Materials.SolderingAlloy.getMolten(1296)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + // Molecular Casing + GTValues.RA.stdBuilder() + .itemInputs( + CustomItemList.eM_Power.get(1), + GTOreDictUnificator.get(OrePrefixes.plateDense, Materials.Osmiridium, 6), + GTOreDictUnificator + .get(OrePrefixes.foil, BaseRecipeLoader.getOrDefault("Trinium", Materials.Osmium), 12), + GTOreDictUnificator.get(OrePrefixes.screw, Materials.TungstenSteel, 24), + GTOreDictUnificator.get(OrePrefixes.ring, Materials.TungstenSteel, 24), + ItemList.Field_Generator_IV.get(1)) + .itemOutputs(CustomItemList.eM_Containment.get(1)) + .fluidInputs(Materials.Osmium.getMolten(1296)) + .duration(40 * SECONDS) + .eut(TierEU.RECIPE_UV) + .addTo(assemblerRecipes); + // Tesla Base + GTValues.RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.plate, Materials.NickelZincFerrite, 6), + GTOreDictUnificator.get(OrePrefixes.frameGt, Materials.NickelZincFerrite, 1)) + .itemOutputs(CustomItemList.tM_TeslaBase.get(1)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(16) + .addTo(assemblerRecipes); + // Tesla Toroid + GTValues.RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.foil, Materials.Aluminium, 6), + GTOreDictUnificator.get(OrePrefixes.frameGt, Materials.Aluminium, 1)) + .itemOutputs(CustomItemList.tM_TeslaToroid.get(1)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(16) + .addTo(assemblerRecipes); + // Tesla Secondary Windings + GTValues.RA.stdBuilder() + .itemInputs( + CustomItemList.teslaComponent.getWithDamage(8, 0), + BaseRecipeLoader.getItemContainer("MicaInsulatorFoil") + .get(12)) + .itemOutputs(CustomItemList.tM_TeslaSecondary.get(1)) + .fluidInputs(Materials.Silver.getMolten(144)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + // Tesla Primary Coils T0 + GTValues.RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.wireGt02, Materials.RedstoneAlloy, 8), + BaseRecipeLoader.getItemContainer("MicaInsulatorFoil") + .get(8)) + .itemOutputs(CustomItemList.tM_TeslaPrimary_0.get(1)) + .fluidInputs(Materials.RedAlloy.getMolten(144)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + // Tesla Primary Coils T1 + GTValues.RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.wireGt02, Materials.SuperconductorMV, 8), + BaseRecipeLoader.getItemContainer("MicaInsulatorFoil") + .get(12)) + .itemOutputs(CustomItemList.tM_TeslaPrimary_1.get(1)) + .fluidInputs(Materials.Magnesium.getMolten(144)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + // Tesla Primary Coils T2 + GTValues.RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.wireGt02, Materials.SuperconductorHV, 8), + BaseRecipeLoader.getItemContainer("MicaInsulatorFoil") + .get(16)) + .itemOutputs(CustomItemList.tM_TeslaPrimary_2.get(1)) + .fluidInputs(Materials.Barium.getMolten(144)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // Tesla Primary Coils T3 + GTValues.RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.wireGt02, Materials.SuperconductorEV, 8), + BaseRecipeLoader.getItemContainer("MicaInsulatorFoil") + .get(20)) + .itemOutputs(CustomItemList.tM_TeslaPrimary_3.get(1)) + .fluidInputs(Materials.Platinum.getMolten(144)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + // Tesla Primary Coils T4 + GTValues.RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.wireGt02, Materials.SuperconductorIV, 8), + BaseRecipeLoader.getItemContainer("MicaInsulatorFoil") + .get(24)) + .itemOutputs(CustomItemList.tM_TeslaPrimary_4.get(1)) + .fluidInputs(Materials.Vanadium.getMolten(144)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + // Tesla Primary Coils T5 + GTValues.RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.wireGt02, Materials.SuperconductorLuV, 8), + BaseRecipeLoader.getItemContainer("MicaInsulatorFoil") + .get(28)) + .itemOutputs(CustomItemList.tM_TeslaPrimary_5.get(1)) + .fluidInputs(Materials.Indium.getMolten(144)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(assemblerRecipes); + // Tesla Primary Coils T6 + GTValues.RA.stdBuilder() + .itemInputs( + GTOreDictUnificator.get(OrePrefixes.wireGt02, Materials.SuperconductorZPM, 8), + BaseRecipeLoader.getItemContainer("MicaInsulatorFoil") + .get(32)) + .itemOutputs(CustomItemList.tM_TeslaPrimary_6.get(1)) + .fluidInputs(Materials.Naquadah.getMolten(144)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .addTo(assemblerRecipes); + + // Dynamo Hatches + { + // Dynamo Hatches 4A + { + // Dynamo EV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Dynamo_EV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.Aluminium, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Titanium, 2)) + .itemOutputs(CustomItemList.eM_dynamoMulti4_EV.get(1)) + .fluidInputs(Materials.Silver.getMolten(144)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // Dynamo IV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Dynamo_IV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.Tungsten, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.TungstenSteel, 2)) + .itemOutputs(CustomItemList.eM_dynamoMulti4_IV.get(1)) + .fluidInputs(Materials.Silver.getMolten(144)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + // Dynamo LuV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Dynamo_LuV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.VanadiumGallium, 2), + GTOreDictUnificator.get( + OrePrefixes.plate, + BaseRecipeLoader.getOrDefault("Rhodium-PlatedPalladium", Materials.Chrome), + 2)) + .itemOutputs(CustomItemList.eM_dynamoMulti4_LuV.get(1)) + .fluidInputs(Materials.Silver.getMolten(288)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + // Dynamo ZPM 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Dynamo_ZPM.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.Naquadah, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Iridium, 2)) + .itemOutputs(CustomItemList.eM_dynamoMulti4_ZPM.get(1)) + .fluidInputs(Materials.Silver.getMolten(576)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(assemblerRecipes); + // Dynamo UV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Dynamo_UV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.NaquadahAlloy, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Osmium, 2)) + .itemOutputs(CustomItemList.eM_dynamoMulti4_UV.get(1)) + .fluidInputs(Materials.Silver.getMolten(1152)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .addTo(assemblerRecipes); + // Dynamo UHV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Dynamo_UHV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorUHV, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Neutronium, 2)) + .itemOutputs(CustomItemList.eM_dynamoMulti4_UHV.get(1)) + .fluidInputs(Materials.Silver.getMolten(2304)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_UV) + .addTo(assemblerRecipes); + // Dynamo UEV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Dynamo_UEV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.Draconium, 2), + GTOreDictUnificator.get( + OrePrefixes.plate, + BaseRecipeLoader.getOrDefault("Bedrockium", Materials.Neutronium), + 2)) + .itemOutputs(CustomItemList.eM_dynamoMulti4_UEV.get(1)) + .fluidInputs(Materials.Silver.getMolten(4608)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_UHV) + .addTo(assemblerRecipes); + // Dynamo UIV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Dynamo_UIV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.NetherStar, 2), + GTOreDictUnificator.get( + OrePrefixes.plate, + BaseRecipeLoader.getOrDefault("BlackPlutonium", Materials.Neutronium), + 2)) + .itemOutputs(CustomItemList.eM_dynamoMulti4_UIV.get(1)) + .fluidInputs(Materials.Silver.getMolten(9216)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_UEV) + .addTo(assemblerRecipes); + // Dynamo UMV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Dynamo_UMV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.Quantium, 2), + GTOreDictUnificator.get(OrePrefixes.plate, MaterialsUEVplus.SpaceTime, 2)) + .itemOutputs(CustomItemList.eM_dynamoMulti4_UMV.get(1)) + .fluidInputs(Materials.Silver.getMolten(9216)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_UIV) + .addTo(assemblerRecipes); + // Dynamo UXV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Dynamo_UXV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.BlackPlutonium, 2), + GTOreDictUnificator + .get(OrePrefixes.plate, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 1), + GTOreDictUnificator.get("plateShirabon", 1L)) + .itemOutputs(CustomItemList.eM_dynamoMulti4_UXV.get(1)) + .fluidInputs(Materials.Silver.getMolten(9216)) + .duration(5 * SECONDS) + .eut((int) TierEU.RECIPE_UMV) + .addTo(assemblerRecipes); + + } + + // Dynamo Hatches 16A + { + // Dynamo EV 16A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Transformer_IV_EV.get(1), + CustomItemList.eM_dynamoMulti4_EV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt08, Materials.Aluminium, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Titanium, 4)) + .itemOutputs(CustomItemList.eM_dynamoMulti16_EV.get(1)) + .fluidInputs(Materials.Electrum.getMolten(144)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // Dynamo IV 16A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Transformer_LuV_IV.get(1), + CustomItemList.eM_dynamoMulti4_IV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt08, Materials.Tungsten, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.TungstenSteel, 4)) + .itemOutputs(CustomItemList.eM_dynamoMulti16_IV.get(1)) + .fluidInputs(Materials.Electrum.getMolten(144)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + // Dynamo LuV 16A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Transformer_ZPM_LuV.get(1), + CustomItemList.eM_dynamoMulti4_LuV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt08, Materials.VanadiumGallium, 2), + GTOreDictUnificator.get( + OrePrefixes.plate, + BaseRecipeLoader.getOrDefault("Rhodium-PlatedPalladium", Materials.Chrome), + 4)) + .itemOutputs(CustomItemList.eM_dynamoMulti16_LuV.get(1)) + .fluidInputs(Materials.Electrum.getMolten(288)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + // Dynamo ZPM 16A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Transformer_UV_ZPM.get(1), + CustomItemList.eM_dynamoMulti4_ZPM.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt08, Materials.Naquadah, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Iridium, 4)) + .itemOutputs(CustomItemList.eM_dynamoMulti16_ZPM.get(1)) + .fluidInputs(Materials.Electrum.getMolten(576)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(assemblerRecipes); + // Dynamo UV 16A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Transformer_MAX_UV.get(1), + CustomItemList.eM_dynamoMulti4_UV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt08, Materials.NaquadahAlloy, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Osmium, 4)) + .itemOutputs(CustomItemList.eM_dynamoMulti16_UV.get(1)) + .fluidInputs(Materials.Electrum.getMolten(1152)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .addTo(assemblerRecipes); + // Dynamo UHV 16A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Transformer_UEV_UHV.get(1), + CustomItemList.eM_dynamoMulti4_UHV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt08, Materials.SuperconductorUHV, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Neutronium, 4)) + .itemOutputs(CustomItemList.eM_dynamoMulti16_UHV.get(1)) + .fluidInputs(Materials.Electrum.getMolten(2304)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_UV) + .addTo(assemblerRecipes); + // Dynamo UEV 16A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Transformer_UIV_UEV.get(1), + CustomItemList.eM_dynamoMulti4_UEV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt08, Materials.Draconium, 2), + GTOreDictUnificator.get( + OrePrefixes.plate, + BaseRecipeLoader.getOrDefault("Bedrockium", Materials.Neutronium), + 4)) + .itemOutputs(CustomItemList.eM_dynamoMulti16_UEV.get(1)) + .fluidInputs(Materials.Electrum.getMolten(4608)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_UHV) + .addTo(assemblerRecipes); + // Dynamo UIV 16A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Transformer_UMV_UIV.get(1), + CustomItemList.eM_dynamoMulti4_UIV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt08, Materials.NetherStar, 2), + GTOreDictUnificator.get( + OrePrefixes.plate, + BaseRecipeLoader.getOrDefault("BlackPlutonium", Materials.Neutronium), + 4)) + .itemOutputs(CustomItemList.eM_dynamoMulti16_UIV.get(1)) + .fluidInputs(Materials.Electrum.getMolten(9216)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_UEV) + .addTo(assemblerRecipes); + // Dynamo UMV 16A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Transformer_UXV_UMV.get(1), + CustomItemList.eM_dynamoMulti4_UMV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt08, Materials.Quantium, 2), + GTOreDictUnificator.get(OrePrefixes.plate, MaterialsUEVplus.SpaceTime, 4)) + .itemOutputs(CustomItemList.eM_dynamoMulti16_UMV.get(1)) + .fluidInputs(Materials.Electrum.getMolten(9216)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_UIV) + .addTo(assemblerRecipes); + // Dynamo UXV 16A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Transformer_MAX_UXV.get(1), + CustomItemList.eM_dynamoMulti4_UXV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt08, Materials.BlackPlutonium, 2), + GTOreDictUnificator + .get(OrePrefixes.plate, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 2), + GTOreDictUnificator.get("plateShirabon", 2L)) + .itemOutputs(CustomItemList.eM_dynamoMulti16_UXV.get(1)) + .fluidInputs(Materials.Electrum.getMolten(9216)) + .duration(10 * SECONDS) + .eut((int) TierEU.RECIPE_UMV) + .addTo(assemblerRecipes); + + } + + // Dynamo Hatches 64A + { + // Dynamo EV 64A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.WetTransformer_IV_EV.get(1), + CustomItemList.eM_dynamoMulti16_EV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt12, Materials.Aluminium, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Titanium, 6)) + .itemOutputs(CustomItemList.eM_dynamoMulti64_EV.get(1)) + .fluidInputs(Materials.Tungsten.getMolten(144)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // Dynamo IV 64A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.WetTransformer_LuV_IV.get(1), + CustomItemList.eM_dynamoMulti16_IV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt12, Materials.Tungsten, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.TungstenSteel, 6)) + .itemOutputs(CustomItemList.eM_dynamoMulti64_IV.get(1)) + .fluidInputs(Materials.Tungsten.getMolten(144)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + // Dynamo LuV 64A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.WetTransformer_ZPM_LuV.get(1), + CustomItemList.eM_dynamoMulti16_LuV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt12, Materials.VanadiumGallium, 2), + GTOreDictUnificator.get( + OrePrefixes.plate, + BaseRecipeLoader.getOrDefault("Rhodium-PlatedPalladium", Materials.Chrome), + 6)) + .itemOutputs(CustomItemList.eM_dynamoMulti64_LuV.get(1)) + .fluidInputs(Materials.Tungsten.getMolten(288)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + // Dynamo ZPM 64A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.WetTransformer_UV_ZPM.get(1), + CustomItemList.eM_dynamoMulti16_ZPM.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt12, Materials.Naquadah, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Iridium, 6)) + .itemOutputs(CustomItemList.eM_dynamoMulti64_ZPM.get(1)) + .fluidInputs(Materials.Tungsten.getMolten(576)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(assemblerRecipes); + // Dynamo UV 64A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.WetTransformer_UHV_UV.get(1), + CustomItemList.eM_dynamoMulti16_UV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt12, Materials.NaquadahAlloy, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Osmium, 6)) + .itemOutputs(CustomItemList.eM_dynamoMulti64_UV.get(1)) + .fluidInputs(Materials.Tungsten.getMolten(1152)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .addTo(assemblerRecipes); + // Dynamo UHV 64A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.WetTransformer_UEV_UHV.get(1), + CustomItemList.eM_dynamoMulti16_UHV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt12, Materials.SuperconductorUHV, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Neutronium, 6)) + .itemOutputs(CustomItemList.eM_dynamoMulti64_UHV.get(1)) + .fluidInputs(Materials.Tungsten.getMolten(2304)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_UHV) + .addTo(assemblerRecipes); + // Dynamo UEV 64A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.WetTransformer_UIV_UEV.get(1), + CustomItemList.eM_dynamoMulti16_UEV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt12, Materials.Draconium, 2), + GTOreDictUnificator.get( + OrePrefixes.plate, + BaseRecipeLoader.getOrDefault("Bedrockium", Materials.Neutronium), + 6)) + .itemOutputs(CustomItemList.eM_dynamoMulti64_UEV.get(1)) + .fluidInputs(Materials.Tungsten.getMolten(4608)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_UHV) + .addTo(assemblerRecipes); + // Dynamo UIV 64A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.WetTransformer_UMV_UIV.get(1), + CustomItemList.eM_dynamoMulti16_UIV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt12, Materials.NetherStar, 2), + GTOreDictUnificator.get( + OrePrefixes.plate, + BaseRecipeLoader.getOrDefault("BlackPlutonium", Materials.Neutronium), + 6)) + .itemOutputs(CustomItemList.eM_dynamoMulti64_UIV.get(1)) + .fluidInputs(Materials.Tungsten.getMolten(9216)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_UEV) + .addTo(assemblerRecipes); + // Dynamo UMV 64A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.WetTransformer_UXV_UMV.get(1), + CustomItemList.eM_dynamoMulti16_UMV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt12, Materials.Quantium, 2), + GTOreDictUnificator.get(OrePrefixes.plate, MaterialsUEVplus.SpaceTime, 6)) + .itemOutputs(CustomItemList.eM_dynamoMulti64_UMV.get(1)) + .fluidInputs(Materials.Tungsten.getMolten(9216)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_UIV) + .addTo(assemblerRecipes); + // Dynamo UXV 64A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.WetTransformer_MAX_UXV.get(1), + CustomItemList.eM_dynamoMulti16_UXV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt12, Materials.BlackPlutonium, 2), + GTOreDictUnificator + .get(OrePrefixes.plate, MaterialsUEVplus.MagnetohydrodynamicallyConstrainedStarMatter, 3), + GTOreDictUnificator.get("plateShirabon", 3L)) + .itemOutputs(CustomItemList.eM_dynamoMulti64_UXV.get(1)) + .fluidInputs(Materials.Tungsten.getMolten(9216)) + .duration(20 * SECONDS) + .eut((int) TierEU.RECIPE_UMV) + .addTo(assemblerRecipes); + + } + } + + // Energy Hatches + { + // Energy Hatches 4A + { + // Energy Hatch EV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Energy_EV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.Aluminium, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Titanium, 2)) + .itemOutputs(CustomItemList.eM_energyMulti4_EV.get(1)) + .fluidInputs(Materials.Silver.getMolten(144)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // Energy Hatch IV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Energy_IV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.Tungsten, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.TungstenSteel, 2)) + .itemOutputs(CustomItemList.eM_energyMulti4_IV.get(1)) + .fluidInputs(Materials.Silver.getMolten(144)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + // Energy Hatch LuV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Energy_LuV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.VanadiumGallium, 2), + GTOreDictUnificator.get( + OrePrefixes.plate, + BaseRecipeLoader.getOrDefault("Rhodium-PlatedPalladium", Materials.Chrome), + 2)) + .itemOutputs(CustomItemList.eM_energyMulti4_LuV.get(1)) + .fluidInputs(Materials.Silver.getMolten(288)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + // Energy Hatch ZPM 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Energy_ZPM.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.Naquadah, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Iridium, 2)) + .itemOutputs(CustomItemList.eM_energyMulti4_ZPM.get(1)) + .fluidInputs(Materials.Silver.getMolten(576)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(assemblerRecipes); + // Energy Hatch UV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Energy_UV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.NaquadahAlloy, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Osmium, 2)) + .itemOutputs(CustomItemList.eM_energyMulti4_UV.get(1)) + .fluidInputs(Materials.Silver.getMolten(1152)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .addTo(assemblerRecipes); + // Energy Hatch UHV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Energy_UHV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorUHV, 2), + GTOreDictUnificator.get(OrePrefixes.plate, Materials.Neutronium, 2)) + .itemOutputs(CustomItemList.eM_energyMulti4_UHV.get(1)) + .fluidInputs(Materials.Silver.getMolten(2304)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_UV) + .addTo(assemblerRecipes); + // Energy Hatch UEV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Energy_UEV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.Draconium, 2), + GTOreDictUnificator.get( + OrePrefixes.plate, + BaseRecipeLoader.getOrDefault("Bedrockium", Materials.Neutronium), + 2)) + .itemOutputs(CustomItemList.eM_energyMulti4_UEV.get(1)) + .fluidInputs(Materials.Silver.getMolten(4608)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_UHV) + .addTo(assemblerRecipes); + // Energy Hatch UIV 4A + GTValues.RA.stdBuilder() + .itemInputs( + ItemList.Hatch_Energy_UIV.get(1), + GTOreDictUnificator.get(OrePrefixes.wireGt04, Materials.NetherStar, 2), + GTOreDictUnificator.get( +