From ca2ebd4bd1887d32dab8c9c23b419c617a1b4f58 Mon Sep 17 00:00:00 2001 From: boubou19 Date: Tue, 18 Jul 2023 17:52:23 +0200 Subject: Added machine type on single block tooltips (#2138) * change tooltips * put machine types together * Added constructor to accept multi line tooltip on sbs * sorting machine registering methods * update MachineType * migrate machines to multiline description * add new constructor for matter amplifier * migrate matter amplifier to multi line tooltip * spotless apply * Capitalize machine types * breakdown large run methods into themed methods * migrate TE IDs to an enum (1/?) * spotless apply * migrate TE IDs to an enum (2/?) * migrate TE IDs to an enum (3/?) * migrate TE IDs to an enum (4/?) * spotless apply * sorting crafting recipes by type + fix meta id typo * migrate TE IDs to an enum(5/?) * spotless apply * merge master (#2143) * Make structure tooltips more colorful (#2133) * default color changes * add colored casing amount builders * oversight * address reviews * GPL Special Item access (#2134) * Added getters to allow a machine to set the special item for recipe checking * Changes to ore factorys running mode description (#2135) * Changes the integrated ore factory mode description to match what its actually doing. * Some tooltip grammar changes. That would have annoyed me :) * Enable void protection for PA (#2136) * Added ofNoOverclock builder that accepts eut and duration (#2140) * Fix findRecipe might limit stack size by 64 (#2139) * Fix potential issue with applecore ItemFoodProxy (#2137) * Fix potential issue with applecore ItemFoodProxy * Fix the worst class loader issue ive ever encountered --------- Co-authored-by: GDCloud <93287602+GDCloudstrike@users.noreply.github.com> Co-authored-by: Maxim Co-authored-by: Lyfts <127234178+Lyfts@users.noreply.github.com> Co-authored-by: miozune Co-authored-by: Serenibyss <10861407+serenibyss@users.noreply.github.com> * Moved machine type and descriptions to lang files * Removed redundant visibility modifier * Only expose translated descriptions * Using prefix gt.recipe for NEI compatibility * Deprecate use of LanguageManager in GT_Recipe_Map * Unify GT_Recipe and MachineType localization * Electromagnetic Polarizer consistency with Separator * Added Packager MachineType * Added Scanner MachineType * Added Rock breaker MachineType * Added Mass Fabricator MachineType * Added Replicator MachineType * Added "Machine Type" tooltip to steam machines * public modifier unnecessary * Spotless apply --------- Co-authored-by: minecraft7771 Co-authored-by: Martin Robertz Co-authored-by: GDCloud <93287602+GDCloudstrike@users.noreply.github.com> Co-authored-by: Lyfts <127234178+Lyfts@users.noreply.github.com> Co-authored-by: miozune Co-authored-by: Serenibyss <10861407+serenibyss@users.noreply.github.com> Co-authored-by: YannickMG --- .../preload/GT_Loader_MetaTileEntities.java | 3137 ++++++++++++-------- 1 file changed, 1871 insertions(+), 1266 deletions(-) (limited to 'src/main/java/gregtech/loaders/preload') diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java b/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java index 4795f96769..c6b7afff26 100644 --- a/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java @@ -1,5 +1,6 @@ package gregtech.loaders.preload; +import static gregtech.api.enums.MetaTileEntityIDs.*; import static gregtech.api.enums.Mods.Forestry; import net.minecraft.util.EnumChatFormatting; @@ -353,501 +354,1671 @@ public class GT_Loader_MetaTileEntities implements Runnable { // TODO CHECK CIRC + EnumChatFormatting.RESET + " to use this."; - private static void run1() { + private static void registerMultiblockControllers() { + ItemList.Machine_Bricked_BlastFurnace.set( + new GT_MetaTileEntity_BrickedBlastFurnace( + BRICKED_BLAST_FURNACE_CONTROLLER.ID, + "multimachine.brickedblastfurnace", + "Bricked Blast Furnace").getStackForm(1L)); + + // deprecated since ages, maybe time to remove it from the game? + ItemList.Machine_Bronze_BlastFurnace.set( + new GT_MetaTileEntity_BronzeBlastFurnace( + BRONZE_BLAST_FURNACE_CONTROLLER.ID, + "bronzemachine.blastfurnace", + "Bronze Plated Blast Furnace").getStackForm(1L)); + + ItemList.Machine_Multi_BlastFurnace.set( + new GT_MetaTileEntity_ElectricBlastFurnace( + EBF_CONTROLLER.ID, + "multimachine.blastfurnace", + "Electric Blast Furnace").getStackForm(1L)); + ItemList.Machine_Multi_ImplosionCompressor.set( + new GT_MetaTileEntity_ImplosionCompressor( + IMPLOSION_COMPRESSOR_CONTROLLER.ID, + "multimachine.implosioncompressor", + "Implosion Compressor").getStackForm(1L)); + ItemList.Machine_Multi_VacuumFreezer.set( + new GT_MetaTileEntity_VacuumFreezer( + VACUUM_FREEZER_CONTROLLER.ID, + "multimachine.vacuumfreezer", + "Vacuum Freezer").getStackForm(1L)); + ItemList.Machine_Multi_Furnace.set( + new GT_MetaTileEntity_MultiFurnace( + MULTI_SMELTER_CONTROLLER.ID, + "multimachine.multifurnace", + "Multi Smelter").getStackForm(1L)); + ItemList.Machine_Multi_PlasmaForge.set( + new GT_MetaTileEntity_PlasmaForge( + DTPF_CONTROLLER.ID, + "multimachine.plasmaforge", + "Dimensionally Transcendent Plasma Forge").getStackForm(1L)); + + ItemList.Machine_Multi_LargeBoiler_Bronze.set( + new GT_MetaTileEntity_LargeBoiler_Bronze( + LARGE_BRONZE_BOILER_CONTROLLER.ID, + "multimachine.boiler.bronze", + "Large Bronze Boiler").getStackForm(1L)); + ItemList.Machine_Multi_LargeBoiler_Steel.set( + new GT_MetaTileEntity_LargeBoiler_Steel( + LARGE_STEEL_BOILER_CONTROLLER.ID, + "multimachine.boiler.steel", + "Large Steel Boiler").getStackForm(1L)); + ItemList.Machine_Multi_LargeBoiler_Titanium.set( + new GT_MetaTileEntity_LargeBoiler_Titanium( + LARGE_TITANIUM_BOILER_CONTROLLER.ID, + "multimachine.boiler.titanium", + "Large Titanium Boiler").getStackForm(1L)); + ItemList.Machine_Multi_LargeBoiler_TungstenSteel.set( + new GT_MetaTileEntity_LargeBoiler_TungstenSteel( + LARGE_TUNGSTENSTEEL_BOILER_CONTROLLER.ID, + "multimachine.boiler.tungstensteel", + "Large Tungstensteel Boiler").getStackForm(1L)); + + ItemList.FusionComputer_LuV.set( + new GT_MetaTileEntity_FusionComputer1( + FUSION_CONTROLLER_MKI.ID, + "fusioncomputer.tier.06", + "Fusion Control Computer Mark I").getStackForm(1L)); + ItemList.FusionComputer_ZPMV.set( + new GT_MetaTileEntity_FusionComputer2( + FUSION_CONTROLLER_MKII.ID, + "fusioncomputer.tier.07", + "Fusion Control Computer Mark II").getStackForm(1L)); + ItemList.FusionComputer_UV.set( + new GT_MetaTileEntity_FusionComputer3( + FUSION_CONTROLLER_MKIII.ID, + "fusioncomputer.tier.08", + "Fusion Control Computer Mark III").getStackForm(1L)); + + ItemList.Processing_Array.set( + new GT_MetaTileEntity_ProcessingArray( + PROCESSING_ARRAY_CONTROLLER.ID, + "multimachine.processingarray", + "Processing Array").getStackForm(1L)); + ItemList.Distillation_Tower.set( + new GT_MetaTileEntity_DistillationTower( + DISTILLATION_TOWER_CONTROLLER.ID, + "multimachine.distillationtower", + "Distillation Tower").getStackForm(1L)); + ItemList.Ore_Processor.set( + new GT_MetaTileEntity_IntegratedOreFactory( + INTEGRATED_ORE_FACTORY_CONTROLLER.ID, + "multimachine.oreprocessor", + "Integrated Ore Factory").getStackForm(1L)); + + ItemList.LargeSteamTurbine.set( + new GT_MetaTileEntity_LargeTurbine_Steam( + LARGE_STEAM_TURBINE_CONTROLLER.ID, + "multimachine.largeturbine", + "Large Steam Turbine").getStackForm(1L)); + ItemList.LargeGasTurbine.set( + new GT_MetaTileEntity_LargeTurbine_Gas( + LARGE_GAS_TURBINE_CONTROLLER.ID, + "multimachine.largegasturbine", + "Large Gas Turbine").getStackForm(1L)); + ItemList.LargeHPSteamTurbine.set( + new GT_MetaTileEntity_LargeTurbine_HPSteam( + LARGE_HP_STEAM_TURBINE_CONTROLLER.ID, + "multimachine.largehpturbine", + "Large HP Steam Turbine").getStackForm(1L)); + ItemList.LargeAdvancedGasTurbine.set( + new GT_MetaTileEntity_LargeTurbine_GasAdvanced( + LARGE_ADVANCED_GAS_TURBINE_CONTROLLER.ID, + "multimachine.largeadvancedgasturbine", + "Large Advanced Gas Turbine").getStackForm(1L)); + ItemList.Machine_Multi_TranscendentPlasmaMixer.set( + new GT_MetaTileEntity_TranscendentPlasmaMixer( + TRANSCENDENT_PLASMA_MIXER_CONTROLLER.ID, + "multimachine.transcendentplasmamixer", + "Transcendent Plasma Mixer").getStackForm(1)); + + ItemList.LargePlasmaTurbine.set( + new GT_MetaTileEntity_LargeTurbine_Plasma( + LARGE_PLASMA_TURBINE_CONTROLLER.ID, + "multimachine.largeplasmaturbine", + "Large Plasma Generator").getStackForm(1L)); + ItemList.Machine_Multi_HeatExchanger.set( + new GT_MetaTileEntity_HeatExchanger( + LARGE_HEAT_EXCHANGER_CONTROLLER.ID, + "multimachine.heatexchanger", + "Large Heat Exchanger").getStackForm(1L)); + ItemList.Charcoal_Pile.set( + new GT_MetaTileEntity_Charcoal_Pit( + CHARCOAL_PILE_IGNITER_CONTROLLER.ID, + "multimachine.charcoalpile", + "Charcoal Pile Igniter").getStackForm(1)); + + // Converter recipes in case you had old one lying around + ItemList.OilDrill1.set( + new GT_MetaTileEntity_OilDrill1( + MULTIBLOCK_PUMP_MKI_CONTROLLER.ID, + "multimachine.oildrill1", + "Oil/Gas/Fluid Drilling Rig").getStackForm(1)); + ItemList.OilDrill2.set( + new GT_MetaTileEntity_OilDrill2( + MULTILOCK_PUMP_MKII_CONTROLLER.ID, + "multimachine.oildrill2", + "Oil/Gas/Fluid Drilling Rig II").getStackForm(1)); + ItemList.OilDrill3.set( + new GT_MetaTileEntity_OilDrill3( + MULTILOCK_PUMP_MKIII_CONTROLLER.ID, + "multimachine.oildrill3", + "Oil/Gas/Fluid Drilling Rig III").getStackForm(1)); + ItemList.OilDrill4.set( + new GT_MetaTileEntity_OilDrill4( + MULTILOCK_PUMP_MKIV_CONTROLLER.ID, + "multimachine.oildrill4", + "Oil/Gas/Fluid Drilling Rig IV").getStackForm(1)); + ItemList.OilDrillInfinite.set( + new GT_MetaTileEntity_OilDrillInfinite( + MULTIBLOCK_PUMP_INFINITE_CONTROLLER.ID, + "multimachine.oildrillinfinite", + "Infinite Oil/Gas/Fluid Drilling Rig").getStackForm(1)); + + ItemList.ConcreteBackfiller1.set( + new GT_MetaTileEntity_ConcreteBackfiller1( + CONCRETE_BACKFILLER_I_CONTROLLER.ID, + "multimachine.concretebackfiller1", + "Concrete Backfiller").getStackForm(1)); + ItemList.ConcreteBackfiller2.set( + new GT_MetaTileEntity_ConcreteBackfiller2( + CONCRETE_BACKFILLER_II_CONTROLLER.ID, + "multimachine.concretebackfiller3", + "Advanced Concrete Backfiller").getStackForm(1)); + ItemList.OreDrill1.set( + new GT_MetaTileEntity_OreDrillingPlant1( + ORE_DRILL_MKI_CONTROLLER.ID, + "multimachine.oredrill1", + "Ore Drilling Plant").getStackForm(1)); + ItemList.OreDrill2.set( + new GT_MetaTileEntity_OreDrillingPlant2( + ORE_DRILL_MKII_CONTROLLER.ID, + "multimachine.oredrill2", + "Ore Drilling Plant II").getStackForm(1)); + ItemList.OreDrill3.set( + new GT_MetaTileEntity_OreDrillingPlant3( + ORE_DRILL_MKIII_CONTROLLER.ID, + "multimachine.oredrill3", + "Ore Drilling Plant III").getStackForm(1)); + ItemList.OreDrill4.set( + new GT_MetaTileEntity_OreDrillingPlant4( + ORE_DRILL_MKIV_CONTROLLER.ID, + "multimachine.oredrill4", + "Ore Drilling Plant IV").getStackForm(1)); + + ItemList.PyrolyseOven.set( + new GT_MetaTileEntity_PyrolyseOven(PYROLYSE_OVEN_CONTROLLER.ID, "multimachine.pyro", "Pyrolyse Oven") + .getStackForm(1)); + ItemList.OilCracker.set( + new GT_MetaTileEntity_OilCracker(OIL_CRACKER_CONTROLLER.ID, "multimachine.cracker", "Oil Cracking Unit") + .getStackForm(1)); + + ItemList.Machine_Multi_Assemblyline.set( + new GT_MetaTileEntity_AssemblyLine( + ASSEMBLING_LINE_CONTROLLER.ID, + "multimachine.assemblyline", + "Assembling Line").getStackForm(1L)); + ItemList.Machine_Multi_DieselEngine.set( + new GT_MetaTileEntity_DieselEngine( + COMBUSTION_ENGINE_CONTROLLER.ID, + "multimachine.dieselengine", + "Combustion Engine").getStackForm(1L)); + ItemList.Machine_Multi_ExtremeDieselEngine.set( + new GT_MetaTileEntity_ExtremeDieselEngine( + EXTREME_COMBUSTION_ENGINE_CONTROLLER.ID, + "multimachine.extremedieselengine", + "Extreme Combustion Engine").getStackForm(1L)); + ItemList.Machine_Multi_Cleanroom.set( + new GT_MetaTileEntity_Cleanroom(CLEANROOM_CONTROLLER.ID, "multimachine.cleanroom", "Cleanroom Controller") + .getStackForm(1)); + + ItemList.Machine_Multi_LargeChemicalReactor.set( + new GT_MetaTileEntity_LargeChemicalReactor( + LCR_CONTROLLER.ID, + "multimachine.chemicalreactor", + "Large Chemical Reactor").getStackForm(1)); + ItemList.PCBFactory.set( + new GT_MetaTileEntity_PCBFactory(PCB_FACTORY_CONTROLLER.ID, "multimachine.pcbfactory", "PCB Factory") + .getStackForm(1)); + ItemList.NanoForge.set( + new GT_MetaTileEntity_NanoForge(NANO_FORGE_CONTROLLER.ID, "multimachine.nanoforge", "Nano Forge") + .getStackForm(1)); + + } + + private static void registerSteamMachines() { + ItemList.Machine_Bronze_Furnace.set( + new GT_MetaTileEntity_Furnace_Bronze(STEAM_FURNACE.ID, "bronzemachine.furnace", "Steam Furnace") + .getStackForm(1L)); + ItemList.Machine_Bronze_Macerator.set( + new GT_MetaTileEntity_Macerator_Bronze(STEAM_MACERATOR.ID, "bronzemachine.macerator", "Steam Macerator") + .getStackForm(1L)); + ItemList.Machine_Bronze_Extractor.set( + new GT_MetaTileEntity_Extractor_Bronze(STEAM_EXTRACTOR.ID, "bronzemachine.extractor", "Steam Extractor") + .getStackForm(1L)); + ItemList.Machine_Bronze_Hammer.set( + new GT_MetaTileEntity_ForgeHammer_Bronze( + STEAM_FORGE_HAMMER.ID, + "bronzemachine.hammer", + "Steam Forge Hammer").getStackForm(1L)); + ItemList.Machine_Bronze_Compressor.set( + new GT_MetaTileEntity_Compressor_Bronze(STEAM_COMPRESSOR.ID, "bronzemachine.compressor", "Steam Compressor") + .getStackForm(1L)); + ItemList.Machine_Bronze_AlloySmelter.set( + new GT_MetaTileEntity_AlloySmelter_Bronze( + STEAM_ALLOY_SMELTER.ID, + "bronzemachine.alloysmelter", + "Steam Alloy Smelter").getStackForm(1L)); + + } + + private static void registerHPSteamMachines() { + ItemList.Machine_HP_Extractor.set( + new GT_MetaTileEntity_Extractor_Steel( + HP_STEAM_EXTRACTOR.ID, + "hpmachine.extractor", + "High Pressure Extractor").getStackForm(1L)); + ItemList.Machine_HP_Furnace.set( + new GT_MetaTileEntity_Furnace_Steel(HP_STEAM_FURNACE.ID, "hpmachine.furnace", "High Pressure Furnace") + .getStackForm(1L)); + ItemList.Machine_HP_Macerator.set( + new GT_MetaTileEntity_Macerator_Steel( + HP_STEAM_MACERATOR.ID, + "hpmachine.macerator", + "High Pressure Macerator").getStackForm(1L)); + ItemList.Machine_HP_Hammer.set( + new GT_MetaTileEntity_ForgeHammer_Steel( + HP_STEAM_FORGE_HAMMER.ID, + "hpmachine.hammer", + "High Pressure Forge Hammer").getStackForm(1L)); + ItemList.Machine_HP_Compressor.set( + new GT_MetaTileEntity_Compressor_Steel( + HP_STEAM_COMPRESSOR.ID, + "hpmachine.compressor", + "High Pressure Compressor").getStackForm(1L)); + ItemList.Machine_HP_AlloySmelter.set( + new GT_MetaTileEntity_AlloySmelter_Steel( + HP_STEAM_ALLOY_SMELTER.ID, + "hpmachine.alloysmelter", + "High Pressure Alloy Smelter").getStackForm(1L)); + } + + private static void registerLocker() { + ItemList.Locker_ULV.set( + new GT_MetaTileEntity_Locker(LOCKER_ULV.ID, "locker.tier.00", "Ultra Low Voltage Locker", 0) + .getStackForm(1L)); + ItemList.Locker_LV.set( + new GT_MetaTileEntity_Locker(LOCKER_LV.ID, "locker.tier.01", "Low Voltage Locker", 1).getStackForm(1L)); + ItemList.Locker_MV.set( + new GT_MetaTileEntity_Locker(LOCKER_MV.ID, "locker.tier.02", "Medium Voltage Locker", 2).getStackForm(1L)); + ItemList.Locker_HV.set( + new GT_MetaTileEntity_Locker(LOCKER_HV.ID, "locker.tier.03", "High Voltage Locker", 3).getStackForm(1L)); + ItemList.Locker_EV.set( + new GT_MetaTileEntity_Locker(LOCKER_EV.ID, "locker.tier.04", "Extreme Voltage Locker", 4).getStackForm(1L)); + ItemList.Locker_IV.set( + new GT_MetaTileEntity_Locker(LOCKER_IV.ID, "locker.tier.05", "Insane Voltage Locker", 5).getStackForm(1L)); + ItemList.Locker_LuV.set( + new GT_MetaTileEntity_Locker(LOCKER_LuV.ID, "locker.tier.06", "Ludicrous Voltage Locker", 6) + .getStackForm(1L)); + ItemList.Locker_ZPM.set( + new GT_MetaTileEntity_Locker(LOCKER_ZPM.ID, "locker.tier.07", "ZPM Voltage Locker", 7).getStackForm(1L)); + ItemList.Locker_UV.set( + new GT_MetaTileEntity_Locker(LOCKER_UV.ID, "locker.tier.08", "Ultimate Voltage Locker", 8) + .getStackForm(1L)); + ItemList.Locker_MAX.set( + new GT_MetaTileEntity_Locker(LOCKER_UHV.ID, "locker.tier.09", "Highly Ultimate Voltage Locker", 9) + .getStackForm(1L)); + } + + private static void registerScanner() { + ItemList.Machine_LV_Scanner.set( + new GT_MetaTileEntity_Scanner(SCANNER_LV.ID, "basicmachine.scanner.tier.01", "Basic Scanner", 1) + .getStackForm(1L)); + ItemList.Machine_MV_Scanner.set( + new GT_MetaTileEntity_Scanner(SCANNER_MV.ID, "basicmachine.scanner.tier.02", "Advanced Scanner", 2) + .getStackForm(1L)); + ItemList.Machine_HV_Scanner.set( + new GT_MetaTileEntity_Scanner(SCANNER_HV.ID, "basicmachine.scanner.tier.03", "Advanced Scanner II", 3) + .getStackForm(1L)); + ItemList.Machine_EV_Scanner.set( + new GT_MetaTileEntity_Scanner(SCANNER_EV.ID, "basicmachine.scanner.tier.04", "Advanced Scanner III", 4) + .getStackForm(1L)); + ItemList.Machine_IV_Scanner.set( + new GT_MetaTileEntity_Scanner(SCANNER_IV.ID, "basicmachine.scanner.tier.05", "Advanced Scanner IV", 5) + .getStackForm(1L)); + } + + private static void registerPackager() { + ItemList.Machine_LV_Boxinator.set( + new GT_MetaTileEntity_Boxinator(PACKAGER_LV.ID, "basicmachine.boxinator.tier.01", "Basic Packager", 1) + .getStackForm(1L)); + ItemList.Machine_MV_Boxinator.set( + new GT_MetaTileEntity_Boxinator(PACKAGER_MV.ID, "basicmachine.boxinator.tier.02", "Advanced Packager", 2) + .getStackForm(1L)); + ItemList.Machine_HV_Boxinator.set( + new GT_MetaTileEntity_Boxinator(PACKAGER_HV.ID, "basicmachine.boxinator.tier.03", "Advanced Packager II", 3) + .getStackForm(1L)); + ItemList.Machine_EV_Boxinator.set( + new GT_MetaTileEntity_Boxinator( + PACKAGER_EV.ID, + "basicmachine.boxinator.tier.04", + "Advanced Packager III", + 4).getStackForm(1L)); + ItemList.Machine_IV_Boxinator.set( + new GT_MetaTileEntity_Boxinator(PACKAGER_IV.ID, "basicmachine.boxinator.tier.05", "Boxinator", 5) + .getStackForm(1L)); + ItemList.Machine_LuV_Boxinator.set( + new GT_MetaTileEntity_Boxinator(PACKAGER_LuV.ID, "basicmachine.boxinator.tier.06", "Boxinator", 6) + .getStackForm(1L)); + ItemList.Machine_ZPM_Boxinator.set( + new GT_MetaTileEntity_Boxinator(PACKAGER_ZPM.ID, "basicmachine.boxinator.tier.07", "Boxinator", 7) + .getStackForm(1L)); + ItemList.Machine_UV_Boxinator.set( + new GT_MetaTileEntity_Boxinator(PACKAGER_UV.ID, "basicmachine.boxinator.tier.08", "Boxinator", 8) + .getStackForm(1L)); + } + + private static void registerRockBreaker() { + ItemList.Machine_LV_RockBreaker.set( + new GT_MetaTileEntity_RockBreaker( + ROCK_BREAKER_LV.ID, + "basicmachine.rockbreaker.tier.01", + "Basic Rock Breaker", + 1).getStackForm(1L)); + ItemList.Machine_MV_RockBreaker.set( + new GT_MetaTileEntity_RockBreaker( + ROCK_BREAKER_MV.ID, + "basicmachine.rockbreaker.tier.02", + "Advanced Rock Breaker", + 2).getStackForm(1L)); + ItemList.Machine_HV_RockBreaker.set( + new GT_MetaTileEntity_RockBreaker( + ROCK_BREAKER_HV.ID, + "basicmachine.rockbreaker.tier.03", + "Advanced Rock Breaker II", + 3).getStackForm(1L)); + ItemList.Machine_EV_RockBreaker.set( + new GT_MetaTileEntity_RockBreaker( + ROCK_BREAKER_EV.ID, + "basicmachine.rockbreaker.tier.04", + "Advanced Rock Breaker III", + 4).getStackForm(1L)); + ItemList.Machine_IV_RockBreaker.set( + new GT_MetaTileEntity_RockBreaker( + ROCK_BREAKER_IV.ID, + "basicmachine.rockbreaker.tier.05", + "Cryogenic Magma Solidifier R-8200", + 5).getStackForm(1L)); + } + + private static void registerIndustrialApiary() { + if (Forestry.isModLoaded()) { + ItemList.Machine_IndustrialApiary.set( + new GT_MetaTileEntity_IndustrialApiary( + INDUSTRIAL_APIARY.ID, + "basicmachine.industrialapiary", + "Industrial Apiary", + 8).getStackForm(1L)); + } + } + + private static void registerMassFab() { + ItemList.Machine_LV_Massfab.set( + new GT_MetaTileEntity_Massfabricator( + MASS_FABRICATOR_LV.ID, + "basicmachine.massfab.tier.01", + "Basic Mass Fabricator", + 1).getStackForm(1L)); + ItemList.Machine_MV_Massfab.set( + new GT_MetaTileEntity_Massfabricator( + MASS_FABRICATOR_MV.ID, + "basicmachine.massfab.tier.02", + "Advanced Mass Fabricator", + 2).getStackForm(1L)); + ItemList.Machine_HV_Massfab.set( + new GT_MetaTileEntity_Massfabricator( + MASS_FABRICATOR_HV.ID, + "basicmachine.massfab.tier.03", + "Advanced Mass Fabricator II", + 3).getStackForm(1L)); + ItemList.Machine_EV_Massfab.set( + new GT_MetaTileEntity_Massfabricator( + MASS_FABRICATOR_EV.ID, + "basicmachine.massfab.tier.04", + "Advanced Mass Fabricator III", + 4).getStackForm(1L)); + ItemList.Machine_IV_Massfab.set( + new GT_MetaTileEntity_Massfabricator( + MASS_FABRICATOR_IV.ID, + "basicmachine.massfab.tier.05", + "Advanced Mass Fabricator IV", + 5).getStackForm(1L)); + } + + private static void registerReplicator() { + ItemList.Machine_LV_Replicator.set( + new GT_MetaTileEntity_Replicator(REPLICATOR_LV.ID, "basicmachine.replicator.tier.01", "Basic Replicator", 1) + .getStackForm(1L)); + ItemList.Machine_MV_Replicator.set( + new GT_MetaTileEntity_Replicator( + REPLICATOR_MV.ID, + "basicmachine.replicator.tier.02", + "Advanced Replicator", + 2).getStackForm(1L)); + ItemList.Machine_HV_Replicator.set( + new GT_MetaTileEntity_Replicator( + REPLICATOR_HV.ID, + "basicmachine.replicator.tier.03", + "Advanced Replicator II", + 3).getStackForm(1L)); + ItemList.Machine_EV_Replicator.set( + new GT_MetaTileEntity_Replicator( + REPLICATOR_EV.ID, + "basicmachine.replicator.tier.04", + "Advanced Replicator III", + 4).getStackForm(1L)); + ItemList.Machine_IV_Replicator.set( + new GT_MetaTileEntity_Replicator( + REPLICATOR_IV.ID, + "basicmachine.replicator.tier.05", + "Advanced Replicator IV", + 5).getStackForm(1L)); + } + + private static void registerBrewery() { + ItemList.Machine_LV_Brewery.set( + new GT_MetaTileEntity_PotionBrewer(BREWERY_LV.ID, "basicmachine.brewery.tier.01", "Basic Brewery", 1) + .getStackForm(1L)); + ItemList.Machine_MV_Brewery.set( + new GT_MetaTileEntity_PotionBrewer(BREWERY_MV.ID, "basicmachine.brewery.tier.02", "Advanced Brewery", 2) + .getStackForm(1L)); + ItemList.Machine_HV_Brewery.set( + new GT_MetaTileEntity_PotionBrewer(BREWERY_HV.ID, "basicmachine.brewery.tier.03", "Advanced Brewery II", 3) + .getStackForm(1L)); + ItemList.Machine_EV_Brewery.set( + new GT_MetaTileEntity_PotionBrewer(BREWERY_EV.ID, "basicmachine.brewery.tier.04", "Advanced Brewery III", 4) + .getStackForm(1L)); + ItemList.Machine_IV_Brewery.set( + new GT_MetaTileEntity_PotionBrewer(BREWERY_IV.ID, "basicmachine.brewery.tier.05", "Advanced Brewery IV", 5) + .getStackForm(1L)); + } + + private static void registerMiner() { + ItemList.Machine_LV_Miner.set( + new GT_MetaTileEntity_Miner(MINER_LV.ID, "basicmachine.miner.tier.01", "Basic Miner", 1).getStackForm(1L)); + ItemList.Machine_MV_Miner.set( + new GT_MetaTileEntity_Miner(MINER_MV.ID, "basicmachine.miner.tier.02", "Good Miner", 2).getStackForm(1L)); + ItemList.Machine_HV_Miner.set( + new GT_MetaTileEntity_Miner(MINER_HV.ID, "basicmachine.miner.tier.03", "Advanced Miner", 3) + .getStackForm(1L)); + } + + private static void registerPump() { + ItemList.Pump_LV + .set(new GT_MetaTileEntity_Pump(PUMP_LV.ID, "basicmachine.pump.tier.01", "Basic Pump", 1).getStackForm(1L)); + ItemList.Pump_MV.set( + new GT_MetaTileEntity_Pump(PUMP_MV.ID, "basicmachine.pump.tier.02", "Advanced Pump", 2).getStackForm(1L)); + ItemList.Pump_HV.set( + new GT_MetaTileEntity_Pump(PUMP_HV.ID, "basicmachine.pump.tier.03", "Advanced Pump II", 3) + .getStackForm(1L)); + ItemList.Pump_EV.set( + new GT_MetaTileEntity_Pump(PUMP_EV.ID, "basicmachine.pump.tier.04", "Advanced Pump III", 4) + .getStackForm(1L)); + ItemList.Pump_IV.set( + new GT_MetaTileEntity_Pump(PUMP_IV.ID, "basicmachine.pump.tier.05", "Advanced Pump IV", 5) + .getStackForm(1L)); + } + + private static void registerTeleporter() { + ItemList.Teleporter.set( + new GT_MetaTileEntity_Teleporter(TELEPORTER.ID, "basicmachine.teleporter", "Teleporter", 9) + .getStackForm(1L)); + } + + private static void registerMonsterRepellator() { + ItemList.MobRep_LV.set( + new GT_MetaTileEntity_MonsterRepellent( + MONSTER_REPELLATOR_LV.ID, + "basicmachine.mobrep.tier.01", + "Basic Monster Repellator", + 1).getStackForm(1L)); + ItemList.MobRep_MV.set( + new GT_MetaTileEntity_MonsterRepellent( + MONSTER_REPELLATOR_MV.ID, + "basicmachine.mobrep.tier.02", + "Advanced Monster Repellator", + 2).getStackForm(1L)); + ItemList.MobRep_HV.set( + new GT_MetaTileEntity_MonsterRepellent( + MONSTER_REPELLATOR_HV.ID, + "basicmachine.mobrep.tier.03", + "Advanced Monster Repellator II", + 3).getStackForm(1L)); + ItemList.MobRep_EV.set( + new GT_MetaTileEntity_MonsterRepellent( + MONSTER_REPELLATOR_EV.ID, + "basicmachine.mobrep.tier.04", + "Advanced Monster Repellator III", + 4).getStackForm(1L)); + ItemList.MobRep_IV.set( + new GT_MetaTileEntity_MonsterRepellent( + MONSTER_REPELLATOR_IV.ID, + "basicmachine.mobrep.tier.05", + "Advanced Monster Repellator IV", + 5).getStackForm(1L)); + ItemList.MobRep_LuV.set( + new GT_MetaTileEntity_MonsterRepellent( + MONSTER_REPELLATOR_LuV.ID, + "basicmachine.mobrep.tier.06", + "Advanced Monster Repellator V", + 6).getStackForm(1L)); + ItemList.MobRep_ZPM.set( + new GT_MetaTileEntity_MonsterRepellent( + MONSTER_REPELLATOR_ZPM.ID, + "basicmachine.mobrep.tier.07", + "Advanced Monster Repellator VI", + 7).getStackForm(1L)); + ItemList.MobRep_UV.set( + new GT_MetaTileEntity_MonsterRepellent( + MONSTER_REPELLATOR_UV.ID, + "basicmachine.mobrep.tier.08", + "Advanced Monster Repellator VII", + 8).getStackForm(1L)); + } + + private static void registerSeismicProspector() { + ItemList.Seismic_Prospector_LV.set( + new GT_MetaTileEntity_SeismicProspector( + SEISMIC_PROSPECTOR_LV.ID, + "basicmachine.seismicprospector.01", + "Seismic Prospector LV", + 1).getStackForm(1)); + ItemList.Seismic_Prospector_MV.set( + new GT_MetaTileEntity_SeismicProspector( + SEISMIC_PROSPECTOR_MV.ID, + "basicmachine.seismicprospector.02", + "Seismic Prospector MV", + 2).getStackForm(1)); + ItemList.Seismic_Prospector_HV.set( + new GT_MetaTileEntity_SeismicProspector( + SEISMIC_PROSPECTOR_HV.ID, + "basicmachine.seismicprospector.03", + "Seismic Prospector HV", + 3).getStackForm(1)); + } + + private static void registerAdvancedSeismicProspector() { + ItemList.Seismic_Prospector_Adv_LV.set( + new GT_MetaTileEntity_AdvSeismicProspector( + ADVANCED_SEISMIC_PROSPECTOR_LV.ID, + "basicmachine.seismicprospector.07", + "Advanced Seismic Prospector LV", + 1, + 5 * 16 / 2, + 2).getStackForm(1)); + ItemList.Seismic_Prospector_Adv_MV.set( + new GT_MetaTileEntity_AdvSeismicProspector( + ADVANCED_SEISMIC_PROSPECTOR_MV.ID, + "basicmachine.seismicprospector.06", + "Advanced Seismic Prospector MV", + 2, + 7 * 16 / 2, + 2).getStackForm(1)); + ItemList.Seismic_Prospector_Adv_HV.set( + new GT_MetaTileEntity_AdvSeismicProspector( + ADVANCED_SEISMIC_PROSPECTOR_HV.ID, + "basicmachine.seismicprospector.05", + "Advanced Seismic Prospector HV", + 3, + 9 * 16 / 2, + 2).getStackForm(1)); + ItemList.Seismic_Prospector_Adv_EV.set( + new GT_MetaTileEntity_AdvSeismicProspector( + ADVANCED_SEISMIC_PROSPECTOR_EV.ID, + "basicmachine.seismicprospector.04", + "Advanced Seismic Prospector EV", + 4, + 11 * 16 / 2, + 2).getStackForm(1)); + } + + private static void registerMicrowaveEnergyTransmitter() { + ItemList.MicroTransmitter_HV.set( + new GT_MetaTileEntity_MicrowaveEnergyTransmitter( + MICROWAVE_ENERGY_TRANSMITTER_HV.ID, + "basicmachine.microtransmitter.03", + "HV Microwave Energy Transmitter", + 3).getStackForm(1L)); + ItemList.MicroTransmitter_EV.set( + new GT_MetaTileEntity_MicrowaveEnergyTransmitter( + MICROWAVE_ENERGY_TRANSMITTER_EV.ID, + "basicmachine.microtransmitter.04", + "EV Microwave Energy Transmitter", + 4).getStackForm(1L)); + ItemList.MicroTransmitter_IV.set( + new GT_MetaTileEntity_MicrowaveEnergyTransmitter( + MICROWAVE_ENERGY_TRANSMITTER_IV.ID, + "basicmachine.microtransmitter.05", + "IV Microwave Energy Transmitter", + 5).getStackForm(1L)); + ItemList.MicroTransmitter_LUV.set( + new GT_MetaTileEntity_MicrowaveEnergyTransmitter( + MICROWAVE_ENERGY_TRANSMITTER_LuV.ID, + "basicmachine.microtransmitter.06", + "LuV Microwave Energy Transmitter", + 6).getStackForm(1L)); + ItemList.MicroTransmitter_ZPM.set( + new GT_MetaTileEntity_MicrowaveEnergyTransmitter( + MICROWAVE_ENERGY_TRANSMITTER_ZPM.ID, + "basicmachine.microtransmitter.07", + "ZPM Microwave Energy Transmitter", + 7).getStackForm(1L)); + ItemList.MicroTransmitter_UV.set( + new GT_MetaTileEntity_MicrowaveEnergyTransmitter( + MICROWAVE_ENERGY_TRANSMITTER_UV.ID, + "basicmachine.microtransmitter.08", + "UV Microwave Energy Transmitter", + 8).getStackForm(1L)); + } + + private static void registerChestBuffer() { + ItemList.Automation_ChestBuffer_ULV.set( + new GT_MetaTileEntity_ChestBuffer( + CHEST_BUFFER_ULV.ID, + "automation.chestbuffer.tier.00", + "Ultra Low Voltage Chest Buffer", + 0).getStackForm(1L)); + ItemList.Automation_ChestBuffer_LV.set( + new GT_MetaTileEntity_ChestBuffer( + CHEST_BUFFER_LV.ID, + "automation.chestbuffer.tier.01", + "Low Voltage Chest Buffer", + 1).getStackForm(1L)); + ItemList.Automation_ChestBuffer_MV.set( + new GT_MetaTileEntity_ChestBuffer( + CHEST_BUFFER_MV.ID, + "automation.chestbuffer.tier.02", + "Medium Voltage Chest Buffer", + 2).getStackForm(1L)); + ItemList.Automation_ChestBuffer_HV.set( + new GT_MetaTileEntity_ChestBuffer( + CHEST_BUFFER_HV.ID, + "automation.chestbuffer.tier.03", + "High Voltage Chest Buffer", + 3).getStackForm(1L)); + ItemList.Automation_ChestBuffer_EV.set( + new GT_MetaTileEntity_ChestBuffer( + CHEST_BUFFER_EV.ID, + "automation.chestbuffer.tier.04", + "Extreme Voltage Chest Buffer", + 4).getStackForm(1L)); + ItemList.Automation_ChestBuffer_IV.set( + new GT_MetaTileEntity_ChestBuffer( + CHEST_BUFFER_IV.ID, + "automation.chestbuffer.tier.05", + "Insane Voltage Chest Buffer", + 5).getStackForm(1L)); + ItemList.Automation_ChestBuffer_LuV.set( + new GT_MetaTileEntity_ChestBuffer( + CHEST_BUFFER_LuV.ID, + "automation.chestbuffer.tier.06", + "Ludicrous Voltage Chest Buffer", + 6).getStackForm(1L)); + ItemList.Automation_ChestBuffer_ZPM.set( + new GT_MetaTileEntity_ChestBuffer( + CHEST_BUFFER_ZPM.ID, + "automation.chestbuffer.tier.07", + "ZPM Voltage Chest Buffer", + 7).getStackForm(1L)); + ItemList.Automation_ChestBuffer_UV.set( + new GT_MetaTileEntity_ChestBuffer( + CHEST_BUFFER_UV.ID, + "automation.chestbuffer.tier.08", + "Ultimate Voltage Chest Buffer", + 8).getStackForm(1L)); + ItemList.Automation_ChestBuffer_MAX.set( + new GT_MetaTileEntity_ChestBuffer( + CHEST_BUFFER_UHV.ID, + "automation.chestbuffer.tier.09", + "Highly Ultimate Voltage Chest Buffer", + 9).getStackForm(1L)); + } - ItemList.Machine_Bricked_BlastFurnace.set( - new GT_MetaTileEntity_BrickedBlastFurnace(140, "multimachine.brickedblastfurnace", "Bricked Blast Furnace") + private static void registerItemFilter() { + ItemList.Automation_Filter_ULV.set( + new GT_MetaTileEntity_Filter( + ITEM_FILTER_ULV.ID, + "automation.filter.tier.00", + "Ultra Low Voltage Item Filter", + 0).getStackForm(1L)); + ItemList.Automation_Filter_LV.set( + new GT_MetaTileEntity_Filter(ITEM_FILTER_LV.ID, "automation.filter.tier.01", "Low Voltage Item Filter", 1) .getStackForm(1L)); - ItemList.Hull_Bronze.set( - new GT_MetaTileEntity_BasicHull_Bronze(1, "hull.bronze", "Bronze Hull", 0, "For your first Steam Machines") + ItemList.Automation_Filter_MV.set( + new GT_MetaTileEntity_Filter( + ITEM_FILTER_MV.ID, + "automation.filter.tier.02", + "Medium Voltage Item Filter", + 2).getStackForm(1L)); + ItemList.Automation_Filter_HV.set( + new GT_MetaTileEntity_Filter(ITEM_FILTER_HV.ID, "automation.filter.tier.03", "High Voltage Item Filter", 3) + .getStackForm(1L)); + ItemList.Automation_Filter_EV.set( + new GT_MetaTileEntity_Filter( + ITEM_FILTER_EV.ID, + "automation.filter.tier.04", + "Extreme Voltage Item Filter", + 4).getStackForm(1L)); + ItemList.Automation_Filter_IV.set( + new GT_MetaTileEntity_Filter( + ITEM_FILTER_IV.ID, + "automation.filter.tier.05", + "Insane Voltage Item Filter", + 5).getStackForm(1L)); + ItemList.Automation_Filter_LuV.set( + new GT_MetaTileEntity_Filter( + ITEM_FILTER_LuV.ID, + "automation.filter.tier.06", + "Ludicrous Voltage Item Filter", + 6).getStackForm(1L)); + ItemList.Automation_Filter_ZPM.set( + new GT_MetaTileEntity_Filter(ITEM_FILTER_ZPM.ID, "automation.filter.tier.07", "ZPM Voltage Item Filter", 7) .getStackForm(1L)); + ItemList.Automation_Filter_UV.set( + new GT_MetaTileEntity_Filter( + ITEM_FILTER_UV.ID, + "automation.filter.tier.08", + "Ultimate Voltage Item Filter", + 8).getStackForm(1L)); + ItemList.Automation_Filter_MAX.set( + new GT_MetaTileEntity_Filter( + ITEM_FILTER_UHV.ID, + "automation.filter.tier.09", + "Highly Ultimate Voltage Item Filter", + 9).getStackForm(1L)); + } + + private static void registerTypeFilter() { + ItemList.Automation_TypeFilter_ULV.set( + new GT_MetaTileEntity_TypeFilter( + TYPE_FILTER_ULV.ID, + "automation.typefilter.tier.00", + "Ultra Low Voltage Type Filter", + 0).getStackForm(1L)); + ItemList.Automation_TypeFilter_LV.set( + new GT_MetaTileEntity_TypeFilter( + TYPE_FILTER_LV.ID, + "automation.typefilter.tier.01", + "Low Voltage Type Filter", + 1).getStackForm(1L)); + ItemList.Automation_TypeFilter_MV.set( + new GT_MetaTileEntity_TypeFilter( + TYPE_FILTER_MV.ID, + "automation.typefilter.tier.02", + "Medium Voltage Type Filter", + 2).getStackForm(1L)); + ItemList.Automation_TypeFilter_HV.set( + new GT_MetaTileEntity_TypeFilter( + TYPE_FILTER_HV.ID, + "automation.typefilter.tier.03", + "High Voltage Type Filter", + 3).getStackForm(1L)); + ItemList.Automation_TypeFilter_EV.set( + new GT_MetaTileEntity_TypeFilter( + TYPE_FILTER_EV.ID, + "automation.typefilter.tier.04", + "Extreme Voltage Type Filter", + 4).getStackForm(1L)); + ItemList.Automation_TypeFilter_IV.set( + new GT_MetaTileEntity_TypeFilter( + TYPE_FILTER_IV.ID, + "automation.typefilter.tier.05", + "Insane Voltage Type Filter", + 5).getStackForm(1L)); + ItemList.Automation_TypeFilter_LuV.set( + new GT_MetaTileEntity_TypeFilter( + TYPE_FILTER_LuV.ID, + "automation.typefilter.tier.06", + "Ludicrous Voltage Type Filter", + 6).getStackForm(1L)); + ItemList.Automation_TypeFilter_ZPM.set( + new GT_MetaTileEntity_TypeFilter( + TYPE_FILTER_ZPM.ID, + "automation.typefilter.tier.07", + "ZPM Voltage Type Filter", + 7).getStackForm(1L)); + ItemList.Automation_TypeFilter_UV.set( + new GT_MetaTileEntity_TypeFilter( + TYPE_FILTER_UV.ID, + "automation.typefilter.tier.08", + "Ultimate Voltage Type Filter", + 8).getStackForm(1L)); + ItemList.Automation_TypeFilter_MAX.set( + new GT_MetaTileEntity_TypeFilter( + TYPE_FILTER_UHV.ID, + "automation.typefilter.tier.09", + "Highly Ultimate Voltage Type Filter", + 9).getStackForm(1L)); + } + + private static void registerRegulator() { + ItemList.Automation_Regulator_ULV.set( + new GT_MetaTileEntity_Regulator( + VOLTAGE_REGULATOR_ULV.ID, + "automation.regulator.tier.00", + "Ultra Low Voltage Regulator", + 0).getStackForm(1L)); + ItemList.Automation_Regulator_LV.set( + new GT_MetaTileEntity_Regulator( + VOLTAGE_REGULATOR_LV.ID, + "automation.regulator.tier.01", + "Low Voltage Regulator", + 1).getStackForm(1L)); + ItemList.Automation_Regulator_MV.set( + new GT_MetaTileEntity_Regulator( + VOLTAGE_REGULATOR_MV.ID, + "automation.regulator.tier.02", + "Medium Voltage Regulator", + 2).getStackForm(1L)); + ItemList.Automation_Regulator_HV.set( + new GT_MetaTileEntity_Regulator( + VOLTAGE_REGULATOR_HV.ID, + "automation.regulator.tier.03", + "High Voltage Regulator", + 3).getStackForm(1L)); + ItemList.Automation_Regulator_EV.set( + new GT_MetaTileEntity_Regulator( + VOLTAGE_REGULATOR_EV.ID, + "automation.regulator.tier.04", + "Extreme Voltage Regulator", + 4).getStackForm(1L)); + ItemList.Automation_Regulator_IV.set( + new GT_MetaTileEntity_Regulator( + VOLTAGE_REGULATOR_IV.ID, + "automation.regulator.tier.05", + "Insane Voltage Regulator", + 5).getStackForm(1L)); + ItemList.Automation_Regulator_LuV.set( + new GT_MetaTileEntity_Regulator( + VOLTAGE_REGULATOR_LuV.ID, + "automation.regulator.tier.06", + "Ludicrous Voltage Regulator", + 6).getStackForm(1L)); + ItemList.Automation_Regulator_ZPM.set( + new GT_MetaTileEntity_Regulator( + VOLTAGE_REGULATOR_ZPM.ID, + "automation.regulator.tier.07", + "ZPM Voltage Regulator", + 7).getStackForm(1L)); + ItemList.Automation_Regulator_UV.set( + new GT_MetaTileEntity_Regulator( + VOLTAGE_REGULATOR_UV.ID, + "automation.regulator.tier.08", + "Ultimate Voltage Regulator", + 8).getStackForm(1L)); + ItemList.Automation_Regulator_MAX.set( + new GT_MetaTileEntity_Regulator( + VOLTAGE_REGULATOR_UHV.ID, + "automation.regulator.tier.09", + "Highly Ultimate Voltage Regulator", + 9).getStackForm(1L)); + } + + private static void registerSuperBuffer() { + ItemList.Automation_SuperBuffer_ULV.set( + new GT_MetaTileEntity_SuperBuffer( + SUPER_BUFFER_ULV.ID, + "automation.superbuffer.tier.00", + "Ultra Low Voltage Super Buffer", + 0).getStackForm(1L)); + ItemList.Automation_SuperBuffer_LV.set( + new GT_MetaTileEntity_SuperBuffer( + SUPER_BUFFER_LV.ID, + "automation.superbuffer.tier.01", + "Low Voltage Super Buffer", + 1).getStackForm(1L)); + ItemList.Automation_SuperBuffer_MV.set( + new GT_MetaTileEntity_SuperBuffer( + SUPER_BUFFER_MV.ID, + "automation.superbuffer.tier.02", + "Medium Voltage Super Buffer", + 2).getStackForm(1L)); + ItemList.Automation_SuperBuffer_HV.set( + new GT_MetaTileEntity_SuperBuffer( + SUPER_BUFFER_HV.ID, + "automation.superbuffer.tier.03", + "High Voltage Super Buffer", + 3).getStackForm(1L)); + ItemList.Automation_SuperBuffer_EV.set( + new GT_MetaTileEntity_SuperBuffer( + SUPER_BUFFER_EV.ID, + "automation.superbuffer.tier.04", + "Extreme Voltage Super Buffer", + 4).getStackForm(1L)); + ItemList.Automation_SuperBuffer_IV.set( + new GT_MetaTileEntity_SuperBuffer( + SUPER_BUFFER_IV.ID, + "automation.superbuffer.tier.05", + "Insane Voltage Super Buffer", + 5).getStackForm(1L)); + ItemList.Automation_SuperBuffer_LuV.set( + new GT_MetaTileEntity_SuperBuffer( + SUPER_BUFFER_LuV.ID, + "automation.superbuffer.tier.06", + "Ludicrous Voltage Super Buffer", + 6).getStackForm(1L)); + ItemList.Automation_SuperBuffer_ZPM.set( + new GT_MetaTileEntity_SuperBuffer( + SUPER_BUFFER_ZPM.ID, + "automation.superbuffer.tier.07", + "ZPM Voltage Super Buffer", + 7).getStackForm(1L)); + ItemList.Automation_SuperBuffer_UV.set( + new GT_MetaTileEntity_SuperBuffer( + SUPER_BUFFER_UV.ID, + "automation.superbuffer.tier.08", + "Ultimate Voltage Super Buffer", + 8).getStackForm(1L)); + ItemList.Automation_SuperBuffer_MAX.set( + new GT_MetaTileEntity_SuperBuffer( + SUPER_BUFFER_UHV.ID, + "automation.superbuffer.tier.09", + "Highly Ultimate Voltage Super Buffer", + 9).getStackForm(1L)); + } + + private static void registerItemDistributor() { + ItemList.Automation_ItemDistributor_ULV.set( + new GT_MetaTileEntity_ItemDistributor( + ITEM_DISTRIBUTOR_ULV.ID, + "automation.itemdistributor.tier.00", + "Ultra Low Voltage Item Distributor", + 0).getStackForm(1L)); + ItemList.Automation_ItemDistributor_LV.set( + new GT_MetaTileEntity_ItemDistributor( + ITEM_DISTRIBUTOR_LV.ID, + "automation.itemdistributor.tier.01", + "Low Voltage Item Distributor", + 1).getStackForm(1L)); + ItemList.Automation_ItemDistributor_MV.set( + new GT_MetaTileEntity_ItemDistributor( + ITEM_DISTRIBUTOR_MV.ID, + "automation.itemdistributor.tier.02", + "Medium Voltage Item Distributor", + 2).getStackForm(1L)); + ItemList.Automation_ItemDistributor_HV.set( + new GT_MetaTileEntity_ItemDistributor( + ITEM_DISTRIBUTOR_HV.ID, + "automation.itemdistributor.tier.03", + "High Voltage Item Distributor", + 3).getStackForm(1L)); + ItemList.Automation_ItemDistributor_EV.set( + new GT_MetaTileEntity_ItemDistributor( + ITEM_DISTRIBUTOR_EV.ID, + "automation.itemdistributor.tier.04", + "Extreme Voltage Item Distributor", + 4).getStackForm(1L)); + ItemList.Automation_ItemDistributor_IV.set( + new GT_MetaTileEntity_ItemDistributor( + ITEM_DISTRIBUTOR_IV.ID, + "automation.itemdistributor.tier.05", + "Insane Voltage Item Distributor", + 5).getStackForm(1L)); + ItemList.Automation_ItemDistributor_LuV.set( + new GT_MetaTileEntity_ItemDistributor( + ITEM_DISTRIBUTOR_LuV.ID, + "automation.itemdistributor.tier.06", + "Ludicrous Voltage Item Distributor", + 6).getStackForm(1L)); + ItemList.Automation_ItemDistributor_ZPM.set( + new GT_MetaTileEntity_ItemDistributor( + ITEM_DISTRIBUTOR_ZPM.ID, + "automation.itemdistributor.tier.07", + "ZPM Voltage Item Distributor", + 7).getStackForm(1L)); + ItemList.Automation_ItemDistributor_UV.set( + new GT_MetaTileEntity_ItemDistributor( + ITEM_DISTRIBUTOR_UV.ID, + "automation.itemdistributor.tier.08", + "Ultimate Voltage Item Distributor", + 8).getStackForm(1L)); + ItemList.Automation_ItemDistributor_MAX.set( + new GT_MetaTileEntity_ItemDistributor( + ITEM_DISTRIBUTOR_UHV.ID, + "automation.itemdistributor.tier.09", + "MAX Voltage Item Distributor", + 9).getStackForm(1L)); + } + + private static void registerRecipeFilter() { + ItemList.Automation_RecipeFilter_ULV.set( + new GT_MetaTileEntity_RecipeFilter( + RECIPE_FILTER_ULV.ID, + "automation.recipefilter.tier.00", + "Ultra Low Voltage Recipe Filter", + 0).getStackForm(1L)); + ItemList.Automation_RecipeFilter_LV.set( + new GT_MetaTileEntity_RecipeFilter( + RECIPE_FILTER_LV.ID, + "automation.recipefilter.tier.01", + "Low Voltage Recipe Filter", + 1).getStackForm(1L)); + ItemList.Automation_RecipeFilter_MV.set( + new GT_MetaTileEntity_RecipeFilter( + RECIPE_FILTER_MV.ID, + "automation.recipefilter.tier.02", + "Medium Voltage Recipe Filter", + 2).getStackForm(1L)); + ItemList.Automation_RecipeFilter_HV.set( + new GT_MetaTileEntity_RecipeFilter( + RECIPE_FILTER_HV.ID, + "automation.recipefilter.tier.03", + "High Voltage Recipe Filter", + 3).getStackForm(1L)); + ItemList.Automation_RecipeFilter_EV.set( + new GT_MetaTileEntity_RecipeFilter( + RECIPE_FILTER_EV.ID, + "automation.recipefilter.tier.04", + "Extreme Voltage Recipe Filter", + 4).getStackForm(1L)); + ItemList.Automation_RecipeFilter_IV.set( + new GT_MetaTileEntity_RecipeFilter( + RECIPE_FILTER_IV.ID, + "automation.recipefilter.tier.05", + "Insane Voltage Recipe Filter", + 5).getStackForm(1L)); + ItemList.Automation_RecipeFilter_LuV.set( + new GT_MetaTileEntity_RecipeFilter( + RECIPE_FILTER_LuV.ID, + "automation.recipefilter.tier.06", + "Ludicrous Voltage Recipe Filter", + 6).getStackForm(1L)); + ItemList.Automation_RecipeFilter_ZPM.set( + new GT_MetaTileEntity_RecipeFilter( + RECIPE_FILTER_ZPM.ID, + "automation.recipefilter.tier.07", + "ZPM Voltage Recipe Filter", + 7).getStackForm(1L)); + ItemList.Automation_RecipeFilter_UV.set( + new GT_MetaTileEntity_RecipeFilter( + RECIPE_FILTER_UV.ID, + "automation.recipefilter.tier.08", + "Ultimate Voltage Recipe Filter", + 8).getStackForm(1L)); + ItemList.Automation_RecipeFilter_MAX.set( + new GT_MetaTileEntity_RecipeFilter( + RECIPE_FILTER_UHV.ID, + "automation.recipefilter.tier.09", + "Highly Ultimate Voltage Recipe Filter", + 9).getStackForm(1L)); + } + + private static void registerMachineHull() { + ItemList.Hull_Bronze.set( + new GT_MetaTileEntity_BasicHull_Bronze( + HULL_BRONZE.ID, + "hull.bronze", + "Bronze Hull", + 0, + "For your first Steam Machines").getStackForm(1L)); ItemList.Hull_Bronze_Bricks.set( new GT_MetaTileEntity_BasicHull_BronzeBricks( - 2, + HULL_BRICKED_BRONZE.ID, "hull.bronze_bricked", "Bricked Bronze Hull", 0, "For your first Steam Machines").getStackForm(1L)); ItemList.Hull_HP.set( - new GT_MetaTileEntity_BasicHull_Steel(3, "hull.steel", "Steel Hull", 0, "For improved Steam Machines") - .getStackForm(1L)); + new GT_MetaTileEntity_BasicHull_Steel( + HULL_STEEL.ID, + "hull.steel", + "Steel Hull", + 0, + "For improved Steam Machines").getStackForm(1L)); ItemList.Hull_HP_Bricks.set( new GT_MetaTileEntity_BasicHull_SteelBricks( - 4, + HULL_WROUGHT_IRON.ID, "hull.steel_bricked", "Bricked Wrought Iron Hull", 0, "For improved Steam Machines").getStackForm(1L)); ItemList.Hull_ULV.set( - new GT_MetaTileEntity_BasicHull(10, "hull.tier.00", "ULV Machine Hull", 0, imagination).getStackForm(1L)); + new GT_MetaTileEntity_BasicHull(HULL_ULV.ID, "hull.tier.00", "ULV Machine Hull", 0, imagination) + .getStackForm(1L)); ItemList.Hull_LV.set( - new GT_MetaTileEntity_BasicHull(11, "hull.tier.01", "LV Machine Hull", 1, imagination).getStackForm(1L)); + new GT_MetaTileEntity_BasicHull(HULL_LV.ID, "hull.tier.01", "LV Machine Hull", 1, imagination) + .getStackForm(1L)); ItemList.Hull_MV.set( - new GT_MetaTileEntity_BasicHull(12, "hull.tier.02", "MV Machine Hull", 2, imagination).getStackForm(1L)); + new GT_MetaTileEntity_BasicHull(HULL_MV.ID, "hull.tier.02", "MV Machine Hull", 2, imagination) + .getStackForm(1L)); ItemList.Hull_HV.set( - new GT_MetaTileEntity_BasicHull(13, "hull.tier.03", "HV Machine Hull", 3, imagination).getStackForm(1L)); + new GT_MetaTileEntity_BasicHull(HULL_HV.ID, "hull.tier.03", "HV Machine Hull", 3, imagination) + .getStackForm(1L)); ItemList.Hull_EV.set( - new GT_MetaTileEntity_BasicHull(14, "hull.tier.04", "EV Machine Hull", 4, imagination).getStackForm(1L)); + new GT_MetaTileEntity_BasicHull(HULL_EV.ID, "hull.tier.04", "EV Machine Hull", 4, imagination) + .getStackForm(1L)); ItemList.Hull_IV.set( - new GT_MetaTileEntity_BasicHull(15, "hull.tier.05", "IV Machine Hull", 5, imagination).getStackForm(1L)); + new GT_MetaTileEntity_BasicHull(HULL_IV.ID, "hull.tier.05", "IV Machine Hull", 5, imagination) + .getStackForm(1L)); ItemList.Hull_LuV.set( - new GT_MetaTileEntity_BasicHull(16, "hull.tier.06", "LuV Machine Hull", 6, imagination).getStackForm(1L)); + new GT_MetaTileEntity_BasicHull(HULL_LuV.ID, "hull.tier.06", "LuV Machine Hull", 6, imagination) + .getStackForm(1L)); ItemList.Hull_ZPM.set( - new GT_MetaTileEntity_BasicHull(17, "hull.tier.07", "ZPM Machine Hull", 7, imagination).getStackForm(1L)); + new GT_MetaTileEntity_BasicHull(HULL_ZPM.ID, "hull.tier.07", "ZPM Machine Hull", 7, imagination) + .getStackForm(1L)); ItemList.Hull_UV.set( - new GT_MetaTileEntity_BasicHull(18, "hull.tier.08", "UV Machine Hull", 8, imagination).getStackForm(1L)); + new GT_MetaTileEntity_BasicHull(HULL_UV.ID, "hull.tier.08", "UV Machine Hull", 8, imagination) + .getStackForm(1L)); ItemList.Hull_MAX.set( - new GT_MetaTileEntity_BasicHull(19, "hull.tier.09", "UHV Machine Hull", 9, imagination).getStackForm(1L)); + new GT_MetaTileEntity_BasicHull(HULL_UHV.ID, "hull.tier.09", "UHV Machine Hull", 9, imagination) + .getStackForm(1L)); + } + private static void registerTransformer() { ItemList.Transformer_LV_ULV.set( new GT_MetaTileEntity_Transformer( - 20, + transformer_LV_ULV.ID, "transformer.tier.00", "Ultra Low Voltage Transformer", 0, "LV -> ULV (Use Soft Mallet to invert)").getStackForm(1L)); ItemList.Transformer_MV_LV.set( new GT_MetaTileEntity_Transformer( - 21, + transformer_MV_LV.ID, "transformer.tier.01", "Low Voltage Transformer", 1, "MV -> LV (Use Soft Mallet to invert)").getStackForm(1L)); ItemList.Transformer_HV_MV.set( new GT_MetaTileEntity_Transformer( - 22, + transformer_HV_MV.ID, "transformer.tier.02", "Medium Voltage Transformer", 2, "HV -> MV (Use Soft Mallet to invert)").getStackForm(1L)); ItemList.Transformer_EV_HV.set( new GT_MetaTileEntity_Transformer( - 23, + transformer_EV_HV.ID, "transformer.tier.03", "High Voltage Transformer", 3, "EV -> HV (Use Soft Mallet to invert)").getStackForm(1L)); ItemList.Transformer_IV_EV.set( new GT_MetaTileEntity_Transformer( - 24, + transformer_IV_EV.ID, "transformer.tier.04", "Extreme Transformer", 4, "IV -> EV (Use Soft Mallet to invert)").getStackForm(1L)); ItemList.Transformer_LuV_IV.set( new GT_MetaTileEntity_Transformer( - 25, + transformer_LuV_IV.ID, "transformer.tier.05", "Insane Transformer", 5, "LuV -> IV (Use Soft Mallet to invert)").getStackForm(1L)); ItemList.Transformer_ZPM_LuV.set( new GT_MetaTileEntity_Transformer( - 26, + transformer_ZPM_LuV.ID, "transformer.tier.06", "Ludicrous Transformer", 6, "ZPM -> LuV (Use Soft Mallet to invert)").getStackForm(1L)); ItemList.Transformer_UV_ZPM.set( new GT_MetaTileEntity_Transformer( - 27, + transformer_UV_ZPM.ID, "transformer.tier.07", "ZPM Voltage Transformer", 7, "UV -> ZPM (Use Soft Mallet to invert)").getStackForm(1L)); ItemList.Transformer_MAX_UV.set( new GT_MetaTileEntity_Transformer( - 28, + transformer_UHV_UV.ID, "transformer.tier.08", "Ultimate Transformer", 8, "UHV -> UV (Use Soft Mallet to invert)").getStackForm(1L)); + } + private static void registerDynamoHatch() { ItemList.Hatch_Dynamo_ULV.set( - new GT_MetaTileEntity_Hatch_Dynamo(30, "hatch.dynamo.tier.00", "ULV Dynamo Hatch", 0).getStackForm(1L)); - ItemList.Hatch_Dynamo_LV - .set(new GT_MetaTileEntity_Hatch_Dynamo(31, "hatch.dynamo.tier.01", "LV Dynamo Hatch", 1).getStackForm(1L)); - ItemList.Hatch_Dynamo_MV - .set(new GT_MetaTileEntity_Hatch_Dynamo(32, "hatch.dynamo.tier.02", "MV Dynamo Hatch", 2).getStackForm(1L)); - ItemList.Hatch_Dynamo_HV - .set(new GT_MetaTileEntity_Hatch_Dynamo(33, "hatch.dynamo.tier.03", "HV Dynamo Hatch", 3).getStackForm(1L)); - ItemList.Hatch_Dynamo_EV - .set(new GT_MetaTileEntity_Hatch_Dynamo(34, "hatch.dynamo.tier.04", "EV Dynamo Hatch", 4).getStackForm(1L)); - ItemList.Hatch_Dynamo_IV - .set(new GT_MetaTileEntity_Hatch_Dynamo(35, "hatch.dynamo.tier.05", "IV Dynamo Hatch", 5).getStackForm(1L)); + new GT_MetaTileEntity_Hatch_Dynamo(DYNAMO_HATCH_ULV.ID, "hatch.dynamo.tier.00", "ULV Dynamo Hatch", 0) + .getStackForm(1L)); + ItemList.Hatch_Dynamo_LV.set( + new GT_MetaTileEntity_Hatch_Dynamo(DYNAMO_HATCH_LV.ID, "hatch.dynamo.tier.01", "LV Dynamo Hatch", 1) + .getStackForm(1L)); + ItemList.Hatch_Dynamo_MV.set( + new GT_MetaTileEntity_Hatch_Dynamo(DYNAMO_HATCH_MV.ID, "hatch.dynamo.tier.02", "MV Dynamo Hatch", 2) + .getStackForm(1L)); + ItemList.Hatch_Dynamo_HV.set( + new GT_MetaTileEntity_Hatch_Dynamo