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 <maxim235@gmx.de>
Co-authored-by: Lyfts <127234178+Lyfts@users.noreply.github.com>
Co-authored-by: miozune <miozune@gmail.com>
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 <maxim235@gmx.de>
Co-authored-by: Martin Robertz <dream-master@gmx.net>
Co-authored-by: GDCloud <93287602+GDCloudstrike@users.noreply.github.com>
Co-authored-by: Lyfts <127234178+Lyfts@users.noreply.github.com>
Co-authored-by: miozune <miozune@gmail.com>
Co-authored-by: Serenibyss <10861407+serenibyss@users.noreply.github.com>
Co-authored-by: YannickMG <yannickmg@gmail.com>

1 files changed, 1861 insertions, 1256 deletions

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(140, "multimachine.brickedblastfurnace", "Bricked Blast Furnace")
+            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.Hull_Bronze.set(
-            new GT_MetaTileEntity_BasicHull_Bronze(1, "hull.bronze", "Bronze Hull", 0, "For your first Steam Machines")
+        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));
+    }
+
+    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.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.