diff options
Diffstat (limited to 'src/main/java/gregtech/loaders/preload')
8 files changed, 9931 insertions, 0 deletions
diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_CircuitBehaviors.java b/src/main/java/gregtech/loaders/preload/GT_Loader_CircuitBehaviors.java new file mode 100644 index 0000000000..fd66127e36 --- /dev/null +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_CircuitBehaviors.java @@ -0,0 +1,31 @@ +package gregtech.loaders.preload; + +import gregtech.api.util.GT_Log; +import gregtech.common.redstonecircuits.GT_Circuit_BasicLogic; +import gregtech.common.redstonecircuits.GT_Circuit_BitAnd; +import gregtech.common.redstonecircuits.GT_Circuit_CombinationLock; +import gregtech.common.redstonecircuits.GT_Circuit_Equals; +import gregtech.common.redstonecircuits.GT_Circuit_Pulser; +import gregtech.common.redstonecircuits.GT_Circuit_Randomizer; +import gregtech.common.redstonecircuits.GT_Circuit_RedstoneMeter; +import gregtech.common.redstonecircuits.GT_Circuit_Repeater; +import gregtech.common.redstonecircuits.GT_Circuit_Timer; + +public class GT_Loader_CircuitBehaviors implements Runnable { + + @Override + public void run() { + GT_Log.out.println("GT_Mod: Register Redstone Circuit behaviours."); + new GT_Circuit_Timer(0); + new GT_Circuit_BasicLogic(1); + new GT_Circuit_Repeater(2); + new GT_Circuit_Pulser(3); + new GT_Circuit_RedstoneMeter(4); + + new GT_Circuit_Randomizer(8); + + new GT_Circuit_CombinationLock(16); + new GT_Circuit_BitAnd(17); + new GT_Circuit_Equals(18); + } +} diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_ItemData.java b/src/main/java/gregtech/loaders/preload/GT_Loader_ItemData.java new file mode 100644 index 0000000000..321ecca70f --- /dev/null +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_ItemData.java @@ -0,0 +1,383 @@ +package gregtech.loaders.preload; + +import static gregtech.api.enums.Mods.AppliedEnergistics2; +import static gregtech.api.enums.Mods.Forestry; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.enums.Mods.Railcraft; +import static gregtech.api.enums.Mods.Thaumcraft; +import static gregtech.api.enums.Mods.TwilightForest; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.objects.ItemData; +import gregtech.api.objects.MaterialStack; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; + +public class GT_Loader_ItemData implements Runnable { + + @Override + public void run() { + GT_Log.out.println("GT_Mod: Loading Item Data Tags"); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(TwilightForest.ID, "item.giantPick", 1L, 0), + new ItemData(Materials.Stone, 696729600L, new MaterialStack(Materials.Wood, 464486400L))); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(TwilightForest.ID, "item.giantSword", 1L, 0), + new ItemData(Materials.Stone, 464486400L, new MaterialStack(Materials.Wood, 232243200L))); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(TwilightForest.ID, "tile.GiantLog", 1L, 32767), + new ItemData(Materials.Wood, 232243200L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(TwilightForest.ID, "tile.GiantCobble", 1L, 32767), + new ItemData(Materials.Stone, 232243200L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(TwilightForest.ID, "tile.GiantObsidian", 1L, 32767), + new ItemData(Materials.Obsidian, 232243200L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(TwilightForest.ID, "item.minotaurAxe", 1L, 0), + new ItemData( + Materials.Diamond, + 14515200L, + new MaterialStack(Materials.Wood, OrePrefixes.stick.mMaterialAmount * 2L))); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(TwilightForest.ID, "item.armorShards", 1L, 0), + new ItemData(Materials.Knightmetal, 403200L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(TwilightForest.ID, "item.shardCluster", 1L, 0), + new ItemData(Materials.Knightmetal, 3628800L)); + GT_OreDictUnificator.addItemData(ItemList.TF_LiveRoot.get(1L), new ItemData(Materials.LiveRoot, 3628800L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 10), + new ItemData(Materials.CertusQuartz, 1814400L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 11), + new ItemData(Materials.NetherQuartz, 1814400L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 12), + new ItemData(Materials.Fluix, 1814400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.quartz_block, 1, 32767), new ItemData(Materials.NetherQuartz, 14515200L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "tile.BlockQuartz", 1L, 32767), + new ItemData(Materials.CertusQuartz, 14515200L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "tile.BlockQuartzPillar", 1L, 32767), + new ItemData(Materials.CertusQuartz, 14515200L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "tile.BlockQuartzChiseled", 1L, 32767), + new ItemData(Materials.CertusQuartz, 14515200L)); + GT_OreDictUnificator.addItemData(new ItemStack(Items.wheat, 1, 32767), new ItemData(Materials.Wheat, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.hay_block, 1, 32767), new ItemData(Materials.Wheat, 32659200L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Items.snowball, 1, 32767), new ItemData(Materials.Snow, 907200L)); + GT_OreDictUnificator.addItemData(new ItemStack(Blocks.snow, 1, 32767), new ItemData(Materials.Snow, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.glowstone, 1, 32767), new ItemData(Materials.Glowstone, 14515200L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.redstone_lamp, 1, 32767), + new ItemData( + Materials.Glowstone, + 14515200L, + new MaterialStack(Materials.Redstone, OrePrefixes.dust.mMaterialAmount * 4L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.lit_redstone_lamp, 1, 32767), + new ItemData( + Materials.Glowstone, + 14515200L, + new MaterialStack(Materials.Redstone, OrePrefixes.dust.mMaterialAmount * 4L))); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(Forestry.ID, "craftingMaterial", 1L, 5), + new ItemData(Materials.Ice, 3628800L)); + GT_OreDictUnificator.addItemData(new ItemStack(Blocks.ice, 1, 32767), new ItemData(Materials.Ice, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.packed_ice, 1, 32767), new ItemData(Materials.Ice, 7257600L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Items.clay_ball, 1, 32767), new ItemData(Materials.Clay, 1814400L)); + GT_OreDictUnificator.removeItemData(new ItemStack(Blocks.clay, 1, 0)); + GT_OreDictUnificator.addItemData(new ItemStack(Blocks.clay, 1, 32767), new ItemData(Materials.Clay, 7257600L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.hardened_clay, 1, 32767), new ItemData(Materials.Clay, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stained_hardened_clay, 1, 32767), new ItemData(Materials.Clay, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.brick_block, 1, 32767), new ItemData(Materials.Brick, 3628800L)); + GT_OreDictUnificator + .addItemData(GT_ModHandler.getIC2Item("Uran238", 1L), new ItemData(Materials.Uranium, 3628800L)); + GT_OreDictUnificator + .addItemData(GT_ModHandler.getIC2Item("Uran235", 1L), new ItemData(Materials.Uranium235, 3628800L)); + GT_OreDictUnificator + .addItemData(GT_ModHandler.getIC2Item("Plutonium", 1L), new ItemData(Materials.Plutonium, 3628800L)); + GT_OreDictUnificator + .addItemData(GT_ModHandler.getIC2Item("smallUran235", 1L), new ItemData(Materials.Uranium235, 403200L)); + GT_OreDictUnificator + .addItemData(GT_ModHandler.getIC2Item("smallPlutonium", 1L), new ItemData(Materials.Plutonium, 403200L)); + GT_OreDictUnificator.addItemData(ItemList.IC2_Item_Casing_Iron.get(1L), new ItemData(Materials.Iron, 1814400L)); + GT_OreDictUnificator.addItemData(ItemList.IC2_Item_Casing_Gold.get(1L), new ItemData(Materials.Gold, 1814400L)); + GT_OreDictUnificator + .addItemData(ItemList.IC2_Item_Casing_Bronze.get(1L), new ItemData(Materials.Bronze, 1814400L)); + GT_OreDictUnificator + .addItemData(ItemList.IC2_Item_Casing_Copper.get(1L), new ItemData(Materials.Copper, 1814400L)); + GT_OreDictUnificator.addItemData(ItemList.IC2_Item_Casing_Tin.get(1L), new ItemData(Materials.Tin, 1814400L)); + GT_OreDictUnificator.addItemData(ItemList.IC2_Item_Casing_Lead.get(1L), new ItemData(Materials.Lead, 1814400L)); + GT_OreDictUnificator + .addItemData(ItemList.IC2_Item_Casing_Steel.get(1L), new ItemData(Materials.Steel, 1814400L)); + GT_OreDictUnificator.addItemData(new ItemStack(Items.book, 1, 32767), new ItemData(Materials.Paper, 10886400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Items.written_book, 1, 32767), new ItemData(Materials.Paper, 10886400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Items.writable_book, 1, 32767), new ItemData(Materials.Paper, 10886400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Items.enchanted_book, 1, 32767), new ItemData(Materials.Paper, 10886400L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Items.golden_apple, 1, 1), + new ItemData(Materials.Gold, OrePrefixes.block.mMaterialAmount * 8L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Items.golden_apple, 1, 0), + new ItemData(Materials.Gold, OrePrefixes.ingot.mMaterialAmount * 8L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Items.golden_carrot, 1, 0), + new ItemData(Materials.Gold, OrePrefixes.nugget.mMaterialAmount * 8L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Items.speckled_melon, 1, 0), + new ItemData(Materials.Gold, OrePrefixes.nugget.mMaterialAmount * 8L)); + GT_OreDictUnificator.addItemData(new ItemStack(Items.minecart, 1), new ItemData(Materials.Iron, 18144000L)); + GT_OreDictUnificator.addItemData(new ItemStack(Items.iron_door, 1), new ItemData(Materials.Iron, 21772800L)); + GT_OreDictUnificator.addItemData(new ItemStack(Items.cauldron, 1), new ItemData(Materials.Iron, 25401600L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.iron_bars, 8, 32767), new ItemData(Materials.Iron, 10886400L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.SteelBars", 8L, 0), + new ItemData(Materials.Steel, 10886400L)); + GT_OreDictUnificator + .addItemData(GT_ModHandler.getIC2Item("ironFurnace", 1L), new ItemData(Materials.Iron, 18144000L)); + GT_OreDictUnificator.addItemData(ItemList.IC2_Food_Can_Empty.get(1L), new ItemData(Materials.Tin, 1814400L)); + GT_OreDictUnificator.addItemData(ItemList.IC2_Fuel_Rod_Empty.get(1L), new ItemData(Materials.Iron, 3628800L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.light_weighted_pressure_plate, 1, 32767), + new ItemData(Materials.Gold, 7257600L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.heavy_weighted_pressure_plate, 1, 32767), + new ItemData(Materials.Iron, 7257600L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(Railcraft.ID, "anvil", 1L, 0), + new ItemData(Materials.Steel, 108864000L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(Railcraft.ID, "anvil", 1L, 1), + new ItemData(Materials.Steel, 72576000L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(Railcraft.ID, "anvil", 1L, 2), + new ItemData(Materials.Steel, 36288000L)); + GT_OreDictUnificator.addItemData(new ItemStack(Blocks.anvil, 1, 0), new ItemData(Materials.Iron, 108864000L)); + GT_OreDictUnificator.addItemData(new ItemStack(Blocks.anvil, 1, 1), new ItemData(Materials.Iron, 72576000L)); + GT_OreDictUnificator.addItemData(new ItemStack(Blocks.anvil, 1, 2), new ItemData(Materials.Iron, 36288000L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.hopper, 1, 32767), + new ItemData(Materials.Iron, 18144000L, new MaterialStack(Materials.Wood, 29030400L))); + GT_OreDictUnificator.addItemData(ItemList.Cell_Universal_Fluid.get(1L), new ItemData(Materials.Tin, 7257600L)); + GT_OreDictUnificator.addItemData(ItemList.Cell_Empty.get(1L), new ItemData(Materials.Tin, 7257600L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.tripwire_hook, 1, 32767), + new ItemData( + Materials.Iron, + OrePrefixes.ring.mMaterialAmount * 2L, + new MaterialStack(Materials.Wood, 3628800L))); + GT_OreDictUnificator.addItemData(ItemList.Bottle_Empty.get(1L), new ItemData(Materials.Glass, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Items.potionitem, 1, 32767), new ItemData(Materials.Glass, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stained_glass, 1, 32767), new ItemData(Materials.Glass, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.glass, 1, 32767), new ItemData(Materials.Glass, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stained_glass_pane, 1, 32767), new ItemData(Materials.Glass, 1360800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.glass_pane, 1, 32767), new ItemData(Materials.Glass, 1360800L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Items.clock, 1, 32767), + new ItemData(Materials.Gold, 14515200L, new MaterialStack(Materials.Redstone, 3628800L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Items.compass, 1, 32767), + new ItemData(Materials.Iron, 14515200L, new MaterialStack(Materials.Redstone, 3628800L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Items.iron_horse_armor, 1, 32767), + new ItemData(Materials.Iron, 29030400L, new MaterialStack(Materials.Leather, 21772800L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Items.golden_horse_armor, 1, 32767), + new ItemData(Materials.Gold, 29030400L, new MaterialStack(Materials.Leather, 21772800L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Items.diamond_horse_armor, 1, 32767), + new ItemData(Materials.Diamond, 29030400L, new MaterialStack(Materials.Leather, 21772800L))); + GT_OreDictUnificator + .addItemData(new ItemStack(Items.leather, 1, 32767), new ItemData(Materials.Leather, 3628800L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.beacon, 1, 32767), + new ItemData( + Materials.NetherStar, + 3628800L, + new MaterialStack(Materials.Obsidian, 10886400L), + new MaterialStack(Materials.Glass, 18144000L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.enchanting_table, 1, 32767), + new ItemData( + Materials.Diamond, + 7257600L, + new MaterialStack(Materials.Obsidian, 14515200L), + new MaterialStack(Materials.Paper, 10886400L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.ender_chest, 1, 32767), + new ItemData(Materials.EnderEye, 3628800L, new MaterialStack(Materials.Obsidian, 29030400L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.bookshelf, 1, 32767), + new ItemData(Materials.Paper, 32659200L, new MaterialStack(Materials.Wood, 21772800L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.lever, 1, 32767), + new ItemData(Materials.Stone, 3628800L, new MaterialStack(Materials.Wood, 1814400L))); + GT_OreDictUnificator.addItemData(new ItemStack(Blocks.ice, 1, 32767), new ItemData(Materials.Ice, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.packed_ice, 1, 32767), new ItemData(Materials.Ice, 7257600L)); + GT_OreDictUnificator.addItemData(new ItemStack(Blocks.snow, 1, 32767), new ItemData(Materials.Snow, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Items.snowball, 1, 32767), new ItemData(Materials.Snow, 907200L)); + GT_OreDictUnificator.addItemData(new ItemStack(Blocks.snow_layer, 1, 32767), new ItemData(Materials.Snow, -1L)); + GT_OreDictUnificator.addItemData(new ItemStack(Blocks.sand, 1, 32767), new ItemData(Materials.Sand, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.sandstone, 1, 32767), new ItemData(Materials.Sand, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone_slab, 1, 0), new ItemData(Materials.Stone, 1814400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone_slab, 1, 8), new ItemData(Materials.Stone, 1814400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.double_stone_slab, 1, 0), new ItemData(Materials.Stone, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.double_stone_slab, 1, 8), new ItemData(Materials.Stone, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone_slab, 1, 1), new ItemData(Materials.Sand, 1814400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone_slab, 1, 9), new ItemData(Materials.Sand, 1814400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.double_stone_slab, 1, 1), new ItemData(Materials.Sand, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.double_stone_slab, 1, 9), new ItemData(Materials.Sand, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone_slab, 1, 2), new ItemData(Materials.Wood, 1814400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone_slab, 1, 10), new ItemData(Materials.Wood, 1814400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.double_stone_slab, 1, 2), new ItemData(Materials.Wood, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.double_stone_slab, 1, 10), new ItemData(Materials.Wood, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone_slab, 1, 3), new ItemData(Materials.Stone, 1814400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone_slab, 1, 11), new ItemData(Materials.Stone, 1814400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.double_stone_slab, 1, 3), new ItemData(Materials.Stone, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.double_stone_slab, 1, 11), new ItemData(Materials.Stone, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone_slab, 1, 5), new ItemData(Materials.Stone, 1814400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone_slab, 1, 13), new ItemData(Materials.Stone, 1814400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.double_stone_slab, 1, 5), new ItemData(Materials.Stone, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.double_stone_slab, 1, 13), new ItemData(Materials.Stone, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone, 1, 32767), new ItemData(Materials.Stone, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.furnace, 1, 32767), new ItemData(Materials.Stone, 29030400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.lit_furnace, 1, 32767), new ItemData(Materials.Stone, 29030400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stonebrick, 1, 32767), new ItemData(Materials.Stone, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.cobblestone, 1, 32767), new ItemData(Materials.Stone, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.mossy_cobblestone, 1, 32767), new ItemData(Materials.Stone, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone_button, 1, 32767), new ItemData(Materials.Stone, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.stone_pressure_plate, 1, 32767), new ItemData(Materials.Stone, 7257600L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.ladder, 1, 32767), new ItemData(Materials.Wood, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.wooden_button, 1, 32767), new ItemData(Materials.Wood, 3628800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.wooden_pressure_plate, 1, 32767), new ItemData(Materials.Wood, 7257600L)); + GT_OreDictUnificator.addItemData(new ItemStack(Blocks.fence, 1, 32767), new ItemData(Materials.Wood, 5443200L)); + GT_OreDictUnificator.addItemData(new ItemStack(Items.bowl, 1, 32767), new ItemData(Materials.Wood, 3628800L)); + GT_OreDictUnificator.addItemData(new ItemStack(Items.sign, 1, 32767), new ItemData(Materials.Wood, 7257600L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Items.wooden_door, 1, 32767), new ItemData(Materials.Wood, 21772800L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.chest, 1, 32767), new ItemData(Materials.Wood, 29030400L)); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.trapped_chest, 1, 32767), new ItemData(Materials.Wood, 29030400L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.unlit_redstone_torch, 1, 32767), + new ItemData(Materials.Wood, 1814400L, new MaterialStack(Materials.Redstone, 3628800L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.redstone_torch, 1, 32767), + new ItemData(Materials.Wood, 1814400L, new MaterialStack(Materials.Redstone, 3628800L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.noteblock, 1, 32767), + new ItemData(Materials.Wood, 29030400L, new MaterialStack(Materials.Redstone, 3628800L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.jukebox, 1, 32767), + new ItemData(Materials.Wood, 29030400L, new MaterialStack(Materials.Diamond, 3628800L))); + GT_OreDictUnificator + .addItemData(new ItemStack(Blocks.crafting_table, 1, 32767), new ItemData(Materials.Wood, 14515200L)); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.piston, 1, 32767), + new ItemData(Materials.Stone, 14515200L, new MaterialStack(Materials.Wood, 10886400L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.sticky_piston, 1, 32767), + new ItemData(Materials.Stone, 14515200L, new MaterialStack(Materials.Wood, 10886400L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.dispenser, 1, 32767), + new ItemData(Materials.Stone, 25401600L, new MaterialStack(Materials.Redstone, 3628800L))); + GT_OreDictUnificator.addItemData( + new ItemStack(Blocks.dropper, 1, 32767), + new ItemData(Materials.Stone, 25401600L, new MaterialStack(Materials.Redstone, 3628800L))); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(Thaumcraft.ID, "ItemNuggetChicken", 1L, 32767), + new ItemData(Materials.MeatCooked, 403200L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(Thaumcraft.ID, "ItemNuggetBeef", 1L, 32767), + new ItemData(Materials.MeatCooked, 403200L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(Thaumcraft.ID, "ItemNuggetPork", 1L, 32767), + new ItemData(Materials.MeatCooked, 403200L)); + GT_OreDictUnificator.addItemData( + GT_ModHandler.getModItem(Thaumcraft.ID, "ItemNuggetFish", 1L, 32767), + new ItemData(Materials.MeatCooked, 403200L)); + for (ItemStack tItem : new ItemStack[] { GT_ModHandler.getModItem(TwilightForest.ID, "item.meefRaw", 1L, 0), + GT_ModHandler.getModItem(TwilightForest.ID, "item.venisonRaw", 1L, 0), new ItemStack(Items.porkchop), + new ItemStack(Items.beef), new ItemStack(Items.chicken), new ItemStack(Items.fish) }) { + if (tItem != null) { + GT_OreDictUnificator.addItemData( + GT_Utility.copyMetaData(32767, tItem), + new ItemData(Materials.MeatRaw, 3628800L, new MaterialStack(Materials.Bone, 403200L))); + } + } + for (ItemStack tItem : new ItemStack[] { GT_ModHandler.getModItem(TwilightForest.ID, "item.meefSteak", 1L, 0), + GT_ModHandler.getModItem(TwilightForest.ID, "item.venisonCooked", 1L, 0), + new ItemStack(Items.cooked_porkchop), new ItemStack(Items.cooked_beef), new ItemStack(Items.cooked_chicken), + new ItemStack(Items.cooked_fished) }) { + if (tItem != null) { + GT_OreDictUnificator.addItemData( + GT_Utility.copyMetaData(32767, tItem), + new ItemData(Materials.MeatCooked, 3628800L, new MaterialStack(Materials.Bone, 403200L))); + } + } + } +} diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_Item_Block_And_Fluid.java b/src/main/java/gregtech/loaders/preload/GT_Loader_Item_Block_And_Fluid.java new file mode 100644 index 0000000000..a0abf686f8 --- /dev/null +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_Item_Block_And_Fluid.java @@ -0,0 +1,2232 @@ +package gregtech.loaders.preload; + +import static gregtech.api.enums.FluidState.GAS; +import static gregtech.api.enums.FluidState.LIQUID; +import static gregtech.api.enums.FluidState.MOLTEN; +import static gregtech.api.enums.FluidState.SLURRY; +import static gregtech.api.enums.Mods.AppliedEnergistics2; +import static gregtech.api.enums.Mods.PamsHarvestCraft; +import static gregtech.api.enums.Mods.Railcraft; +import static gregtech.api.enums.Mods.Thaumcraft; +import static gregtech.api.enums.Mods.TwilightForest; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidCannerRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.recipe.RecipeMaps.thermalCentrifugeRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeBuilder.WILDCARD; + +import java.util.Locale; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; + +import codechicken.nei.api.API; +import cpw.mods.fml.common.event.FMLInterModComms; +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.GT_Mod; +import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.Dyes; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsKevlar; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.fluid.GT_FluidFactory; +import gregtech.api.items.GT_Block_LongDistancePipe; +import gregtech.api.items.GT_BreederCell_Item; +import gregtech.api.items.GT_Generic_Item; +import gregtech.api.items.GT_RadioactiveCellIC_Item; +import gregtech.api.metatileentity.BaseMetaPipeEntity; +import gregtech.api.metatileentity.BaseMetaTileEntity; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.blocks.GT_Block_Casings1; +import gregtech.common.blocks.GT_Block_Casings2; +import gregtech.common.blocks.GT_Block_Casings3; +import gregtech.common.blocks.GT_Block_Casings4; +import gregtech.common.blocks.GT_Block_Casings5; +import gregtech.common.blocks.GT_Block_Casings6; +import gregtech.common.blocks.GT_Block_Casings8; +import gregtech.common.blocks.GT_Block_Casings9; +import gregtech.common.blocks.GT_Block_Concretes; +import gregtech.common.blocks.GT_Block_Drone; +import gregtech.common.blocks.GT_Block_Granites; +import gregtech.common.blocks.GT_Block_Machines; +import gregtech.common.blocks.GT_Block_Metal; +import gregtech.common.blocks.GT_Block_Ores; +import gregtech.common.blocks.GT_Block_Reinforced; +import gregtech.common.blocks.GT_Block_Stones; +import gregtech.common.blocks.GT_Cyclotron_Coils; +import gregtech.common.blocks.GT_TileEntity_Ores; +import gregtech.common.items.GT_DepletetCell_Item; +import gregtech.common.items.GT_FluidDisplayItem; +import gregtech.common.items.GT_IntegratedCircuit_Item; +import gregtech.common.items.GT_MetaGenerated_Item_01; +import gregtech.common.items.GT_MetaGenerated_Item_02; +import gregtech.common.items.GT_MetaGenerated_Item_03; +import gregtech.common.items.GT_MetaGenerated_Item_98; +import gregtech.common.items.GT_MetaGenerated_Item_99; +import gregtech.common.items.GT_MetaGenerated_Tool_01; +import gregtech.common.items.GT_NeutronReflector_Item; +import gregtech.common.items.GT_TierDrone; +import gregtech.common.items.GT_VolumetricFlask; +import gregtech.common.tileentities.render.TileDrone; + +public class GT_Loader_Item_Block_And_Fluid implements Runnable { + + @Override + public void run() { + Materials.Water.mFluid = (Materials.Ice.mFluid = GT_ModHandler.getWater(1000L) + .getFluid()); + Materials.Lava.mFluid = GT_ModHandler.getLava(1000L) + .getFluid(); + + GT_Log.out.println("GT_Mod: Register Books."); + + GT_Utility.getWrittenBook( + "Manual_Printer", + "Printer Manual V2.0", + "Gregorius Techneticies", + "This Manual explains the different Functionalities the GregTech Printing Factory has built in, which are not in NEI. Most got NEI Support now, but there is still some left without it.", + "1. Coloring Items and Blocks: You know those Crafting Recipes, which have a dye surrounded by 8 Item to dye them? Or the ones which have just one Item and one Dye in the Grid? Those two Recipe Types can be cheaply automated using the Printer.", + "The Colorization Functionality even optimizes the Recipes, which normally require 8 Items + 1 Dye to 1 Item and an 8th of the normally used Dye in Fluid Form, isn't that awesome?", + "2. Copying Books: This Task got slightly harder. The first Step is putting the written and signed Book inside the Scanner with a Data Stick ready to receive the Data.", + "Now insert the Stick into the Data Slot of the Printer and add 3 pieces of Paper together with 144 Liters of actual Ink Fluid. Water mixed and chemical Dyes won't work on Paper without messing things up!", + "You got a stack of Pages for your new Book, just put them into the Assembler with some Glue and a piece of Leather for the Binding, and you receive an identical copy of the Book, which would stack together with the original.", + "3. Renaming Items: This Functionality is no longer Part of the Printer. There is now a Name Mold for the Forming Press to imprint a Name into an Item, just rename the Mold in an Anvil and use it in the Forming Press on any Item.", + "4. Crafting of Books, Maps, Nametags etc etc etc: Those Recipes moved to other Machines, just look them up in NEI."); + + GT_Utility.getWrittenBook( + "Manual_Punch_Cards", + "Punch Card Manual V0.0", + "Gregorius Techneticies", + "This Manual will explain the Functionality of the Punch Cards, once they are fully implemented. And no, they won't be like the IRL Punch Cards. This is just a current Idea Collection.", + "(i1&&i2)?o1=15:o1=0;=10", + "ignore all Whitespace Characters, use Long for saving the Numbers", + "&& || ^^ & | ^ ! ++ -- + - % / // * ** << >> >>> < > <= >= == != ~ ( ) ?: , ; ;= ;=X; = i0 i1 i2 i3 i4 i5 o0 o1 o2 o3 o4 o5 v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 m0 m1 m2 m3 m4 m5 m6 m7 m8 m9 A B C D E F", + "'0' = false, 'everything but 0' = true, '!' turns '0' into '1' and everything else into '0'", + "',' is just a separator for multiple executed Codes in a row.", + "';' means that the Program waits until the next tick before continuing. ';=10' and ';=10;' both mean that it will wait 10 Ticks instead of 1. And ';=0' or anything < 0 will default to 0.", + "If the '=' Operator is used within Brackets, it returns the value the variable has been set to.", + "The Program saves the Char Index of the current Task, the 10 Variables (which reset to 0 as soon as the Program Loop stops), the 10 Member Variables and the remaining waiting Time in its NBT.", + "A = 10, B = 11, C = 12, D = 13, E = 14, F = 15, just for Hexadecimal Space saving, since Redstone has only 4 Bits.", + "For implementing Loops you just need 1 Punch Card per Loop, these Cards can restart once they are finished, depending on how many other Cards there are in the Program Loop you inserted your Card into, since it will process them procedurally.", + "A Punch Card Processor can run up to four Loops, each with the length of seven Punch Cards, parallel.", + "Why does the Punch Card need Ink to be made, you ask? Because the empty one needs to have some lines on, and the for the punched one it prints the Code to execute in a human readable format on the Card."); + + GT_Utility.getWrittenBook( + "Manual_Microwave", + "Microwave Oven Manual", + "Kitchen Industries", + "Congratulations, you inserted a random seemingly empty Book into the Microwave and these Letters appeared out of nowhere.", + "You just got a Microwave Oven and asked yourself 'why do I even need it?'. It's simple, the Microwave can cook for just 128 EU and at an insane speed. Not even a normal E-furnace can do it that fast and cheap!", + "This is the cheapest and fastest way to cook for you. That is why the Microwave Oven can be found in almost every Kitchen (see www.youwannabuyakitchen.ly).", + "Long time exposure to Microwaves can cause Cancer, but we doubt Steve lives long enough to die because of that.", + "Do not insert any Metals. It might result in an Explosion.", + "Do not dry Animals with it. It will result in a Hot Dog, no matter which Animal you put into it.", + "Do not insert inflammable Objects. The Oven will catch on Fire.", + "Do not insert Explosives such as Eggs. Just don't."); + + GT_Log.out.println("GT_Mod: Register Items."); + + new GT_IntegratedCircuit_Item(); + new GT_MetaGenerated_Item_01(); + new GT_MetaGenerated_Item_02(); + new GT_MetaGenerated_Item_03(); + // GT_MetaGenerated_Item_98 is initialized in GT_Proxy.onPostLoad() because we need to wait for fluids to be + // registered. + // Pre-initialization needs to happen before then, though, because the cell icons get deleted at some point + // between load and post-load. + GT_MetaGenerated_Item_98.preInit(); + new GT_MetaGenerated_Item_99(); + new GT_MetaGenerated_Tool_01(); + new GT_FluidDisplayItem(); + + // Tiered recipe materials actually appear to be set in GT_MetaTileEntity_BasicMachine_GT_Recipe, making these + // unused + ItemList.Rotor_LV.set(GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Tin, 1L)); + ItemList.Rotor_MV.set(GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Bronze, 1L)); + ItemList.Rotor_HV.set(GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Steel, 1L)); + ItemList.Rotor_EV.set(GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.StainlessSteel, 1L)); + ItemList.Rotor_IV.set(GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.TungstenSteel, 1L)); + + ItemList.VOLUMETRIC_FLASK.set(new GT_VolumetricFlask("Volumetric_Flask", "Volumetric flask", 1000)); + + Item tItem = (Item) GT_Utility.callConstructor( + "gregtech.common.items.GT_SensorCard_Item", + 0, + null, + false, + new Object[] { "sensorcard", "GregTech Sensor Card" }); + ItemList.NC_SensorCard.set( + tItem == null ? new GT_Generic_Item("sensorcard", "GregTech Sensor Card", "Nuclear Control not installed") + : tItem); + + Item advSensorCard = (Item) GT_Utility + .callConstructor("gregtech.common.items.GT_AdvancedSensorCard_Item", 0, null, false); + ItemList.NC_AdvancedSensorCard.set( + advSensorCard == null + ? new GT_Generic_Item( + "advancedsensorcard", + "GregTech Advanced Sensor Card", + "Nuclear Control not installed") + : advSensorCard); + + ItemList.Neutron_Reflector + .set(new GT_NeutronReflector_Item("neutronreflector", "Iridium Neutron Reflector", 0)); + ItemList.Reactor_Coolant_He_1 + .set(GregTech_API.constructCoolantCellItem("60k_Helium_Coolantcell", "60k He Coolant Cell", 60000)); + ItemList.Reactor_Coolant_He_3 + .set(GregTech_API.constructCoolantCellItem("180k_Helium_Coolantcell", "180k He Coolant Cell", 180000)); + ItemList.Reactor_Coolant_He_6 + .set(GregTech_API.constructCoolantCellItem("360k_Helium_Coolantcell", "360k He Coolant Cell", 360000)); + ItemList.Reactor_Coolant_NaK_1 + .set(GregTech_API.constructCoolantCellItem("60k_NaK_Coolantcell", "60k NaK Coolantcell", 60000)); + ItemList.Reactor_Coolant_NaK_3 + .set(GregTech_API.constructCoolantCellItem("180k_NaK_Coolantcell", "180k NaK Coolantcell", 180000)); + ItemList.Reactor_Coolant_NaK_6 + .set(GregTech_API.constructCoolantCellItem("360k_NaK_Coolantcell", "360k NaK Coolantcell", 360000)); + + ItemList.Reactor_Coolant_Sp_1 + .set(GregTech_API.constructCoolantCellItem("180k_Space_Coolantcell", "180k Sp Coolant Cell", 180000)); + + ItemList.Reactor_Coolant_Sp_2 + .set(GregTech_API.constructCoolantCellItem("360k_Space_Coolantcell", "360k Sp Coolant Cell", 360000)); + + ItemList.Reactor_Coolant_Sp_3 + .set(GregTech_API.constructCoolantCellItem("540k_Space_Coolantcell", "540k Sp Coolant Cell", 540000)); + + ItemList.Reactor_Coolant_Sp_6 + .set(GregTech_API.constructCoolantCellItem("1080k_Space_Coolantcell", "1080k Sp Coolant Cell", 1080000)); + + ItemList.GlowstoneCell.set( + new GT_BreederCell_Item( + "glowstoneCell", + "Glowstone Fuel Rod", + "Source of sunnarium", + 3000, + 1, + 10000, + () -> ItemList.SunnariumCell.get(1))); + ItemList.SunnariumCell.set(new GT_DepletetCell_Item("sunnariumCell", "Sunnarium Fuel Rod", 1)); + + ItemList.neutroniumHeatCapacitor.set( + GregTech_API + .constructCoolantCellItem("neutroniumHeatCapacitor", "1G Neutronium Heat Capacitor", 1000000000)); + + ItemList.Depleted_Thorium_1.set(new GT_DepletetCell_Item("ThoriumcellDep", "Fuel Rod (Depleted Thorium)", 1)); + ItemList.Depleted_Thorium_2 + .set(new GT_DepletetCell_Item("Double_ThoriumcellDep", "Dual Fuel Rod (Depleted Thorium)", 1)); // TODO + // CHECK + // num + ItemList.Depleted_Thorium_4 + .set(new GT_DepletetCell_Item("Quad_ThoriumcellDep", "Quad Fuel Rod (Depleted Thorium)", 1)); // TODO + // CHECK + // num + ItemList.ThoriumCell_1.set( + new GT_RadioactiveCellIC_Item( + "Thoriumcell", + "Fuel Rod (Thorium)", + 1, + 50000, + 0.4F, + 0, + 0.25F, + ItemList.Depleted_Thorium_1.get(1), + false)); + ItemList.ThoriumCell_2.set( + new GT_RadioactiveCellIC_Item( + "Double_Thoriumcell", + "Dual Fuel Rod (Thorium)", + 2, + 50000, + 0.4F, + 0, + 0.25F, + ItemList.Depleted_Thorium_2.get(1), + false)); + ItemList.ThoriumCell_4.set( + new GT_RadioactiveCellIC_Item( + "Quad_Thoriumcell", + "Quad Fuel Rod (Thorium)", + 4, + 50000, + 0.4F, + 0, + 0.25F, + ItemList.Depleted_Thorium_4.get(1), + false)); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Depleted_Thorium_1.get(1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Lutetium, 2L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Thorium, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Iron, 1L)) + .duration(25 * SECONDS) + .eut(48) + .addTo(thermalCentrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Depleted_Thorium_2.get(1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lutetium, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Thorium, 2L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Iron, 3L)) + .duration(25 * SECONDS) + .eut(48) + .addTo(thermalCentrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Depleted_Thorium_4.get(1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lutetium, 2L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Thorium, 4L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Iron, 6L)) + .duration(25 * SECONDS) + .eut(48) + .addTo(thermalCentrifugeRecipes); + + ItemList.Depleted_Naquadah_1 + .set(new GT_DepletetCell_Item("NaquadahcellDep", "Fuel Rod (Depleted Naquadah)", 1)); + ItemList.Depleted_Naquadah_2 + .set(new GT_DepletetCell_Item("Double_NaquadahcellDep", "Dual Fuel Rod (Depleted Naquadah)", 1)); + ItemList.Depleted_Naquadah_4 + .set(new GT_DepletetCell_Item("Quad_NaquadahcellDep", "Quad Fuel Rod (Depleted Naquadah)", 1)); + ItemList.NaquadahCell_1.set( + new GT_RadioactiveCellIC_Item( + "Naquadahcell", + "Fuel Rod (Naquadah)", + 1, + 100000, + 4F, + 1, + 1F, + ItemList.Depleted_Naquadah_1.get(1), + false)); + ItemList.NaquadahCell_2.set( + new GT_RadioactiveCellIC_Item( + "Double_Naquadahcell", + "Dual Fuel Rod (Naquadah)", + 2, + 100000, + 4F, + 1, + 1F, + ItemList.Depleted_Naquadah_2.get(1), + false)); + ItemList.NaquadahCell_4.set( + new GT_RadioactiveCellIC_Item( + "Quad_Naquadahcell", + "Quad Fuel Rod (Naquadah)", + 4, + 100000, + 4F, + 1, + 1F, + ItemList.Depleted_Naquadah_4.get(1), + false)); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Depleted_Naquadah_1.get(1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Naquadria, 2L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.NaquadahEnriched, 2L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.TungstenSteel, 8L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Platinum, 1L)) + .outputChances(10_000, 5_000, 5_000, 2_500, 10_000, 10_000) + .duration(25 * SECONDS) + .eut(2000) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Depleted_Naquadah_2.get(1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 2L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 2L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.NaquadahEnriched, 4L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.TungstenSteel, 18L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Platinum, 2L)) + .outputChances(10_000, 5_000, 5_000, 2_500, 10_000, 10_000) + .duration(50 * SECONDS) + .eut(2000) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Depleted_Naquadah_4.get(1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 4L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 4L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadria, 2L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.NaquadahEnriched, 8L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.TungstenSteel, 38L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Platinum, 4L)) + .outputChances(10_000, 5_000, 5_000, 2_500, 10_000, 10_000) + .duration(100 * SECONDS) + .eut(2000) + .addTo(centrifugeRecipes); + + ItemList.Depleted_MNq_1.set(new GT_DepletetCell_Item("MNqCellDep", "Fuel Rod (Depleted Nq*)", 1)); + ItemList.Depleted_MNq_2.set(new GT_DepletetCell_Item("Double_MNqCellDep", "Dual Fuel Rod (Depleted Nq*)", 1)); + ItemList.Depleted_MNq_4.set(new GT_DepletetCell_Item("Quad_MNqCellDep", "Quad Fuel Rod (Depleted Nq*)", 1)); + ItemList.MNqCell_1.set( + new GT_RadioactiveCellIC_Item( + "MNqCell", + "Fuel Rod (Nq* - MOX like behaviour)", + 1, + 100000, + 4F, + 1, + 1F, + ItemList.Depleted_MNq_1.get(1), + true)); + ItemList.MNqCell_2.set( + new GT_RadioactiveCellIC_Item( + "Double_MNqCell", + "Dual Fuel Rod (Nq* - MOX like behaviour)", + 2, + 100000, + 4F, + 1, + 1F, + ItemList.Depleted_MNq_2.get(1), + true)); + ItemList.MNqCell_4.set( + new GT_RadioactiveCellIC_Item( + "Quad_MNqCell", + "Quad Fuel Rod (Nq* - MOX like behaviour)", + 4, + 100000, + 4F, + 1, + 1F, + ItemList.Depleted_MNq_4.get(1), + true)); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Depleted_MNq_1.get(1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.NaquadahEnriched, 2L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Naquadria, 2L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.TungstenSteel, 8L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Platinum, 1L)) + .outputChances(10_000, 5_000, 5_000, 2_500, 10_000, 10_000) + .duration(25 * SECONDS) + .eut(2000) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Depleted_MNq_2.get(1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 2L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 2L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.NaquadahEnriched, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Naquadria, 4L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.TungstenSteel, 18L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Platinum, 2L)) + .outputChances(10_000, 5_000, 5_000, 2_500, 10_000, 10_000) + .duration(50 * SECONDS) + .eut(2000) + .addTo(centrifugeRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Depleted_MNq_4.get(1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 4L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Naquadah, 4L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.NaquadahEnriched, 2L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Naquadria, 8L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.TungstenSteel, 38L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Platinum, 4L)) + .outputChances(10_000, 5_000, 5_000, 2_500, 10_000, 10_000) + .duration(100 * SECONDS) + .eut(2000) + .addTo(centrifugeRecipes); + + ItemList.Uraniumcell_1.set( + new GT_RadioactiveCellIC_Item( + "reactorUraniumSimple", + "Fuel Rod (Uranium)", + 1, + 20000, + 2F, + 1, + 1F, + GT_ModHandler.getIC2Item("reactorDepletedUraniumSimple", 1), + false)); + ItemList.Uraniumcell_2.set( + new GT_RadioactiveCellIC_Item( + "reactorUraniumDual", + "Dual Fuel Rod (Uranium)", + 2, + 20000, + 2F, + 1, + 1F, + GT_ModHandler.getIC2Item("reactorDepletedUraniumDual", 1), + false)); + ItemList.Uraniumcell_4.set( + new GT_RadioactiveCellIC_Item( + "reactorUraniumQuad", + "Quad Fuel Rod (Uranium)", + 4, + 20000, + 2F, + 1, + 1F, + GT_ModHandler.getIC2Item("reactorDepletedUraniumQuad", 1), + false)); + ItemList.Moxcell_1.set( + new GT_RadioactiveCellIC_Item( + "reactorMOXSimple", + "Fuel Rod (Mox)", + 1, + 10000, + 2F, + 1, + 1F, + GT_ModHandler.getIC2Item("reactorDepletedMOXSimple", 1), + true)); + ItemList.Moxcell_2.set( + new GT_RadioactiveCellIC_Item( + "reactorMOXDual", + "Dual Fuel Rod (Mox)", + 2, + 10000, + 2F, + 1, + 1F, + GT_ModHandler.getIC2Item("reactorDepletedMOXDual", 1), + true)); + ItemList.Moxcell_4.set( + new GT_RadioactiveCellIC_Item( + "reactorMOXQuad", + "Quad Fuel Rod (Mox)", + 4, + 10000, + 2F, + 1, + 1F, + GT_ModHandler.getIC2Item("reactorDepletedMOXQuad", 1), + true)); + + GT_Log.out.println("GT_Mod: Adding Blocks."); + GregTech_API.sBlockMachines = new GT_Block_Machines(); + GregTech_API.sBlockCasings1 = new GT_Block_Casings1(); + GregTech_API.sBlockCasings2 = new GT_Block_Casings2(); + GregTech_API.sBlockCasings3 = new GT_Block_Casings3(); + GregTech_API.sBlockCasings4 = new GT_Block_Casings4(); + GregTech_API.sBlockCasings5 = new GT_Block_Casings5(); + GregTech_API.sBlockCasings6 = new GT_Block_Casings6(); + GregTech_API.sBlockCasings8 = new GT_Block_Casings8(); + GregTech_API.sBlockCasings9 = new GT_Block_Casings9(); + GregTech_API.sBlockGranites = new GT_Block_Granites(); + GregTech_API.sBlockLongDistancePipes = new GT_Block_LongDistancePipe(); + GregTech_API.sBlockConcretes = new GT_Block_Concretes(); + GregTech_API.sBlockStones = new GT_Block_Stones(); + GregTech_API.sBlockOres1 = new GT_Block_Ores(); + GregTech_API.sDroneRender = new GT_Block_Drone(); + // meta ID order, DO NOT CHANGE ORDER + + GregTech_API.sBlockMetal1 = new GT_Block_Metal( + "gt.blockmetal1", + new Materials[] { Materials.Adamantium, Materials.Aluminium, Materials.Americium, Materials.AnnealedCopper, + Materials.Antimony, Materials.Arsenic, Materials.AstralSilver, Materials.BatteryAlloy, + Materials.Beryllium, Materials.Bismuth, Materials.BismuthBronze, Materials.BlackBronze, + Materials.BlackSteel, Materials.BlueAlloy, Materials.BlueSteel, Materials.Brass }, + OrePrefixes.block, + gregtech.api.enums.Textures.BlockIcons.STORAGE_BLOCKS1); + + GregTech_API.sBlockMetal2 = new GT_Block_Metal( + "gt.blockmetal2", + new Materials[] { Materials.Bronze, Materials.Caesium, Materials.Cerium, Materials.Chrome, + Materials.ChromiumDioxide, Materials.Cobalt, Materials.CobaltBrass, Materials.Copper, + Materials.Cupronickel, Materials.DamascusSteel, Materials.DarkIron, Materials.DeepIron, Materials.Desh, + Materials.Duranium, Materials.Dysprosium, Materials.Electrum }, + OrePrefixes.block, + gregtech.api.enums.Textures.BlockIcons.STORAGE_BLOCKS2); + + GregTech_API.sBlockMetal3 = new GT_Block_Metal( + "gt.blockmetal3", + new Materials[] { Materials.ElectrumFlux, Materials.Enderium, Materials.Erbium, Materials.Europium, + Materials.FierySteel, Materials.Gadolinium, Materials.Gallium, Materials.Holmium, Materials.HSLA, + Materials.Indium, Materials.InfusedGold, Materials.Invar, Materials.Iridium, Materials.IronMagnetic, + Materials.IronWood, Materials.Kanthal }, + OrePrefixes.block, + gregtech.api.enums.Textures.BlockIcons.STORAGE_BLOCKS3); + + GregTech_API.sBlockMetal4 = new GT_Block_Metal( + "gt.blockmetal4", + new Materials[] { Materials.Knightmetal, Materials.Lanthanum, Materials.Lead, Materials.Lutetium, + Materials.Magnalium, Materials.Magnesium, Materials.Manganese, Materials.MeteoricIron, + Materials.MeteoricSteel, Materials.Trinium, Materials.Mithril, Materials.Molybdenum, Materials.Naquadah, + Materials.NaquadahAlloy, Materials.NaquadahEnriched, Materials.Naquadria }, + OrePrefixes.block, + gregtech.api.enums.Textures.BlockIcons.STORAGE_BLOCKS4); + + GregTech_API.sBlockMetal5 = new GT_Block_Metal( + "gt.blockmetal5", + new Materials[] { Materials.Neodymium, Materials.NeodymiumMagnetic, Materials.Neutronium, + Materials.Nichrome, Materials.Nickel, Materials.Niobium, Materials.NiobiumNitride, + Materials.NiobiumTitanium, Materials.Osmiridium, Materials.Osmium, Materials.Palladium, + Materials.PigIron, Materials.Platinum, Materials.Plutonium, Materials.Plutonium241, + Materials.Praseodymium }, + OrePrefixes.block, + gregtech.api.enums.Textures.BlockIcons.STORAGE_BLOCKS5); + + GregTech_API.sBlockMetal6 = new GT_Block_Metal( + "gt.blockmetal6", + new Materials[] { Materials.Promethium, Materials.RedAlloy, Materials.RedSteel, Materials.RoseGold, + Materials.Rubidium, Materials.Samarium, Materials.Scandium, Materials.ShadowIron, Materials.ShadowSteel, + Materials.Silicon, Materials.Silver, Materials.SolderingAlloy, Materials.StainlessSteel, + Materials.Steel, Materials.SteelMagnetic, Materials.SterlingSilver }, + OrePrefixes.block, + gregtech.api.enums.Textures.BlockIcons.STORAGE_BLOCKS6); + + GregTech_API.sBlockMetal7 = new GT_Block_Metal( + "gt.blockmetal7", + new Materials[] { Materials.Sunnarium, Materials.Tantalum, Materials.Tellurium, Materials.Terbium, + Materials.Thaumium, Materials.Thorium, Materials.Thulium, Materials.Tin, Materials.TinAlloy, + Materials.Titanium, Materials.Tritanium, Materials.Tungsten, Materials.TungstenSteel, Materials.Ultimet, + Materials.Uranium, Materials.Uranium235 }, + OrePrefixes.block, + gregtech.api.enums.Textures.BlockIcons.STORAGE_BLOCKS7); + + GregTech_API.sBlockMetal8 = new GT_Block_Metal( + "gt.blockmetal8", + new Materials[] { Materials.Vanadium, Materials.VanadiumGallium, Materials.WroughtIron, Materials.Ytterbium, + Materials.Yttrium, Materials.YttriumBariumCuprate, Materials.Zinc, Materials.TungstenCarbide, + Materials.VanadiumSteel, Materials.HSSG, Materials.HSSE, Materials.HSSS, Materials.Steeleaf, + Materials.Ichorium, Materials.Firestone, Materials.Shadow }, + OrePrefixes.block, + gregtech.api.enums.Textures.BlockIcons.STORAGE_BLOCKS8); + + GregTech_API.sBlockGem1 = new GT_Block_Metal( + "gt.blockgem1", + new Materials[] { Materials.InfusedAir, Materials.Amber, Materials.Amethyst, Materials.InfusedWater, + Materials.BlueTopaz, Materials.CertusQuartz, Materials.Dilithium, Materials.EnderEye, + Materials.EnderPearl, Materials.FoolsRuby, Materials.Force, Materials.Forcicium, Materials.Forcillium, + Materials.GreenSapphire, Materials.InfusedFire, Materials.Jasper }, + OrePrefixes.block, + gregtech.api.enums.Textures.BlockIcons.STORAGE_BLOCKS9); + + GregTech_API.sBlockGem2 = new GT_Block_Metal( + "gt.blockgem2", + new Materials[] { Materials.Lazurite, Materials.Lignite, Materials.Monazite, Materials.Niter, + Materials.Olivine, Materials.Opal, Materials.InfusedOrder, Materials.InfusedEntropy, + Materials.TricalciumPhosphate, Materials.Quartzite, Materials.GarnetRed, Materials.Ruby, + Materials.Sapphire, Materials.Sodalite, Materials.Tanzanite, Materials.InfusedEarth }, + OrePrefixes.block, + gregtech.api.enums.Textures.BlockIcons.STORAGE_BLOCKS10); + + GregTech_API.sBlockGem3 = new GT_Block_Metal( + "gt.blockgem3", + new Materials[] { Materials.Topaz, Materials.Vinteum, Materials.GarnetYellow, Materials.NetherStar, + Materials.Charcoal, Materials.Blaze }, + OrePrefixes.block, + gregtech.api.enums.Textures.BlockIcons.STORAGE_BLOCKS11); + + GregTech_API.sBlockMetal9 = new GT_Block_Metal( + "gt.blockmetal9", + new Materials[] { Materials.Cryolite, Materials.SiliconSG, MaterialsKevlar.NickelAluminide, + MaterialsUEVplus.SpaceTime, MaterialsUEVplus.TranscendentMetal, Materials.Oriharukon, + MaterialsUEVplus.WhiteDwarfMatter, MaterialsUEVplus.BlackDwarfMatter, MaterialsUEVplus.Universium, + MaterialsUEVplus.Eternity, MaterialsUEVplus.MagMatter }, + OrePrefixes.block, + gregtech.api.enums.Textures.BlockIcons.STORAGE_BLOCKS12); + + GregTech_API.sBlockReinforced = new GT_Block_Reinforced("gt.blockreinforced"); + + GT_Log.out.println("GT_Mod: Register TileEntities."); + + BaseMetaTileEntity tBaseMetaTileEntity = GregTech_API.constructBaseMetaTileEntity(); + + GT_Log.out.println("GT_Mod: Registering the BaseMetaTileEntity."); + GameRegistry.registerTileEntity(tBaseMetaTileEntity.getClass(), "BaseMetaTileEntity"); + FMLInterModComms.sendMessage( + AppliedEnergistics2.ID, + "whitelist-spatial", + tBaseMetaTileEntity.getClass() + .getName()); + + GT_Log.out.println("GT_Mod: Registering the DroneRender."); + GameRegistry.registerTileEntity(TileDrone.class, "DroneRender"); + + GT_Log.out.println("GT_Mod: Registering the BaseMetaPipeEntity."); + GameRegistry.registerTileEntity(BaseMetaPipeEntity.class, "BaseMetaPipeEntity"); + FMLInterModComms.sendMessage(AppliedEnergistics2.ID, "whitelist-spatial", BaseMetaPipeEntity.class.getName()); + + GT_Log.out.println("GT_Mod: Registering the Ore TileEntity."); + GameRegistry.registerTileEntity(GT_TileEntity_Ores.class, "GT_TileEntity_Ores"); + FMLInterModComms.sendMessage(AppliedEnergistics2.ID, "whitelist-spatial", GT_TileEntity_Ores.class.getName()); + + GT_Log.out.println("GT_Mod: Registering Fluids."); + Materials.ConstructionFoam.mFluid = GT_Utility + .getFluidForFilledItem(GT_ModHandler.getIC2Item("CFCell", 1L), true) + .getFluid(); + Materials.UUMatter.mFluid = GT_Utility.getFluidForFilledItem(GT_ModHandler.getIC2Item("uuMatterCell", 1L), true) + .getFluid(); + + GT_FluidFactory.builder("Air") + .withLocalizedName("Air") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Air) + .registerContainers(ItemList.Cell_Air.get(1L), ItemList.Cell_Empty.get(1L), 2000); + GT_FluidFactory.builder("LiquidOxygen") + .withLocalizedName("Liquid Oxygen") + .withStateAndTemperature(GAS, 60) + .buildAndRegister() + .configureMaterials(Materials.LiquidOxygen) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.LiquidOxygen, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("LiquidNitrogen") + .withLocalizedName("Liquid Nitrogen") + .withStateAndTemperature(GAS, 77) + .buildAndRegister() + .configureMaterials(Materials.LiquidNitrogen) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.LiquidNitrogen, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("LiquidAir") + .withLocalizedName("Liquid Air") + .withStateAndTemperature(LIQUID, 77) + .buildAndRegister() + .configureMaterials(Materials.LiquidAir) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.LiquidAir, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Oxygen") + .withLocalizedName("Oxygen") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Oxygen) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Oxygen, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Hydrogen") + .withLocalizedName("Hydrogen") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Hydrogen) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Hydrogen, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Deuterium") + .withLocalizedName("Deuterium") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Deuterium) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Deuterium, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Tritium") + .withLocalizedName("Tritium") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Tritium) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Tritium, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Helium") + .withLocalizedName("Helium") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Helium) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Helium, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Argon") + .withLocalizedName("Argon") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Argon) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Argon, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Radon") + .withLocalizedName("Radon") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Radon) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Radon, 1L), + ItemList.Cell_Empty.get(1L)); + + GT_FluidFactory.builder("Fluorine") + .withLocalizedName("Fluorine") + .withStateAndTemperature(GAS, 53) + .buildAndRegister() + .configureMaterials(Materials.Fluorine) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Fluorine, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Titaniumtetrachloride") + .withLocalizedName("Titaniumtetrachloride") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Titaniumtetrachloride) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Titaniumtetrachloride, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Helium-3") + .withLocalizedName("Helium-3") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Helium_3) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Helium_3, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Methane") + .withLocalizedName("Methane") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Methane) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Methane, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Nitrogen") + .withLocalizedName("Nitrogen") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Nitrogen) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Nitrogen, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("NitrogenDioxide") + .withLocalizedName("Nitrogen Dioxide") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.NitrogenDioxide) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.NitrogenDioxide, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Steam") + .withLocalizedName("Steam") + .withStateAndTemperature(GAS, 375) + .buildAndRegister() + .configureMaterials(Materials.Water) + .registerBContainers(GT_ModHandler.getIC2Item("steamCell", 1), Materials.Empty.getCells(1)); + + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Empty.getCells(1)) + .itemOutputs(GT_ModHandler.getIC2Item("steamCell", 1)) + .fluidInputs(GT_ModHandler.getSteam(1000)) + .duration(16 * TICKS) + .eut(1) + .addTo(fluidCannerRecipes); + + Materials.Ice.mGas = Materials.Water.mGas; + Materials.Water.mGas.setTemperature(375) + .setGaseous(true); + + ItemList.sOilExtraHeavy = GT_FluidFactory.of("liquid_extra_heavy_oil", "Very Heavy Oil", LIQUID, 295); + ItemList.sEpichlorhydrin = GT_FluidFactory.builder("liquid_epichlorhydrin") + .withLocalizedName("Epichlorohydrin") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Epichlorohydrin) + .registerBContainers(Materials.Epichlorohydrin.getCells(1), Materials.Empty.getCells(1)) + .asFluid(); + ItemList.sDrillingFluid = GT_FluidFactory.of("liquid_drillingfluid", "Drilling Fluid", LIQUID, 295); + ItemList.sToluene = GT_FluidFactory.builder("liquid_toluene") + .withLocalizedName("Toluene") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Toluene) + .registerBContainers(Materials.Toluene.getCells(1), Materials.Empty.getCells(1)) + .asFluid(); + ItemList.sNitrationMixture = GT_FluidFactory.builder("liquid_nitrationmixture") + .withLocalizedName("Nitration Mixture") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.NitrationMixture) + .registerBContainers(Materials.NitrationMixture.getCells(1), Materials.Empty.getCells(1)) + .asFluid(); + + GT_FluidFactory.builder("liquid_heavy_oil") + .withLocalizedName("Heavy Oil") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.OilHeavy) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.OilHeavy, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("liquid_medium_oil") + .withLocalizedName("Raw Oil") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.OilMedium) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.OilMedium, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("liquid_light_oil") + .withLocalizedName("Light Oil") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.OilLight) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.OilLight, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("gas_natural_gas") + .withLocalizedName("Natural Gas") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.NatruralGas) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.NatruralGas, 1L), + ItemList.Cell_Empty.get(1L)); + ItemList.sHydricSulfur = GT_FluidFactory.builder("liquid_hydricsulfur") + .withLocalizedName("Hydrogen Sulfide") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.HydricSulfide) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.HydricSulfide, 1L), + ItemList.Cell_Empty.get(1L)) + .asFluid(); + GT_FluidFactory.builder("gas_sulfuricgas") + .withLocalizedName("Sulfuric Gas") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.SulfuricGas) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SulfuricGas, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("gas_gas") + .withLocalizedName("Refinery Gas") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Gas) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Gas, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("liquid_sulfuricnaphtha") + .withLocalizedName("Sulfuric Naphtha") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.SulfuricNaphtha) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SulfuricNaphtha, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("liquid_sufluriclight_fuel") + .withLocalizedName("Sulfuric Light Fuel") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.SulfuricLightFuel) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SulfuricLightFuel, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("liquid_sulfuricheavy_fuel") + .withLocalizedName("Sulfuric Heavy Fuel") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.SulfuricHeavyFuel) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SulfuricHeavyFuel, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("liquid_naphtha") + .withLocalizedName("Naphtha") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Naphtha) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Naphtha, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("liquid_light_fuel") + .withLocalizedName("Light Fuel") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.LightFuel) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.LightFuel, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("liquid_heavy_fuel") + .withLocalizedName("Heavy Fuel") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.HeavyFuel) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.HeavyFuel, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("liquid_lpg") + .withLocalizedName("LPG") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.LPG) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.LPG, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("charcoal_byproducts") + .withTextureName("molten.autogenerated") + .withLocalizedName("Charcoal Byproducts") + .withColorRGBA(Materials.CharcoalByproducts.mRGBa) + .withStateAndTemperature(GAS, 775) + .buildAndRegister() + .configureMaterials(Materials.CharcoalByproducts) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.CharcoalByproducts, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("molten.bisphenol_a") + .withTextureName("molten.autogenerated") + .withLocalizedName("Molten Bisphenol A") + .withColorRGBA(Materials.BisphenolA.mRGBa) + .withStateAndTemperature(LIQUID, 432) + .buildAndRegister() + .configureMaterials(Materials.BisphenolA) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.BisphenolA, 1L), + ItemList.Cell_Empty.get(1L)); + + GT_FluidFactory.builder("UUAmplifier") + .withLocalizedName("UU Amplifier") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.UUAmplifier) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.UUAmplifier, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Chlorine") + .withLocalizedName("Chlorine") + .withStateAndTemperature(GAS, 295) + .buildAndRegister() + .configureMaterials(Materials.Chlorine) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Chlorine, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Mercury") + .withLocalizedName("Mercury") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Mercury) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Mercury, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("NitroFuel") + .withLocalizedName("Cetane-Boosted Diesel") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.NitroFuel) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.NitroFuel, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("SodiumPersulfate") + .withLocalizedName("Sodium Persulfate") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.SodiumPersulfate) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SodiumPersulfate, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("Glyceryl") + .withLocalizedName("Glyceryl Trinitrate") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Glyceryl) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Glyceryl, 1L), + ItemList.Cell_Empty.get(1L)); + + GT_FluidFactory.builder("lubricant") + .withLocalizedName("Lubricant") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Lubricant) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Lubricant, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("creosote") + .withLocalizedName("Creosote Oil") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Creosote) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Creosote, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("seedoil") + .withLocalizedName("Seed Oil") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.SeedOil) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SeedOil, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("fishoil") + .withLocalizedName("Fish Oil") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.FishOil) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.FishOil, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("oil") + .withLocalizedName("Oil") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Oil) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Oil, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("fuel") + .withLocalizedName("Diesel") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Fuel) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Fuel, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("for.honey") + .withLocalizedName("Honey") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Honey) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Honey, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("biomass") + .withLocalizedName("Biomass") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Biomass) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Biomass, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("bioethanol") + .withLocalizedName("Bio Ethanol") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Ethanol) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Ethanol, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("sulfuricacid") + .withLocalizedName("Sulfuric Acid") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.SulfuricAcid) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.SulfuricAcid, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("milk") + .withLocalizedName("Milk") + .withStateAndTemperature(LIQUID, 290) + .buildAndRegister() + .configureMaterials(Materials.Milk) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Milk, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("mcguffium") + .withLocalizedName("Mc Guffium 239") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.McGuffium239) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.McGuffium239, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("refinedGlue") + .withLocalizedName("Refined Glue") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Glue) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Glue, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("hotfryingoil") + .withLocalizedName("Hot Frying Oil") + .withStateAndTemperature(LIQUID, 400) + .buildAndRegister() + .configureMaterials(Materials.FryingOilHot) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.FryingOilHot, 1L), + ItemList.Cell_Empty.get(1L)); + + GT_FluidFactory.builder("DimensionallyTranscendentResidue") + .withLocalizedName("Dimensionally Transcendent Residue") + .withStateAndTemperature(LIQUID, 2000000000) + .buildAndRegister() + .configureMaterials(MaterialsUEVplus.DimensionallyTranscendentResidue) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, MaterialsUEVplus.DimensionallyTranscendentResidue, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("ExcitedDTCC") + .withLocalizedName("Excited Dimensionally Transcendent Crude Catalyst") + .withStateAndTemperature(LIQUID, 500000000) + .buildAndRegister() + .configureMaterials(MaterialsUEVplus.ExcitedDTCC) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, MaterialsUEVplus.ExcitedDTCC, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("ExcitedDTPC") + .withLocalizedName("Excited Dimensionally Transcendent Prosaic Catalyst") + .withStateAndTemperature(LIQUID, 500000000) + .buildAndRegister() + .configureMaterials(MaterialsUEVplus.ExcitedDTPC) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, MaterialsUEVplus.ExcitedDTPC, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("ExcitedDTRC") + .withLocalizedName("Excited Dimensionally Transcendent Resplendent Catalyst") + .withStateAndTemperature(LIQUID, 500000000) + .buildAndRegister() + .configureMaterials(MaterialsUEVplus.ExcitedDTRC) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, MaterialsUEVplus.ExcitedDTRC, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("ExcitedDTEC") + .withLocalizedName("Excited Dimensionally Transcendent Exotic Catalyst") + .withStateAndTemperature(LIQUID, 500000000) + .buildAndRegister() + .configureMaterials(MaterialsUEVplus.ExcitedDTEC) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, MaterialsUEVplus.ExcitedDTEC, 1L), + ItemList.Cell_Empty.get(1L)); + GT_FluidFactory.builder("ExcitedDTSC") + .withLocalizedName("Excited Dimensionally Transcendent Stellar Catalyst") + .withStateAndTemperature(LIQUID, 500000000) + .buildAndRegister() + .configureMaterials(MaterialsUEVplus.ExcitedDTSC) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, MaterialsUEVplus.ExcitedDTSC, 1L), + ItemList.Cell_Empty.get(1L)); + + GT_FluidFactory.builder(MaterialsUEVplus.RawStarMatter.mName) + .withLocalizedName(MaterialsUEVplus.RawStarMatter.mLocalizedName) + .withStateAndTemperature(LIQUID, 10_000_000) + .buildAndRegister() + .configureMaterials(MaterialsUEVplus.RawStarMatter) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, MaterialsUEVplus.RawStarMatter, 1L), + ItemList.Cell_Empty.get(1L)); + + GT_FluidFactory.builder(MaterialsUEVplus.Space.mName) + .withLocalizedName(MaterialsUEVplus.Space.mLocalizedName) + .withStateAndTemperature(MOLTEN, 0) + .buildAndRegister() + .configureMaterials(MaterialsUEVplus.Space) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, MaterialsUEVplus.Space, 1L), + ItemList.Cell_Empty.get(1L)); + + GT_FluidFactory.builder(MaterialsUEVplus.Time.mName) + .withLocalizedName(MaterialsUEVplus.Time.mLocalizedName) + .withStateAndTemperature(MOLTEN, 0) + .buildAndRegister() + .configureMaterials(MaterialsUEVplus.Time) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, MaterialsUEVplus.Time, 1L), + ItemList.Cell_Empty.get(1L)); + + GT_FluidFactory.builder("PrimordialMatter") + .withLocalizedName(MaterialsUEVplus.PrimordialMatter.mLocalizedName) + .withStateAndTemperature(LIQUID, 2_000_000_000) + .buildAndRegister() + .configureMaterials(MaterialsUEVplus.PrimordialMatter) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, MaterialsUEVplus.PrimordialMatter, 1L), + ItemList.Cell_Empty.get(1L)); + + GT_FluidFactory.builder("QuarkGluonPlasma") + .withLocalizedName(MaterialsUEVplus.QuarkGluonPlasma.mLocalizedName) + .withStateAndTemperature(LIQUID, 2_000_000_000) + .buildAndRegister() + .configureMaterials(MaterialsUEVplus.QuarkGluonPlasma) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, MaterialsUEVplus.QuarkGluonPlasma, 1L), + ItemList.Cell_Empty.get(1L)); + + GT_FluidFactory.builder("fieryblood") + .withLocalizedName("Fiery Blood") + .withStateAndTemperature(LIQUID, 6400) + .buildAndRegister() + .configureMaterials(Materials.FierySteel) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.FierySteel, 1L), + ItemList.Cell_Empty.get(1L)); + + GT_FluidFactory.builder("holywater") + .withLocalizedName("Holy Water") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.HolyWater) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.HolyWater, 1L), + ItemList.Cell_Empty.get(1L)); + if (ItemList.TF_Vial_FieryBlood.get(1L) != null) { + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + Materials.FierySteel.getFluid(250L), + ItemList.TF_Vial_FieryBlood.get(1L), + ItemList.Bottle_Empty.get(1L))); + } + + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + Materials.Milk.getFluid(1000L), + GT_OreDictUnificator.get(OrePrefixes.bucket, Materials.Milk, 1L), + GT_OreDictUnificator.get(OrePrefixes.bucket, Materials.Empty, 1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + Materials.Milk.getFluid(250L), + ItemList.Bottle_Milk.get(1L), + ItemList.Bottle_Empty.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + Materials.HolyWater.getFluid(250L), + ItemList.Bottle_Holy_Water.get(1L), + ItemList.Bottle_Empty.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + Materials.McGuffium239.getFluid(250L), + ItemList.McGuffium_239.get(1L), + ItemList.Bottle_Empty.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + Materials.Fuel.getFluid(100L), + ItemList.Tool_Lighter_Invar_Full.get(1L), + ItemList.Tool_Lighter_Invar_Empty.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + Materials.Fuel.getFluid(1000L), + ItemList.Tool_Lighter_Platinum_Full.get(1L), + ItemList.Tool_Lighter_Platinum_Empty.get(1L))); + + Dyes.dyeBlack.addFluidDye(GT_FluidFactory.of("squidink", "Squid Ink", LIQUID, 295)); + Dyes.dyeBlue.addFluidDye(GT_FluidFactory.of("indigo", "Indigo Dye", LIQUID, 295)); + for (byte i = 0; i < Dyes.VALUES.length; i = (byte) (i + 1)) { + Dyes tDye = Dyes.VALUES[i]; + tDye.addFluidDye( + GT_FluidFactory.builder( + "dye.watermixed." + tDye.name() + .toLowerCase(Locale.ENGLISH)) + .withTextureName("dyes") + .withLocalizedName("Water Mixed " + tDye.mName + " Dye") + .withColorRGBA(tDye.getRGBA()) + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .asFluid()); + tDye.addFluidDye( + GT_FluidFactory.builder( + "dye.chemical." + tDye.name() + .toLowerCase(Locale.ENGLISH)) + .withTextureName("dyes") + .withLocalizedName("Chemical " + tDye.mName + " Dye") + .withColorRGBA(tDye.getRGBA()) + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerContainers(ItemList.SPRAY_CAN_DYES[i].get(1L), ItemList.Spray_Empty.get(1L), 2304) + .asFluid()); + } + GT_FluidFactory.builder("ice") + .withLocalizedName("Crushed Ice") + .withStateAndTemperature(SLURRY, 270) + .buildAndRegister() + .configureMaterials(Materials.Ice) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Ice, 1L), + ItemList.Cell_Empty.get(1L)); + Materials.Water.mSolid = Materials.Ice.mSolid; + + GT_FluidFactory.builder("molten.glass") + .withLocalizedName("Molten Glass") + .withStateAndTemperature(MOLTEN, 1500) + .buildAndRegister() + .configureMaterials(Materials.Glass) + .registerContainers( + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Glass, 1L), + ItemList.Cell_Empty.get(1L), + 144); + GT_FluidFactory.builder("molten.redstone") + .withLocalizedName("Molten Redstone") + .withStateAndTemperature(MOLTEN, 500) + .buildAndRegister() + .configureMaterials(Materials.Redstone) + .registerContainers( + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Redstone, 1L), + ItemList.Cell_Empty.get(1L), + 144); + GT_FluidFactory.builder("molten.blaze") + .withLocalizedName("Molten Blaze") + .withStateAndTemperature(MOLTEN, 6400) + .buildAndRegister() + .configureMaterials(Materials.Blaze) + .registerContainers( + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Blaze, 1L), + ItemList.Cell_Empty.get(1L), + 144); + GT_FluidFactory.builder("wet.concrete") + .withLocalizedName("Wet Concrete") + .withStateAndTemperature(MOLTEN, 300) + .buildAndRegister() + .configureMaterials(Materials.Concrete) + .registerContainers( + GT_OreDictUnificator.get(OrePrefixes.cellMolten, Materials.Concrete, 1L), + ItemList.Cell_Empty.get(1L), + 144); + + for (Materials tMaterial : Materials.values()) { + if ((tMaterial.mStandardMoltenFluid == null) && (tMaterial.contains(SubTag.SMELTING_TO_FLUID)) + && (!tMaterial.contains(SubTag.NO_SMELTING))) { + GT_Mod.gregtechproxy.addAutogeneratedMoltenFluid(tMaterial); + if ((tMaterial.mSmeltInto != tMaterial) && (tMaterial.mSmeltInto.mStandardMoltenFluid == null)) { + GT_Mod.gregtechproxy.addAutogeneratedMoltenFluid(tMaterial.mSmeltInto); + } + } + if (tMaterial.mElement != null) { + GT_Mod.gregtechproxy.addAutogeneratedPlasmaFluid(tMaterial); + } + if (tMaterial.hasCorrespondingFluid()) { + GT_Mod.gregtechproxy.addAutoGeneratedCorrespondingFluid(tMaterial); + } + if (tMaterial.hasCorrespondingGas()) { + GT_Mod.gregtechproxy.addAutoGeneratedCorrespondingGas(tMaterial); + } + if (tMaterial.canBeCracked()) { + GT_Mod.gregtechproxy.addAutoGeneratedHydroCrackedFluids(tMaterial); + GT_Mod.gregtechproxy.addAutoGeneratedSteamCrackedFluids(tMaterial); + } + } + + GT_FluidFactory.builder("potion.awkward") + .withLocalizedName("Awkward Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.thick") + .withLocalizedName("Thick Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 32), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.mundane") + .withLocalizedName("Mundane Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 64), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.damage") + .withLocalizedName("Harming Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8204), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.damage.strong") + .withLocalizedName("Strong Harming Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8236), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.damage.splash") + .withLocalizedName("Splash Harming Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16396), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.damage.strong.splash") + .withLocalizedName("Strong Splash Harming Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16428), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.health") + .withLocalizedName("Healing Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8197), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.health.strong") + .withLocalizedName("Strong Healing Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8229), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.health.splash") + .withLocalizedName("Splash Healing Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16389), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.health.strong.splash") + .withLocalizedName("Strong Splash Healing Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16421), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.speed") + .withLocalizedName("Swiftness Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8194), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.speed.strong") + .withLocalizedName("Strong Swiftness Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8226), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.speed.long") + .withLocalizedName("Stretched Swiftness Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8258), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.speed.splash") + .withLocalizedName("Splash Swiftness Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16386), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.speed.strong.splash") + .withLocalizedName("Strong Splash Swiftness Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16418), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.speed.long.splash") + .withLocalizedName("Stretched Splash Swiftness Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16450), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.strength") + .withLocalizedName("Strength Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8201), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.strength.strong") + .withLocalizedName("Strong Strength Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8233), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.strength.long") + .withLocalizedName("Stretched Strength Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8265), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.strength.splash") + .withLocalizedName("Splash Strength Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16393), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.strength.strong.splash") + .withLocalizedName("Strong Splash Strength Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16425), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.strength.long.splash") + .withLocalizedName("Stretched Splash Strength Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16457), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.regen") + .withLocalizedName("Regenerating Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8193), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.regen.strong") + .withLocalizedName("Strong Regenerating Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8225), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.regen.long") + .withLocalizedName("Stretched Regenerating Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8257), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.regen.splash") + .withLocalizedName("Splash Regenerating Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16385), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.regen.strong.splash") + .withLocalizedName("Strong Splash Regenerating Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16417), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.regen.long.splash") + .withLocalizedName("Stretched Splash Regenerating Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16449), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.poison") + .withLocalizedName("Poisonous Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8196), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.poison.strong") + .withLocalizedName("Strong Poisonous Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8228), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.poison.long") + .withLocalizedName("Stretched Poisonous Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8260), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.poison.splash") + .withLocalizedName("Splash Poisonous Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16388), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.poison.strong.splash") + .withLocalizedName("Strong Splash Poisonous Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16420), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.poison.long.splash") + .withLocalizedName("Stretched Splash Poisonous Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16452), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.fireresistance") + .withLocalizedName("Fire Resistant Brew") + .withStateAndTemperature(LIQUID, 375) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8195), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.fireresistance.long") + .withLocalizedName("Stretched Fire Resistant Brew") + .withStateAndTemperature(LIQUID, 375) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8259), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.fireresistance.splash") + .withLocalizedName("Splash Fire Resistant Brew") + .withStateAndTemperature(LIQUID, 375) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16387), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.fireresistance.long.splash") + .withLocalizedName("Stretched Splash Fire Resistant Brew") + .withStateAndTemperature(LIQUID, 375) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16451), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.nightvision") + .withLocalizedName("Night Vision Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8198), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.nightvision.long") + .withLocalizedName("Stretched Night Vision Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8262), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.nightvision.splash") + .withLocalizedName("Splash Night Vision Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16390), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.nightvision.long.splash") + .withLocalizedName("Stretched Splash Night Vision Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16454), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.weakness") + .withLocalizedName("Weakening Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8200), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.weakness.long") + .withLocalizedName("Stretched Weakening Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8264), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.weakness.splash") + .withLocalizedName("Splash Weakening Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16392), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.weakness.long.splash") + .withLocalizedName("Stretched Splash Weakening Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16456), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.slowness") + .withLocalizedName("Lame Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8202), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.slowness.long") + .withLocalizedName("Stretched Lame Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8266), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.slowness.splash") + .withLocalizedName("Splash Lame Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16394), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.slowness.long.splash") + .withLocalizedName("Stretched Splash Lame Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16458), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.waterbreathing") + .withLocalizedName("Fishy Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8205), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.waterbreathing.long") + .withLocalizedName("Stretched Fishy Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8269), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.waterbreathing.splash") + .withLocalizedName("Splash Fishy Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16397), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.waterbreathing.long.splash") + .withLocalizedName("Stretched Splash Fishy Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16461), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.invisibility") + .withLocalizedName("Invisible Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8206), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.invisibility.long") + .withLocalizedName("Stretched Invisible Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 8270), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.invisibility.splash") + .withLocalizedName("Splash Invisible Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16398), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.invisibility.long.splash") + .withLocalizedName("Stretched Splash Invisible Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(new ItemStack(Items.potionitem, 1, 16462), ItemList.Bottle_Empty.get(1L)); + + GT_FluidFactory.builder("potion.purpledrink") + .withLocalizedName("Purple Drink") + .withStateAndTemperature(LIQUID, 275) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Purple_Drink.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.grapejuice") + .withLocalizedName("Grape Juice") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Grape_Juice.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.wine") + .withLocalizedName("Wine") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Wine.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.vinegar") + .withLocalizedName("Vinegar") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .configureMaterials(Materials.Vinegar) + .registerPContainers(ItemList.Bottle_Vinegar.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.potatojuice") + .withLocalizedName("Potato Juice") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Potato_Juice.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.vodka") + .withLocalizedName("Vodka") + .withStateAndTemperature(LIQUID, 275) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Vodka.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.leninade") + .withLocalizedName("Leninade") + .withStateAndTemperature(LIQUID, 275) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Leninade.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.mineralwater") + .withLocalizedName("Mineral Water") + .withStateAndTemperature(LIQUID, 275) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Mineral_Water.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.saltywater") + .withLocalizedName("Salty Water") + .withStateAndTemperature(LIQUID, 275) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Salty_Water.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.reedwater") + .withLocalizedName("Reed Water") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Reed_Water.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.rum") + .withLocalizedName("Rum") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Rum.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.piratebrew") + .withLocalizedName("Pirate Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Pirate_Brew.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.hopsjuice") + .withLocalizedName("Hops Juice") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Hops_Juice.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.darkbeer") + .withLocalizedName("Dark Beer") + .withStateAndTemperature(LIQUID, 275) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Dark_Beer.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.dragonblood") + .withLocalizedName("Dragon Blood") + .withStateAndTemperature(LIQUID, 375) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Dragon_Blood.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.wheatyjuice") + .withLocalizedName("Wheaty Juice") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Wheaty_Juice.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.scotch") + .withLocalizedName("Scotch") + .withStateAndTemperature(LIQUID, 275) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Scotch.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.glenmckenner") + .withLocalizedName("Glen McKenner") + .withStateAndTemperature(LIQUID, 275) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Glen_McKenner.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.wheatyhopsjuice") + .withLocalizedName("Wheaty Hops Juice") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Wheaty_Hops_Juice.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.beer") + .withLocalizedName("Beer") + .withStateAndTemperature(LIQUID, 275) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Beer.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.chillysauce") + .withLocalizedName("Chilly Sauce") + .withStateAndTemperature(LIQUID, 375) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Chilly_Sauce.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.hotsauce") + .withLocalizedName("Hot Sauce") + .withStateAndTemperature(LIQUID, 380) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Hot_Sauce.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.diabolosauce") + .withLocalizedName("Diabolo Sauce") + .withStateAndTemperature(LIQUID, 385) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Diabolo_Sauce.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.diablosauce") + .withLocalizedName("Diablo Sauce") + .withStateAndTemperature(LIQUID, 390) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Diablo_Sauce.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.diablosauce.strong") + .withLocalizedName("Old Man Snitches glitched Diablo Sauce") + .withStateAndTemperature(LIQUID, 999) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Snitches_Glitch_Sauce.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.applejuice") + .withLocalizedName("Apple Juice") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Apple_Juice.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.cider") + .withLocalizedName("Cider") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Cider.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.goldenapplejuice") + .withLocalizedName("Golden Apple Juice") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Golden_Apple_Juice.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.goldencider") + .withLocalizedName("Golden Cider") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Golden_Cider.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.idunsapplejuice") + .withLocalizedName("Idun's Apple Juice") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Iduns_Apple_Juice.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.notchesbrew") + .withLocalizedName("Notches Brew") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Notches_Brew.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.lemonjuice") + .withLocalizedName("Lemon Juice") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Lemon_Juice.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.limoncello") + .withLocalizedName("Limoncello") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Limoncello.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.lemonade") + .withLocalizedName("Lemonade") + .withStateAndTemperature(LIQUID, 275) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Lemonade.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.alcopops") + .withLocalizedName("Alcopops") + .withStateAndTemperature(LIQUID, 275) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Alcopops.get(1L), ItemList.Bottle_Empty.get(1L)); + GT_FluidFactory.builder("potion.cavejohnsonsgrenadejuice") + .withLocalizedName("Cave Johnsons Grenade Juice") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.Bottle_Cave_Johnsons_Grenade_Juice.get(1L), ItemList.Bottle_Empty.get(1L)); + + GT_FluidFactory.builder("potion.darkcoffee") + .withLocalizedName("Dark Coffee") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.ThermosCan_Dark_Coffee.get(1L), ItemList.ThermosCan_Empty.get(1L)); + GT_FluidFactory.builder("potion.darkcafeaulait") + .withLocalizedName("Dark Cafe au lait") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.ThermosCan_Dark_Cafe_au_lait.get(1L), ItemList.ThermosCan_Empty.get(1L)); + GT_FluidFactory.builder("potion.coffee") + .withLocalizedName("Coffee") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.ThermosCan_Coffee.get(1L), ItemList.ThermosCan_Empty.get(1L)); + GT_FluidFactory.builder("potion.cafeaulait") + .withLocalizedName("Cafe au lait") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.ThermosCan_Cafe_au_lait.get(1L), ItemList.ThermosCan_Empty.get(1L)); + GT_FluidFactory.builder("potion.laitaucafe") + .withLocalizedName("Lait au cafe") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.ThermosCan_Lait_au_cafe.get(1L), ItemList.ThermosCan_Empty.get(1L)); + GT_FluidFactory.builder("potion.darkchocolatemilk") + .withLocalizedName("Bitter Chocolate Milk") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.ThermosCan_Dark_Chocolate_Milk.get(1L), ItemList.ThermosCan_Empty.get(1L)); + GT_FluidFactory.builder("potion.chocolatemilk") + .withLocalizedName("Chocolate Milk") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.ThermosCan_Chocolate_Milk.get(1L), ItemList.ThermosCan_Empty.get(1L)); + GT_FluidFactory.builder("potion.tea") + .withLocalizedName("Tea") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.ThermosCan_Tea.get(1L), ItemList.ThermosCan_Empty.get(1L)); + GT_FluidFactory.builder("potion.sweettea") + .withLocalizedName("Sweet Tea") + .withStateAndTemperature(LIQUID, 295) + .buildAndRegister() + .registerPContainers(ItemList.ThermosCan_Sweet_Tea.get(1L), ItemList.ThermosCan_Empty.get(1L)); + GT_FluidFactory.builder("potion.icetea") + .withLocalizedName("Ice Tea") + .withStateAndTemperature(LIQUID, 255) + .buildAndRegister() + .registerPContainers(ItemList.ThermosCan_Ice_Tea.get(1L), ItemList.ThermosCan_Empty.get(1L)); + GT_FluidFactory.builder("liquid_sodium") + .withLocalizedName("Liquid Sodium") + .withStateAndTemperature(LIQUID, 495) + .buildAndRegister() + .configureMaterials(Materials.Sodium) + .registerBContainers( + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Sodium, 1L), + ItemList.Cell_Empty.get(1L)); + + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.poison.strong", 750), + ItemList.IC2_Spray_WeedEx.get(1L), + ItemList.Spray_Empty.get(1L))); + + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.poison", 125), + ItemList.Arrow_Head_Glass_Poison.get(1L), + ItemList.Arrow_Head_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.poison.long", 125), + ItemList.Arrow_Head_Glass_Poison_Long.get(1L), + ItemList.Arrow_Head_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.poison.strong", 125), + ItemList.Arrow_Head_Glass_Poison_Strong.get(1L), + ItemList.Arrow_Head_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.slowness", 125), + ItemList.Arrow_Head_Glass_Slowness.get(1L), + ItemList.Arrow_Head_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.slowness.long", 125), + ItemList.Arrow_Head_Glass_Slowness_Long.get(1L), + ItemList.Arrow_Head_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.weakness", 125), + ItemList.Arrow_Head_Glass_Weakness.get(1L), + ItemList.Arrow_Head_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.weakness.long", 125), + ItemList.Arrow_Head_Glass_Weakness_Long.get(1L), + ItemList.Arrow_Head_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("holywater", 125), + ItemList.Arrow_Head_Glass_Holy_Water.get(1L), + ItemList.Arrow_Head_Glass_Emtpy.get(1L))); + + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.poison", 125), + ItemList.Arrow_Wooden_Glass_Poison.get(1L), + ItemList.Arrow_Wooden_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.poison.long", 125), + ItemList.Arrow_Wooden_Glass_Poison_Long.get(1L), + ItemList.Arrow_Wooden_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.poison.strong", 125), + ItemList.Arrow_Wooden_Glass_Poison_Strong.get(1L), + ItemList.Arrow_Wooden_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.slowness", 125), + ItemList.Arrow_Wooden_Glass_Slowness.get(1L), + ItemList.Arrow_Wooden_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.slowness.long", 125), + ItemList.Arrow_Wooden_Glass_Slowness_Long.get(1L), + ItemList.Arrow_Wooden_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.weakness", 125), + ItemList.Arrow_Wooden_Glass_Weakness.get(1L), + ItemList.Arrow_Wooden_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.weakness.long", 125), + ItemList.Arrow_Wooden_Glass_Weakness_Long.get(1L), + ItemList.Arrow_Wooden_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("holywater", 125), + ItemList.Arrow_Wooden_Glass_Holy_Water.get(1L), + ItemList.Arrow_Wooden_Glass_Emtpy.get(1L))); + + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.poison", 125), + ItemList.Arrow_Plastic_Glass_Poison.get(1L), + ItemList.Arrow_Plastic_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.poison.long", 125), + ItemList.Arrow_Plastic_Glass_Poison_Long.get(1L), + ItemList.Arrow_Plastic_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.poison.strong", 125), + ItemList.Arrow_Plastic_Glass_Poison_Strong.get(1L), + ItemList.Arrow_Plastic_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.slowness", 125), + ItemList.Arrow_Plastic_Glass_Slowness.get(1L), + ItemList.Arrow_Plastic_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.slowness.long", 125), + ItemList.Arrow_Plastic_Glass_Slowness_Long.get(1L), + ItemList.Arrow_Plastic_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.weakness", 125), + ItemList.Arrow_Plastic_Glass_Weakness.get(1L), + ItemList.Arrow_Plastic_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("potion.weakness.long", 125), + ItemList.Arrow_Plastic_Glass_Weakness_Long.get(1L), + ItemList.Arrow_Plastic_Glass_Emtpy.get(1L))); + FluidContainerRegistry.registerFluidContainer( + new FluidContainerRegistry.FluidContainerData( + FluidRegistry.getFluidStack("holywater", 125), + ItemList.Arrow_Plastic_Glass_Holy_Water.get(1L), + ItemList.Arrow_Plastic_Glass_Emtpy.get(1L))); + if (!GT_Values.D1) { + try { + Class.forName("codechicken.nei.api.API"); + GT_Log.out.println("GT_Mod: Hiding certain Items from NEI."); + API.hideItem(ItemList.Display_Fluid.getWildcard(1L)); + } catch (Throwable e) { + if (GT_Values.D1) { + e.printStackTrace(GT_Log.err); + } + } + } + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.cobblestone, 1, WILDCARD)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.gravel, 1, WILDCARD)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 1L), new ItemStack(Items.flint, 1)) + .outputChances(10000, 1000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.furnace, 1, WILDCARD)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 8L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.lit_furnace, 1, WILDCARD)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Stone, 8L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_OreDictUnificator.set( + OrePrefixes.ingot, + Materials.FierySteel, + GT_ModHandler.getModItem(TwilightForest.ID, "item.fieryIngot", 1L, 0)); + GT_OreDictUnificator.set( + OrePrefixes.ingot, + Materials.Knightmetal, + GT_ModHandler.getModItem(TwilightForest.ID, "item.knightMetal", 1L, 0)); + GT_OreDictUnificator.set( + OrePrefixes.ingot, + Materials.Steeleaf, + GT_ModHandler.getModItem(TwilightForest.ID, "item.steeleafIngot", 1L, 0)); + GT_OreDictUnificator.set( + OrePrefixes.ingot, + Materials.IronWood, + GT_ModHandler.getModItem(TwilightForest.ID, "item.ironwoodIngot", 1L, 0)); + GT_OreDictUnificator + .set(OrePrefixes.gem, Materials.InfusedAir, GT_ModHandler.getModItem(Thaumcraft.ID, "ItemShard", 1L, 0)); + GT_OreDictUnificator + .set(OrePrefixes.gem, Materials.InfusedFire, GT_ModHandler.getModItem(Thaumcraft.ID, "ItemShard", 1L, 1)); + GT_OreDictUnificator + .set(OrePrefixes.gem, Materials.InfusedWater, GT_ModHandler.getModItem(Thaumcraft.ID, "ItemShard", 1L, 2)); + GT_OreDictUnificator + .set(OrePrefixes.gem, Materials.InfusedEarth, GT_ModHandler.getModItem(Thaumcraft.ID, "ItemShard", 1L, 3)); + GT_OreDictUnificator + .set(OrePrefixes.gem, Materials.InfusedOrder, GT_ModHandler.getModItem(Thaumcraft.ID, "ItemShard", 1L, 4)); + GT_OreDictUnificator.set( + OrePrefixes.gem, + Materials.InfusedEntropy, + GT_ModHandler.getModItem(Thaumcraft.ID, "ItemShard", 1L, 5)); + GT_OreDictUnificator + .set(OrePrefixes.nugget, Materials.Mercury, GT_ModHandler.getModItem(Thaumcraft.ID, "ItemNugget", 1L, 5)); + GT_OreDictUnificator + .set(OrePrefixes.nugget, Materials.Thaumium, GT_ModHandler.getModItem(Thaumcraft.ID, "ItemNugget", 1L, 6)); + GT_OreDictUnificator + .set(OrePrefixes.ingot, Materials.Thaumium, GT_ModHandler.getModItem(Thaumcraft.ID, "ItemResource", 1L, 2)); + GT_OreDictUnificator + .set(OrePrefixes.gem, Materials.Mercury, GT_ModHandler.getModItem(Thaumcraft.ID, "ItemResource", 1L, 3)); + GT_OreDictUnificator + .set(OrePrefixes.gem, Materials.Amber, GT_ModHandler.getModItem(Thaumcraft.ID, "ItemResource", 1L, 6)); + GT_OreDictUnificator + .set(OrePrefixes.gem, Materials.Firestone, GT_ModHandler.getModItem(Railcraft.ID, "firestone.raw", 1L)); + + GT_OreDictUnificator + .set(OrePrefixes.nugget, Materials.Void, GT_ModHandler.getModItem(Thaumcraft.ID, "ItemNugget", 1L, 7)); + GT_OreDictUnificator + .set(OrePrefixes.ingot, Materials.Void, GT_ModHandler.getModItem(Thaumcraft.ID, "ItemResource", 1L, 16)); + + if (GregTech_API.sUnification + .get(ConfigCategories.specialunificationtargets + "." + "railcraft", "plateIron", true)) { + GT_OreDictUnificator + .set(OrePrefixes.plate, Materials.Iron, GT_ModHandler.getModItem(Railcraft.ID, "part.plate", 1L, 0)); + } else { + GT_OreDictUnificator.set( + OrePrefixes.plate, + Materials.Iron, + GT_ModHandler.getModItem(Railcraft.ID, "part.plate", 1L, 0), + false, + false); + } + + if (GregTech_API.sUnification + .get(ConfigCategories.specialunificationtargets + "." + "railcraft", "plateSteel", true)) { + GT_OreDictUnificator + .set(OrePrefixes.plate, Materials.Steel, GT_ModHandler.getModItem(Railcraft.ID, "part.plate", 1L, 1)); + } else { + GT_OreDictUnificator.set( + OrePrefixes.plate, + Materials.Steel, + GT_ModHandler.getModItem(Railcraft.ID, "part.plate", 1L, 1), + false, + false); + } + + if (GregTech_API.sUnification + .get(ConfigCategories.specialunificationtargets + "." + "railcraft", "plateTinAlloy", true)) { + GT_OreDictUnificator.set( + OrePrefixes.plate, + Materials.TinAlloy, + GT_ModHandler.getModItem(Railcraft.ID, "part.plate", 1L, 2)); + } else { + GT_OreDictUnificator.set( + OrePrefixes.plate, + Materials.TinAlloy, + GT_ModHandler.getModItem(Railcraft.ID, "part.plate", 1L, 2), + false, + false); + } + + if (GregTech_API.sUnification + .get(ConfigCategories.specialunificationtargets + "." + "railcraft", "plateCopper", true)) { + GT_OreDictUnificator + .set(OrePrefixes.plate, Materials.Copper, GT_ModHandler.getModItem(Railcraft.ID, "part.plate", 1L, 3)); + } else { + GT_OreDictUnificator.set( + OrePrefixes.plate, + Materials.Copper, + GT_ModHandler.getModItem(Railcraft.ID, "part.plate", 1L, 3), + false, + false); + } + + GT_OreDictUnificator.set( + OrePrefixes.dust, + Materials.Cocoa, + GT_ModHandler.getModItem(PamsHarvestCraft.ID, "cocoapowderItem", 1L, 0)); + GT_OreDictUnificator.set(OrePrefixes.dust, Materials.Coffee, ItemList.IC2_CoffeePowder.get(1L)); + + GregTech_API + .registerMachineBlock(GT_Utility.getBlockFromStack(GT_ModHandler.getIC2Item("reinforcedGlass", 0)), 0); + + GregTech_API.sSolenoidCoilCasings = new GT_Cyclotron_Coils(); + ItemList.TierdDrone0 + .set(new GT_TierDrone("tierdDrone0", "Drone (Level 1)", "Quadcopter Stable Small Aircraft", 1)); + ItemList.TierdDrone1 + .set(new GT_TierDrone("tierdDrone1", "Drone (Level 2)", "Dual Turbo High-Ejection Medium Aircraft", 2)); + ItemList.TierdDrone2 + .set(new GT_TierDrone("tierdDrone2", "Drone (Level 3)", "Single Engine Anti-Gravity Large Aircraft", 3)); + + } +} diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java b/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java new file mode 100644 index 0000000000..d1196552c6 --- /dev/null +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_MetaTileEntities.java @@ -0,0 +1,4307 @@ +package gregtech.loaders.preload; + +import static gregtech.api.enums.MetaTileEntityIDs.ADVANCED_DATA_ACCESS_HATCH; +import static gregtech.api.enums.MetaTileEntityIDs.ADVANCED_DEBUG_STRUCTURE_WRITTER; +import static gregtech.api.enums.MetaTileEntityIDs.ADVANCED_SEISMIC_PROSPECTOR_EV; +import static gregtech.api.enums.MetaTileEntityIDs.ADVANCED_SEISMIC_PROSPECTOR_HV; +import static gregtech.api.enums.MetaTileEntityIDs.ADVANCED_SEISMIC_PROSPECTOR_LV; +import static gregtech.api.enums.MetaTileEntityIDs.ADVANCED_SEISMIC_PROSPECTOR_MV; +import static gregtech.api.enums.MetaTileEntityIDs.ASSEMBLING_LINE_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.AUTOMATABLE_DATA_ACCESS_HATCH; +import static gregtech.api.enums.MetaTileEntityIDs.AUTO_MAINTENANCE_HATCH; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_1_BY_1_EV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_1_BY_1_HV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_1_BY_1_IV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_1_BY_1_LV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_1_BY_1_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_1_BY_1_MV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_1_BY_1_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_1_BY_1_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_1_BY_1_UV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_1_BY_1_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_2_BY_2_EV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_2_BY_2_HV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_2_BY_2_IV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_2_BY_2_LV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_2_BY_2_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_2_BY_2_MV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_2_BY_2_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_2_BY_2_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_2_BY_2_UV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_2_BY_2_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_3_BY_3_EV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_3_BY_3_HV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_3_BY_3_IV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_3_BY_3_LV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_3_BY_3_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_3_BY_3_MV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_3_BY_3_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_3_BY_3_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_3_BY_3_UV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_3_BY_3_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_4_BY_4_EV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_4_BY_4_HV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_4_BY_4_IV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_4_BY_4_LV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_4_BY_4_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_4_BY_4_MV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_4_BY_4_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_4_BY_4_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_4_BY_4_UV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_BUFFER_4_BY_4_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_CHARGER_4_BY_4_EV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_CHARGER_4_BY_4_HV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_CHARGER_4_BY_4_IV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_CHARGER_4_BY_4_LV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_CHARGER_4_BY_4_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_CHARGER_4_BY_4_MV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_CHARGER_4_BY_4_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_CHARGER_4_BY_4_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_CHARGER_4_BY_4_UV; +import static gregtech.api.enums.MetaTileEntityIDs.BATTERY_CHARGER_4_BY_4_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.BREWERY_EV; +import static gregtech.api.enums.MetaTileEntityIDs.BREWERY_HV; +import static gregtech.api.enums.MetaTileEntityIDs.BREWERY_IV; +import static gregtech.api.enums.MetaTileEntityIDs.BREWERY_LV; +import static gregtech.api.enums.MetaTileEntityIDs.BREWERY_MV; +import static gregtech.api.enums.MetaTileEntityIDs.BRICKED_BLAST_FURNACE_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.CHARCOAL_PILE_IGNITER_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.CHEST_BUFFER_EV; +import static gregtech.api.enums.MetaTileEntityIDs.CHEST_BUFFER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.CHEST_BUFFER_IV; +import static gregtech.api.enums.MetaTileEntityIDs.CHEST_BUFFER_LV; +import static gregtech.api.enums.MetaTileEntityIDs.CHEST_BUFFER_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.CHEST_BUFFER_MV; +import static gregtech.api.enums.MetaTileEntityIDs.CHEST_BUFFER_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.CHEST_BUFFER_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.CHEST_BUFFER_UV; +import static gregtech.api.enums.MetaTileEntityIDs.CHEST_BUFFER_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.CLEANROOM_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.COMBUSTION_ENGINE_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.COMBUSTION_GENERATOR_HV; +import static gregtech.api.enums.MetaTileEntityIDs.COMBUSTION_GENERATOR_LV; +import static gregtech.api.enums.MetaTileEntityIDs.COMBUSTION_GENERATOR_MV; +import static gregtech.api.enums.MetaTileEntityIDs.CONCRETE_BACKFILLER_II_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.CONCRETE_BACKFILLER_I_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.CRAFTING_INPUT_ME; +import static gregtech.api.enums.MetaTileEntityIDs.CRAFTING_INPUT_ME_BUS; +import static gregtech.api.enums.MetaTileEntityIDs.CRAFTING_INPUT_SLAVE; +import static gregtech.api.enums.MetaTileEntityIDs.DATA_ACCESS_HATCH; +import static gregtech.api.enums.MetaTileEntityIDs.DISTILLATION_TOWER_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.DTPF_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.DYNAMO_HATCH_EV; +import static gregtech.api.enums.MetaTileEntityIDs.DYNAMO_HATCH_HV; +import static gregtech.api.enums.MetaTileEntityIDs.DYNAMO_HATCH_IV; +import static gregtech.api.enums.MetaTileEntityIDs.DYNAMO_HATCH_LV; +import static gregtech.api.enums.MetaTileEntityIDs.DYNAMO_HATCH_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.DYNAMO_HATCH_MV; +import static gregtech.api.enums.MetaTileEntityIDs.DYNAMO_HATCH_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.DYNAMO_HATCH_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.DYNAMO_HATCH_UV; +import static gregtech.api.enums.MetaTileEntityIDs.DYNAMO_HATCH_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.DroneDownLink; +import static gregtech.api.enums.MetaTileEntityIDs.Drone_Centre; +import static gregtech.api.enums.MetaTileEntityIDs.EBF_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.ENERGY_HATCH_EV; +import static gregtech.api.enums.MetaTileEntityIDs.ENERGY_HATCH_HV; +import static gregtech.api.enums.MetaTileEntityIDs.ENERGY_HATCH_IV; +import static gregtech.api.enums.MetaTileEntityIDs.ENERGY_HATCH_LV; +import static gregtech.api.enums.MetaTileEntityIDs.ENERGY_HATCH_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.ENERGY_HATCH_MV; +import static gregtech.api.enums.MetaTileEntityIDs.ENERGY_HATCH_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.ENERGY_HATCH_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.ENERGY_HATCH_UV; +import static gregtech.api.enums.MetaTileEntityIDs.ENERGY_HATCH_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.EXTREME_COMBUSTION_ENGINE_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.FUSION_CONTROLLER_MKI; +import static gregtech.api.enums.MetaTileEntityIDs.FUSION_CONTROLLER_MKII; +import static gregtech.api.enums.MetaTileEntityIDs.FUSION_CONTROLLER_MKIII; +import static gregtech.api.enums.MetaTileEntityIDs.GAS_TURBINE_EV; +import static gregtech.api.enums.MetaTileEntityIDs.GAS_TURBINE_HV; +import static gregtech.api.enums.MetaTileEntityIDs.GAS_TURBINE_IV; +import static gregtech.api.enums.MetaTileEntityIDs.GAS_TURBINE_LV; +import static gregtech.api.enums.MetaTileEntityIDs.GAS_TURBINE_MV; +import static gregtech.api.enums.MetaTileEntityIDs.HIGH_PRESSURE_COAL_BOILER; +import static gregtech.api.enums.MetaTileEntityIDs.HIGH_PRESSURE_LAVA_BOILER; +import static gregtech.api.enums.MetaTileEntityIDs.HIGH_PRESSURE_SOLAR_BOILER; +import static gregtech.api.enums.MetaTileEntityIDs.HP_STEAM_ALLOY_SMELTER; +import static gregtech.api.enums.MetaTileEntityIDs.HP_STEAM_COMPRESSOR; +import static gregtech.api.enums.MetaTileEntityIDs.HP_STEAM_EXTRACTOR; +import static gregtech.api.enums.MetaTileEntityIDs.HP_STEAM_FORGE_HAMMER; +import static gregtech.api.enums.MetaTileEntityIDs.HP_STEAM_FURNACE; +import static gregtech.api.enums.MetaTileEntityIDs.HP_STEAM_MACERATOR; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_BRICKED_BRONZE; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_BRONZE; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_EV; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_HV; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_IV; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_LV; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_MV; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_STEEL; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_UV; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_WROUGHT_IRON; +import static gregtech.api.enums.MetaTileEntityIDs.HULL_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.IMPLOSION_COMPRESSOR_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.INDUSTRIAL_APIARY; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_BUS_EV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_BUS_HV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_BUS_IV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_BUS_LV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_BUS_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_BUS_ME; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_BUS_ME_ADVANCED; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_BUS_MV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_BUS_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_BUS_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_BUS_UV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_BUS_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_HATCH_EV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_HATCH_HV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_HATCH_IV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_HATCH_LV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_HATCH_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_HATCH_ME; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_HATCH_ME_ADVANCED; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_HATCH_MV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_HATCH_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_HATCH_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_HATCH_UV; +import static gregtech.api.enums.MetaTileEntityIDs.INPUT_HATCH_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.INTEGRATED_ORE_FACTORY_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_DISTRIBUTOR_EV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_DISTRIBUTOR_HV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_DISTRIBUTOR_IV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_DISTRIBUTOR_LV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_DISTRIBUTOR_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_DISTRIBUTOR_MV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_DISTRIBUTOR_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_DISTRIBUTOR_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_DISTRIBUTOR_UV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_DISTRIBUTOR_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_FILTER_EV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_FILTER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_FILTER_IV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_FILTER_LV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_FILTER_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_FILTER_MV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_FILTER_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_FILTER_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_FILTER_UV; +import static gregtech.api.enums.MetaTileEntityIDs.ITEM_FILTER_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.LARGE_ADVANCED_GAS_TURBINE_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.LARGE_BRONZE_BOILER_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.LARGE_GAS_TURBINE_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.LARGE_HEAT_EXCHANGER_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.LARGE_HP_STEAM_TURBINE_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.LARGE_PLASMA_TURBINE_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.LARGE_STEAM_TURBINE_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.LARGE_STEEL_BOILER_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.LARGE_TITANIUM_BOILER_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.LARGE_TUNGSTENSTEEL_BOILER_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.LCR_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.LIGHTNING_ROD_EV; +import static gregtech.api.enums.MetaTileEntityIDs.LIGHTNING_ROD_HV; +import static gregtech.api.enums.MetaTileEntityIDs.LIGHTNING_ROD_IV; +import static gregtech.api.enums.MetaTileEntityIDs.LOCKER_EV; +import static gregtech.api.enums.MetaTileEntityIDs.LOCKER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.LOCKER_IV; +import static gregtech.api.enums.MetaTileEntityIDs.LOCKER_LV; +import static gregtech.api.enums.MetaTileEntityIDs.LOCKER_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.LOCKER_MV; +import static gregtech.api.enums.MetaTileEntityIDs.LOCKER_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.LOCKER_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.LOCKER_UV; +import static gregtech.api.enums.MetaTileEntityIDs.LOCKER_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.LONG_DISTANCE_PIPELINE_FLUID; +import static gregtech.api.enums.MetaTileEntityIDs.LONG_DISTANCE_PIPELINE_ITEM; +import static gregtech.api.enums.MetaTileEntityIDs.MAGIC_ENERGY_ABSORBER_EV; +import static gregtech.api.enums.MetaTileEntityIDs.MAGIC_ENERGY_ABSORBER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.MAGIC_ENERGY_ABSORBER_LV; +import static gregtech.api.enums.MetaTileEntityIDs.MAGIC_ENERGY_ABSORBER_MV; +import static gregtech.api.enums.MetaTileEntityIDs.MAGIC_ENERGY_CONVERTER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.MAGIC_ENERGY_CONVERTER_LV; +import static gregtech.api.enums.MetaTileEntityIDs.MAGIC_ENERGY_CONVERTER_MV; +import static gregtech.api.enums.MetaTileEntityIDs.MAINTENANCE_HATCH; +import static gregtech.api.enums.MetaTileEntityIDs.MASS_FABRICATOR_EV; +import static gregtech.api.enums.MetaTileEntityIDs.MASS_FABRICATOR_HV; +import static gregtech.api.enums.MetaTileEntityIDs.MASS_FABRICATOR_IV; +import static gregtech.api.enums.MetaTileEntityIDs.MASS_FABRICATOR_LV; +import static gregtech.api.enums.MetaTileEntityIDs.MASS_FABRICATOR_MV; +import static gregtech.api.enums.MetaTileEntityIDs.MICROWAVE_ENERGY_TRANSMITTER_EV; +import static gregtech.api.enums.MetaTileEntityIDs.MICROWAVE_ENERGY_TRANSMITTER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.MICROWAVE_ENERGY_TRANSMITTER_IV; +import static gregtech.api.enums.MetaTileEntityIDs.MICROWAVE_ENERGY_TRANSMITTER_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.MICROWAVE_ENERGY_TRANSMITTER_UV; +import static gregtech.api.enums.MetaTileEntityIDs.MICROWAVE_ENERGY_TRANSMITTER_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.MINER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.MINER_LV; +import static gregtech.api.enums.MetaTileEntityIDs.MINER_MV; +import static gregtech.api.enums.MetaTileEntityIDs.MONSTER_REPELLATOR_EV; +import static gregtech.api.enums.MetaTileEntityIDs.MONSTER_REPELLATOR_HV; +import static gregtech.api.enums.MetaTileEntityIDs.MONSTER_REPELLATOR_IV; +import static gregtech.api.enums.MetaTileEntityIDs.MONSTER_REPELLATOR_LV; +import static gregtech.api.enums.MetaTileEntityIDs.MONSTER_REPELLATOR_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.MONSTER_REPELLATOR_MV; +import static gregtech.api.enums.MetaTileEntityIDs.MONSTER_REPELLATOR_UV; +import static gregtech.api.enums.MetaTileEntityIDs.MONSTER_REPELLATOR_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.MUFFLER_HATCH_EV; +import static gregtech.api.enums.MetaTileEntityIDs.MUFFLER_HATCH_HV; +import static gregtech.api.enums.MetaTileEntityIDs.MUFFLER_HATCH_IV; +import static gregtech.api.enums.MetaTileEntityIDs.MUFFLER_HATCH_LV; +import static gregtech.api.enums.MetaTileEntityIDs.MUFFLER_HATCH_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.MUFFLER_HATCH_MV; +import static gregtech.api.enums.MetaTileEntityIDs.MUFFLER_HATCH_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.MUFFLER_HATCH_UV; +import static gregtech.api.enums.MetaTileEntityIDs.MUFFLER_HATCH_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.MULTIBLOCK_PUMP_INFINITE_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.MULTIBLOCK_PUMP_MKI_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.MULTILOCK_PUMP_MKIII_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.MULTILOCK_PUMP_MKII_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.MULTILOCK_PUMP_MKIV_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.MULTI_SMELTER_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.NANO_FORGE_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.NAQUADAH_REACTOR_EV; +import static gregtech.api.enums.MetaTileEntityIDs.NAQUADAH_REACTOR_IV; +import static gregtech.api.enums.MetaTileEntityIDs.NAQUADAH_REACTOR_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.NAQUADAH_REACTOR_UV; +import static gregtech.api.enums.MetaTileEntityIDs.NAQUADAH_REACTOR_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.OIL_CRACKER_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.ORE_DRILL_MKIII_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.ORE_DRILL_MKII_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.ORE_DRILL_MKIV_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.ORE_DRILL_MKI_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_BUS_EV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_BUS_HV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_BUS_IV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_BUS_LV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_BUS_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_BUS_ME; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_BUS_MV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_BUS_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_BUS_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_BUS_UV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_BUS_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_HATCH_EV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_HATCH_HV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_HATCH_IV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_HATCH_LV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_HATCH_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_HATCH_ME; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_HATCH_MV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_HATCH_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_HATCH_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_HATCH_UV; +import static gregtech.api.enums.MetaTileEntityIDs.OUTPUT_HATCH_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.PACKAGER_EV; +import static gregtech.api.enums.MetaTileEntityIDs.PACKAGER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.PACKAGER_IV; +import static gregtech.api.enums.MetaTileEntityIDs.PACKAGER_LV; +import static gregtech.api.enums.MetaTileEntityIDs.PACKAGER_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.PACKAGER_MV; +import static gregtech.api.enums.MetaTileEntityIDs.PACKAGER_UV; +import static gregtech.api.enums.MetaTileEntityIDs.PACKAGER_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.PCB_FACTORY_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.PLASMA_GENERATOR_IV; +import static gregtech.api.enums.MetaTileEntityIDs.PLASMA_GENERATOR_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.PLASMA_GENERATOR_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.PROCESSING_ARRAY_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.PUMP_EV; +import static gregtech.api.enums.MetaTileEntityIDs.PUMP_HV; +import static gregtech.api.enums.MetaTileEntityIDs.PUMP_IV; +import static gregtech.api.enums.MetaTileEntityIDs.PUMP_LV; +import static gregtech.api.enums.MetaTileEntityIDs.PUMP_MV; +import static gregtech.api.enums.MetaTileEntityIDs.PYROLYSE_OVEN_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_EV; +import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_IV; +import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_MAX; +import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_UEV; +import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_UIV; +import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_UMV; +import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_UV; +import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_UXV; +import static gregtech.api.enums.MetaTileEntityIDs.QUADRUPLE_INPUT_HATCHES_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.QUANTUM_CHEST_EV; +import static gregtech.api.enums.MetaTileEntityIDs.QUANTUM_CHEST_HV; +import static gregtech.api.enums.MetaTileEntityIDs.QUANTUM_CHEST_IV; +import static gregtech.api.enums.MetaTileEntityIDs.QUANTUM_CHEST_LV; +import static gregtech.api.enums.MetaTileEntityIDs.QUANTUM_CHEST_MV; +import static gregtech.api.enums.MetaTileEntityIDs.QUANTUM_TANK_EV; +import static gregtech.api.enums.MetaTileEntityIDs.QUANTUM_TANK_HV; +import static gregtech.api.enums.MetaTileEntityIDs.QUANTUM_TANK_IV; +import static gregtech.api.enums.MetaTileEntityIDs.QUANTUM_TANK_LV; +import static gregtech.api.enums.MetaTileEntityIDs.QUANTUM_TANK_MV; +import static gregtech.api.enums.MetaTileEntityIDs.RECIPE_FILTER_EV; +import static gregtech.api.enums.MetaTileEntityIDs.RECIPE_FILTER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.RECIPE_FILTER_IV; +import static gregtech.api.enums.MetaTileEntityIDs.RECIPE_FILTER_LV; +import static gregtech.api.enums.MetaTileEntityIDs.RECIPE_FILTER_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.RECIPE_FILTER_MV; +import static gregtech.api.enums.MetaTileEntityIDs.RECIPE_FILTER_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.RECIPE_FILTER_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.RECIPE_FILTER_UV; +import static gregtech.api.enums.MetaTileEntityIDs.RECIPE_FILTER_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.REPLICATOR_EV; +import static gregtech.api.enums.MetaTileEntityIDs.REPLICATOR_HV; +import static gregtech.api.enums.MetaTileEntityIDs.REPLICATOR_IV; +import static gregtech.api.enums.MetaTileEntityIDs.REPLICATOR_LV; +import static gregtech.api.enums.MetaTileEntityIDs.REPLICATOR_MV; +import static gregtech.api.enums.MetaTileEntityIDs.ROCK_BREAKER_EV; +import static gregtech.api.enums.MetaTileEntityIDs.ROCK_BREAKER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.ROCK_BREAKER_IV; +import static gregtech.api.enums.MetaTileEntityIDs.ROCK_BREAKER_LV; +import static gregtech.api.enums.MetaTileEntityIDs.ROCK_BREAKER_MV; +import static gregtech.api.enums.MetaTileEntityIDs.SCANNER_EV; +import static gregtech.api.enums.MetaTileEntityIDs.SCANNER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.SCANNER_IV; +import static gregtech.api.enums.MetaTileEntityIDs.SCANNER_LV; +import static gregtech.api.enums.MetaTileEntityIDs.SCANNER_MV; +import static gregtech.api.enums.MetaTileEntityIDs.SIMPLE_SOLAR_BOILER; +import static gregtech.api.enums.MetaTileEntityIDs.SMALL_COAL_BOILER; +import static gregtech.api.enums.MetaTileEntityIDs.STEAM_ALLOY_SMELTER; +import static gregtech.api.enums.MetaTileEntityIDs.STEAM_COMPRESSOR; +import static gregtech.api.enums.MetaTileEntityIDs.STEAM_EXTRACTOR; +import static gregtech.api.enums.MetaTileEntityIDs.STEAM_FORGE_HAMMER; +import static gregtech.api.enums.MetaTileEntityIDs.STEAM_FURNACE; +import static gregtech.api.enums.MetaTileEntityIDs.STEAM_MACERATOR; +import static gregtech.api.enums.MetaTileEntityIDs.STEAM_TURBINE_HV; +import static gregtech.api.enums.MetaTileEntityIDs.STEAM_TURBINE_LV; +import static gregtech.api.enums.MetaTileEntityIDs.STEAM_TURBINE_MV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_BUFFER_EV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_BUFFER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_BUFFER_IV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_BUFFER_LV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_BUFFER_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_BUFFER_MV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_BUFFER_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_BUFFER_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_BUFFER_UV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_BUFFER_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_CHEST_EV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_CHEST_HV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_CHEST_IV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_CHEST_LV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_CHEST_MV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_TANK_EV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_TANK_HV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_TANK_IV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_TANK_LV; +import static gregtech.api.enums.MetaTileEntityIDs.SUPER_TANK_MV; +import static gregtech.api.enums.MetaTileEntityIDs.TELEPORTER; +import static gregtech.api.enums.MetaTileEntityIDs.TRANSCENDENT_PLASMA_MIXER_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.TYPE_FILTER_EV; +import static gregtech.api.enums.MetaTileEntityIDs.TYPE_FILTER_HV; +import static gregtech.api.enums.MetaTileEntityIDs.TYPE_FILTER_IV; +import static gregtech.api.enums.MetaTileEntityIDs.TYPE_FILTER_LV; +import static gregtech.api.enums.MetaTileEntityIDs.TYPE_FILTER_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.TYPE_FILTER_MV; +import static gregtech.api.enums.MetaTileEntityIDs.TYPE_FILTER_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.TYPE_FILTER_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.TYPE_FILTER_UV; +import static gregtech.api.enums.MetaTileEntityIDs.TYPE_FILTER_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.VACUUM_FREEZER_CONTROLLER; +import static gregtech.api.enums.MetaTileEntityIDs.VOLTAGE_REGULATOR_EV; +import static gregtech.api.enums.MetaTileEntityIDs.VOLTAGE_REGULATOR_HV; +import static gregtech.api.enums.MetaTileEntityIDs.VOLTAGE_REGULATOR_IV; +import static gregtech.api.enums.MetaTileEntityIDs.VOLTAGE_REGULATOR_LV; +import static gregtech.api.enums.MetaTileEntityIDs.VOLTAGE_REGULATOR_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.VOLTAGE_REGULATOR_MV; +import static gregtech.api.enums.MetaTileEntityIDs.VOLTAGE_REGULATOR_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.VOLTAGE_REGULATOR_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.VOLTAGE_REGULATOR_UV; +import static gregtech.api.enums.MetaTileEntityIDs.VOLTAGE_REGULATOR_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_EV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_HV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_IV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_LV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_MAX; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_MV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_UEV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_UIV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_UMV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_UV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_UXV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_DYNAMO_ENERGY_HATCH_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_EV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_HV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_IV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_LV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_LuV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_MAX; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_MV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_UEV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_UHV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_UIV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_UMV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_UV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_UXV; +import static gregtech.api.enums.MetaTileEntityIDs.WIRELESS_HATCH_ENERGY_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.transformer_EV_HV; +import static gregtech.api.enums.MetaTileEntityIDs.transformer_HV_MV; +import static gregtech.api.enums.MetaTileEntityIDs.transformer_IV_EV; +import static gregtech.api.enums.MetaTileEntityIDs.transformer_LV_ULV; +import static gregtech.api.enums.MetaTileEntityIDs.transformer_LuV_IV; +import static gregtech.api.enums.MetaTileEntityIDs.transformer_MV_LV; +import static gregtech.api.enums.MetaTileEntityIDs.transformer_UHV_UV; +import static gregtech.api.enums.MetaTileEntityIDs.transformer_UV_ZPM; +import static gregtech.api.enums.MetaTileEntityIDs.transformer_ZPM_LuV; +import static gregtech.api.enums.Mods.Forestry; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; + +import net.minecraft.util.EnumChatFormatting; + +import gregtech.GT_Mod; +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Cable; +import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Fluid; +import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Frame; +import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Item; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicBatteryBuffer; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicHull; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_DataAccess; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Dynamo; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_InputBus; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Maintenance; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Muffler; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_MultiInput; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_OutputBus; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_QuadrupleHumongous; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Transformer; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Wireless_Dynamo; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Wireless_Hatch; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.common.tileentities.automation.GT_MetaTileEntity_ChestBuffer; +import gregtech.common.tileentities.automation.GT_MetaTileEntity_Filter; +import gregtech.common.tileentities.automation.GT_MetaTileEntity_ItemDistributor; +import gregtech.common.tileentities.automation.GT_MetaTileEntity_RecipeFilter; +import gregtech.common.tileentities.automation.GT_MetaTileEntity_Regulator; +import gregtech.common.tileentities.automation.GT_MetaTileEntity_SuperBuffer; +import gregtech.common.tileentities.automation.GT_MetaTileEntity_TypeFilter; +import gregtech.common.tileentities.boilers.GT_MetaTileEntity_Boiler_Bronze; +import gregtech.common.tileentities.boilers.GT_MetaTileEntity_Boiler_Lava; +import gregtech.common.tileentities.boilers.GT_MetaTileEntity_Boiler_Solar; +import gregtech.common.tileentities.boilers.GT_MetaTileEntity_Boiler_Solar_Steel; +import gregtech.common.tileentities.boilers.GT_MetaTileEntity_Boiler_Steel; +import gregtech.common.tileentities.debug.GT_MetaTileEntity_AdvDebugStructureWriter; +import gregtech.common.tileentities.generators.GT_MetaTileEntity_DieselGenerator; +import gregtech.common.tileentities.generators.GT_MetaTileEntity_GasTurbine; +import gregtech.common.tileentities.generators.GT_MetaTileEntity_LightningRod; +import gregtech.common.tileentities.generators.GT_MetaTileEntity_MagicEnergyConverter; +import gregtech.common.tileentities.generators.GT_MetaTileEntity_MagicalEnergyAbsorber; +import gregtech.common.tileentities.generators.GT_MetaTileEntity_NaquadahReactor; +import gregtech.common.tileentities.generators.GT_MetaTileEntity_PlasmaGenerator; +import gregtech.common.tileentities.generators.GT_MetaTileEntity_SteamTurbine; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_BasicHull_Bronze; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_BasicHull_BronzeBricks; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_BasicHull_Steel; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_BasicHull_SteelBricks; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_Hatch_CraftingInput_ME; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_Hatch_CraftingInput_Slave; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_Hatch_InputBus_ME; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_Hatch_Input_ME; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_Hatch_OutputBus_ME; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_Hatch_Output_ME; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_AdvSeismicProspector; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_Boxinator; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_Charger; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_IndustrialApiary; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_Massfabricator; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_MicrowaveEnergyTransmitter; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_Miner; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_MonsterRepellent; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_PotionBrewer; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_Pump; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_Replicator; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_RockBreaker; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_Scanner; +import gregtech.common.tileentities.machines.basic.GT_MetaTileEntity_Teleporter; +import gregtech.common.tileentities.machines.long_distance.GT_MetaTileEntity_LongDistancePipelineFluid; +import gregtech.common.tileentities.machines.long_distance.GT_MetaTileEntity_LongDistancePipelineItem; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_AssemblyLine; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_BrickedBlastFurnace; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_Charcoal_Pit; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_Cleanroom; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_ConcreteBackfiller1; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_ConcreteBackfiller2; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_DieselEngine; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_DistillationTower; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_ElectricBlastFurnace; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_ExtremeDieselEngine; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_FusionComputer1; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_FusionComputer2; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_FusionComputer3; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_HeatExchanger; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_ImplosionCompressor; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_IntegratedOreFactory; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeBoiler_Bronze; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeBoiler_Steel; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeBoiler_Titanium; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeBoiler_TungstenSteel; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeChemicalReactor; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine_Gas; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine_GasAdvanced; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine_HPSteam; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine_Plasma; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_LargeTurbine_Steam; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_MultiFurnace; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_NanoForge; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_OilCracker; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_OilDrill1; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_OilDrill2; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_OilDrill3; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_OilDrill4; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_OilDrillInfinite; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_OreDrillingPlant1; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_OreDrillingPlant2; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_OreDrillingPlant3; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_OreDrillingPlant4; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_PCBFactory; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_PlasmaForge; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_ProcessingArray; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_PyrolyseOven; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_TranscendentPlasmaMixer; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_VacuumFreezer; +import gregtech.common.tileentities.machines.multi.drone.GT_MetaTileEntity_DroneCentre; +import gregtech.common.tileentities.machines.multi.drone.GT_MetaTileEntity_Hatch_DroneDownLink; +import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_AlloySmelter_Bronze; +import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_AlloySmelter_Steel; +import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Compressor_Bronze; +import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Compressor_Steel; +import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Extractor_Bronze; +import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Extractor_Steel; +import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_ForgeHammer_Bronze; +import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_ForgeHammer_Steel; +import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Furnace_Bronze; +import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Furnace_Steel; +import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Macerator_Bronze; +import gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Macerator_Steel; +import gregtech.common.tileentities.storage.GT_MetaTileEntity_Locker; +import gregtech.common.tileentities.storage.GT_MetaTileEntity_QuantumChest; +import gregtech.common.tileentities.storage.GT_MetaTileEntity_QuantumTank; +import gregtech.common.tileentities.storage.GT_MetaTileEntity_SuperChest; +import gregtech.common.tileentities.storage.GT_MetaTileEntity_SuperTank; + +// Free IDs left for machines in GT as of 29th of July 2022 - Colen. Please try use them up in order. +// 358 +// 359 +// 366 +// 367 +// 368 +// 369 +// 370 +// 376 +// 377 +// 378 +// 379 +// 386 +// 387 +// 388 +// 389 +// 390 +// 396 +// 397 +// 398 +// 399 +// 410 +// 419 +// 426 +// 427 +// 428 +// 429 +// 430 +// 436 +// 437 +// 438 +// 439 +// 446 +// 447 +// 448 +// 449 +// 450 +// 456 +// 457 +// 458 +// 459 +// 466 +// 467 +// 468 +// 469 +// 470 +// 476 +// 477 +// 478 +// 479 +// 486 +// 487 +// 488 +// 489 +// 496 +// 497 +// 498 +// 499 +// 506 +// 507 +// 508 +// 509 +// 518 +// 519 +// 526 +// 530 +// 537 +// 538 +// 539 +// 546 +// 547 +// 548 +// 549 +// 550 +// 556 +// 557 +// 558 +// 559 +// 566 +// 567 +// 576 +// 577 +// 578 +// 579 +// 586 +// 587 +// 588 +// 589 +// 590 +// 596 +// 597 +// 598 +// 599 +// 607 +// 608 +// 609 +// 610 +// 616 +// 617 +// 618 +// 619 +// 626 +// 627 +// 628 +// 629 +// 630 +// 636 +// 637 +// 639 +// 646 +// 647 +// 648 +// 649 +// 650 +// 656 +// 657 +// 658 +// 659 +// 666 +// 667 +// 668 +// 669 +// 670 +// 676 +// 677 +// 678 +// 682 +// 683 +// 684 +// 686 +// 687 +// 688 +// 689 +// 702 +// 703 +// 704 +// 705 +// 706 +// 707 +// 708 +// 709 +// 714 +// 715 +// 716 +// 717 +// 718 +// 719 +// 721 +// 722 +// 723 +// 724 +// 725 +// 726 +// 727 +// 728 +// 729 +// 730 +// 731 +// 732 +// 733 +// 734 +// 735 +// 736 +// 737 +// 738 +// 739 +// 741 +// 742 +// 743 +// 744 +// 745 +// 746 +// 747 +// 748 +// 749 + +// TODO Some GT MetaTileEntity registrations are done in load/GT_Loader_MetaTileEntities_Recipes.java due to joint +// registration+recipe methods, they should be split and brought here to register all in preload. + +public class GT_Loader_MetaTileEntities implements Runnable { // TODO CHECK CIRCUIT RECIPES AND USAGES + + private static final String aTextWire1 = "wire."; + private static final String aTextCable1 = "cable."; + private static final String aTextWire2 = " Wire"; + private static final String aTextCable2 = " Cable"; + public static final String imagination = EnumChatFormatting.RESET + "You just need " + + EnumChatFormatting.DARK_PURPLE + + "I" + + EnumChatFormatting.LIGHT_PURPLE + + "m" + + EnumChatFormatting.DARK_RED + + "a" + + EnumChatFormatting.RED + + "g" + + EnumChatFormatting.YELLOW + + "i" + + EnumChatFormatting.GREEN + + "n" + + EnumChatFormatting.AQUA + + "a" + + EnumChatFormatting.DARK_AQUA + + "t" + + EnumChatFormatting.BLUE + + "i" + + EnumChatFormatting.DARK_BLUE + + "o" + + EnumChatFormatting.DARK_PURPLE + + "n" + + EnumChatFormatting.RESET + + " to use this."; + + 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)); + + 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)); + ItemList.Machine_Multi_DroneCentre.set( + new GT_MetaTileEntity_DroneCentre(Drone_Centre.ID, "multimachine_DroneCentre", "Drone Centre") + .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 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.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( + 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( + HULL_STEEL.ID, + "hull.steel", + "Steel Hull", + 0, + "For improved Steam Machines").getStackForm(1L)); + ItemList.Hull_HP_Bricks.set( + new GT_MetaTileEntity_BasicHull_SteelBricks( + 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(HULL_ULV.ID, "hull.tier.00", "ULV Machine Hull", 0, imagination) + .getStackForm(1L)); + ItemList.Hull_LV.set( + 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(HULL_MV.ID, "hull.tier.02", "MV Machine Hull", 2, imagination) + .getStackForm(1L)); + ItemList.Hull_HV.set( + 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(HULL_EV.ID, "hull.tier.04", "EV Machine Hull", 4, imagination) + .getStackForm(1L)); + ItemList.Hull_IV.set( + 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(HULL_LuV.ID, "hull.tier.06", "LuV Machine Hull", 6, imagination) + .getStackForm(1L)); + ItemList.Hull_ZPM.set( + 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(HULL_UV.ID, "hull.tier.08", "UV Machine Hull", 8, imagination) + .getStackForm(1L)); + ItemList.Hull_MAX.set( + 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( + 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( + 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( + 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( + 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( + 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( + 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( + 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( + 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( + 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(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(DYNAMO_HATCH_HV.ID, "hatch.dynamo.tier.03", "HV Dynamo Hatch", 3) + .getStackForm(1L)); + ItemList.Hatch_Dynamo_EV.set( + new GT_MetaTileEntity_Hatch_Dynamo(DYNAMO_HATCH_EV.ID, "hatch.dynamo.tier.04", "EV Dynamo Hatch", 4) + .getStackForm(1L)); + ItemList.Hatch_Dynamo_IV.set( + new GT_MetaTileEntity_Hatch_Dynamo(DYNAMO_HATCH_IV.ID, "hatch.dynamo.tier.05", "IV Dynamo Hatch", 5) + .getStackForm(1L)); + ItemList.Hatch_Dynamo_LuV.set( + new GT_MetaTileEntity_Hatch_Dynamo(DYNAMO_HATCH_LuV.ID, "hatch.dynamo.tier.06", "LuV Dynamo Hatch", 6) + .getStackForm(1L)); + ItemList.Hatch_Dynamo_ZPM.set( + new GT_MetaTileEntity_Hatch_Dynamo(DYNAMO_HATCH_ZPM.ID, "hatch.dynamo.tier.07", "ZPM Dynamo Hatch", 7) + .getStackForm(1L)); + ItemList.Hatch_Dynamo_UV.set( + new GT_MetaTileEntity_Hatch_Dynamo(DYNAMO_HATCH_UV.ID, "hatch.dynamo.tier.08", "UV Dynamo Hatch", 8) + .getStackForm(1L)); + ItemList.Hatch_Dynamo_MAX.set( + new GT_MetaTileEntity_Hatch_Dynamo(DYNAMO_HATCH_UHV.ID, "hatch.dynamo.tier.09", "UHV Dynamo Hatch", 9) + .getStackForm(1L)); + } + + private static void registerEnergyHatch() { + ItemList.Hatch_Energy_ULV.set( + new GT_MetaTileEntity_Hatch_Energy(ENERGY_HATCH_ULV.ID, "hatch.energy.tier.00", "ULV Energy Hatch", 0) + .getStackForm(1L)); + ItemList.Hatch_Energy_LV.set( + new GT_MetaTileEntity_Hatch_Energy(ENERGY_HATCH_LV.ID, "hatch.energy.tier.01", "LV Energy Hatch", 1) + .getStackForm(1L)); + ItemList.Hatch_Energy_MV.set( + new GT_MetaTileEntity_Hatch_Energy(ENERGY_HATCH_MV.ID, "hatch.energy.tier.02", "MV Energy Hatch", 2) + .getStackForm(1L)); + ItemList.Hatch_Energy_HV.set( + new GT_MetaTileEntity_Hatch_Energy(ENERGY_HATCH_HV.ID, "hatch.energy.tier.03", "HV Energy Hatch", 3) + .getStackForm(1L)); + ItemList.Hatch_Energy_EV.set( + new GT_MetaTileEntity_Hatch_Energy(ENERGY_HATCH_EV.ID, "hatch.energy.tier.04", "EV Energy Hatch", 4) + .getStackForm(1L)); + ItemList.Hatch_Energy_IV.set( + new GT_MetaTileEntity_Hatch_Energy(ENERGY_HATCH_IV.ID, "hatch.energy.tier.05", "IV Energy Hatch", 5) + .getStackForm(1L)); + ItemList.Hatch_Energy_LuV.set( + new GT_MetaTileEntity_Hatch_Energy(ENERGY_HATCH_LuV.ID, "hatch.energy.tier.06", "LuV Energy Hatch", 6) + .getStackForm(1L)); + ItemList.Hatch_Energy_ZPM.set( + new GT_MetaTileEntity_Hatch_Energy(ENERGY_HATCH_ZPM.ID, "hatch.energy.tier.07", "ZPM Energy Hatch", 7) + .getStackForm(1L)); + ItemList.Hatch_Energy_UV.set( + new GT_MetaTileEntity_Hatch_Energy(ENERGY_HATCH_UV.ID, "hatch.energy.tier.08", "UV Energy Hatch", 8) + .getStackForm(1L)); + ItemList.Hatch_Energy_MAX.set( + new GT_MetaTileEntity_Hatch_Energy(ENERGY_HATCH_UHV.ID, "hatch.energy.tier.09", "UHV Energy Hatch", 9) + .getStackForm(1L)); + } + + private static void registerInputHatch() { + ItemList.Hatch_Input_ULV.set( + new GT_MetaTileEntity_Hatch_Input(INPUT_HATCH_ULV.ID, "hatch.input.tier.00", "Input Hatch (ULV)", 0) + .getStackForm(1L)); + ItemList.Hatch_Input_LV.set( + new GT_MetaTileEntity_Hatch_Input(INPUT_HATCH_LV.ID, "hatch.input.tier.01", "Input Hatch (LV)", 1) + .getStackForm(1L)); + ItemList.Hatch_Input_MV.set( + new GT_MetaTileEntity_Hatch_Input(INPUT_HATCH_MV.ID, "hatch.input.tier.02", "Input Hatch (MV)", 2) + .getStackForm(1L)); + ItemList.Hatch_Input_HV.set( + new GT_MetaTileEntity_Hatch_Input(INPUT_HATCH_HV.ID, "hatch.input.tier.03", "Input Hatch (HV)", 3) + .getStackForm(1L)); + ItemList.Hatch_Input_EV.set( + new GT_MetaTileEntity_Hatch_Input(INPUT_HATCH_EV.ID, "hatch.input.tier.04", "Input Hatch (EV)", 4) + .getStackForm(1L)); + ItemList.Hatch_Input_IV.set( + new GT_MetaTileEntity_Hatch_Input(INPUT_HATCH_IV.ID, "hatch.input.tier.05", "Input Hatch (IV)", 5) + .getStackForm(1L)); + ItemList.Hatch_Input_LuV.set( + new GT_MetaTileEntity_Hatch_Input(INPUT_HATCH_LuV.ID, "hatch.input.tier.06", "Input Hatch (LuV)", 6) + .getStackForm(1L)); + ItemList.Hatch_Input_ZPM.set( + new GT_MetaTileEntity_Hatch_Input(INPUT_HATCH_ZPM.ID, "hatch.input.tier.07", "Input Hatch (ZPM)", 7) + .getStackForm(1L)); + ItemList.Hatch_Input_UV.set( + new GT_MetaTileEntity_Hatch_Input(INPUT_HATCH_UV.ID, "hatch.input.tier.08", "Input Hatch (UV)", 8) + .getStackForm(1L)); + ItemList.Hatch_Input_MAX.set( + new GT_MetaTileEntity_Hatch_Input(INPUT_HATCH_UHV.ID, "hatch.input.tier.09", "Input Hatch (UHV)", 9) + .getStackForm(1L)); + } + + private static void registerQuadrupleInputHatch() { + ItemList.Hatch_Input_Multi_2x2_EV.set( + new GT_MetaTileEntity_Hatch_MultiInput( + QUADRUPLE_INPUT_HATCHES_EV.ID, + 4, + "hatch.multi.input.tier.01", + "Quadruple Input Hatch (EV)", + 4).getStackForm(1L)); + ItemList.Hatch_Input_Multi_2x2_IV.set( + new GT_MetaTileEntity_Hatch_MultiInput( + QUADRUPLE_INPUT_HATCHES_IV.ID, + 4, + "hatch.multi.input.tier.02", + "Quadruple Input Hatch (IV)", + 5).getStackForm(1L)); + ItemList.Hatch_Input_Multi_2x2_LuV.set( + new GT_MetaTileEntity_Hatch_MultiInput( + QUADRUPLE_INPUT_HATCHES_LuV.ID, + 4, + "hatch.multi.input.tier.03", + "Quadruple Input Hatch (LuV)", + 6).getStackForm(1L)); + ItemList.Hatch_Input_Multi_2x2_ZPM.set( + new GT_MetaTileEntity_Hatch_MultiInput( + QUADRUPLE_INPUT_HATCHES_ZPM.ID, + 4, + "hatch.multi.input.tier.04", + "Quadruple Input Hatch (ZPM)", + 7).getStackForm(1L)); + ItemList.Hatch_Input_Multi_2x2_UV.set( + new GT_MetaTileEntity_Hatch_MultiInput( + QUADRUPLE_INPUT_HATCHES_UV.ID, + 4, + "hatch.multi.input.tier.05", + "Quadruple Input Hatch (UV)", + 8).getStackForm(1L)); + ItemList.Hatch_Input_Multi_2x2_UHV.set( + new GT_MetaTileEntity_Hatch_MultiInput( + QUADRUPLE_INPUT_HATCHES_UHV.ID, + 4, + "hatch.multi.input.tier.06", + "Quadruple Input Hatch (UHV)", + 9).getStackForm(1L)); + ItemList.Hatch_Input_Multi_2x2_UEV.set( + new GT_MetaTileEntity_Hatch_MultiInput( + QUADRUPLE_INPUT_HATCHES_UEV.ID, + 4, + "hatch.multi.input.tier.07", + "Quadruple Input Hatch (UEV)", + 10).getStackForm(1L)); + ItemList.Hatch_Input_Multi_2x2_UIV.set( + new GT_MetaTileEntity_Hatch_MultiInput( + QUADRUPLE_INPUT_HATCHES_UIV.ID, + 4, + "hatch.multi.input.tier.08", + "Quadruple Input Hatch (UIV)", + 11).getStackForm(1L)); + ItemList.Hatch_Input_Multi_2x2_UMV.set( + new GT_MetaTileEntity_Hatch_MultiInput( + QUADRUPLE_INPUT_HATCHES_UMV.ID, + 4, + "hatch.multi.input.tier.09", + "Quadruple Input Hatch (UMV)", + 12).getStackForm(1L)); + ItemList.Hatch_Input_Multi_2x2_UXV.set( + new GT_MetaTileEntity_Hatch_MultiInput( + QUADRUPLE_INPUT_HATCHES_UXV.ID, + 4, + "hatch.multi.input.tier.10", + "Quadruple Input Hatch (UXV)", + 13).getStackForm(1L)); + + ItemList.Hatch_Input_Multi_2x2_Humongous.set( + new GT_MetaTileEntity_Hatch_QuadrupleHumongous( + QUADRUPLE_INPUT_HATCHES_MAX.ID, + 4, + "hatch.multi.input.tier.11", + "Humongous Quadruple Input Hatch").getStackForm(1L)); + } + + private static void registerOutputHatch() { + ItemList.Hatch_Output_ULV.set( + new GT_MetaTileEntity_Hatch_Output(OUTPUT_HATCH_ULV.ID, "hatch.output.tier.00", "Output Hatch (ULV)", 0) + .getStackForm(1L)); + ItemList.Hatch_Output_LV.set( + new GT_MetaTileEntity_Hatch_Output(OUTPUT_HATCH_LV.ID, "hatch.output.tier.01", "Output Hatch (LV)", 1) + .getStackForm(1L)); + ItemList.Hatch_Output_MV.set( + new GT_MetaTileEntity_Hatch_Output(OUTPUT_HATCH_MV.ID, "hatch.output.tier.02", "Output Hatch (MV)", 2) + .getStackForm(1L)); + ItemList.Hatch_Output_HV.set( + new GT_MetaTileEntity_Hatch_Output(OUTPUT_HATCH_HV.ID, "hatch.output.tier.03", "Output Hatch (HV)", 3) + .getStackForm(1L)); + ItemList.Hatch_Output_EV.set( + new GT_MetaTileEntity_Hatch_Output(OUTPUT_HATCH_EV.ID, "hatch.output.tier.04", "Output Hatch (EV)", 4) + .getStackForm(1L)); + ItemList.Hatch_Output_IV.set( + new GT_MetaTileEntity_Hatch_Output(OUTPUT_HATCH_IV.ID, "hatch.output.tier.05", "Output Hatch (IV)", 5) + .getStackForm(1L)); + ItemList.Hatch_Output_LuV.set( + new GT_MetaTileEntity_Hatch_Output(OUTPUT_HATCH_LuV.ID, "hatch.output.tier.06", "Output Hatch (LuV)", 6) + .getStackForm(1L)); + ItemList.Hatch_Output_ZPM.set( + new GT_MetaTileEntity_Hatch_Output(OUTPUT_HATCH_ZPM.ID, "hatch.output.tier.07", "Output Hatch (ZPM)", 7) + .getStackForm(1L)); + ItemList.Hatch_Output_UV.set( + new GT_MetaTileEntity_Hatch_Output(OUTPUT_HATCH_UV.ID, "hatch.output.tier.08", "Output Hatch (UV)", 8) + .getStackForm(1L)); + ItemList.Hatch_Output_MAX.set( + new GT_MetaTileEntity_Hatch_Output(OUTPUT_HATCH_UHV.ID, "hatch.output.tier.09", "Output Hatch (UHV)", 9) + .getStackForm(1L)); + } + + private static void registerQuantumTank() { + ItemList.Quantum_Tank_LV.set( + new GT_MetaTileEntity_QuantumTank(QUANTUM_TANK_LV.ID, "quantum.tank.tier.06", "Quantum Tank I", 6) + .getStackForm(1L)); + ItemList.Quantum_Tank_MV.set( + new GT_MetaTileEntity_QuantumTank(QUANTUM_TANK_MV.ID, "quantum.tank.tier.07", "Quantum Tank II", 7) + .getStackForm(1L)); + ItemList.Quantum_Tank_HV.set( + new GT_MetaTileEntity_QuantumTank(QUANTUM_TANK_HV.ID, "quantum.tank.tier.08", "Quantum Tank III", 8) + .getStackForm(1L)); + ItemList.Quantum_Tank_EV.set( + new GT_MetaTileEntity_QuantumTank(QUANTUM_TANK_EV.ID, "quantum.tank.tier.09", "Quantum Tank IV", 9) + .getStackForm(1L)); + ItemList.Quantum_Tank_IV.set( + new GT_MetaTileEntity_QuantumTank(QUANTUM_TANK_IV.ID, "quantum.tank.tier.10", "Quantum Tank V", 10) + .getStackForm(1L)); + } + + private static void registerQuantumChest() { + ItemList.Quantum_Chest_LV.set( + new GT_MetaTileEntity_QuantumChest(QUANTUM_CHEST_LV.ID, "quantum.chest.tier.06", "Quantum Chest I", 6) + .getStackForm(1L)); + ItemList.Quantum_Chest_MV.set( + new GT_MetaTileEntity_QuantumChest(QUANTUM_CHEST_MV.ID, "quantum.chest.tier.07", "Quantum Chest II", 7) + .getStackForm(1L)); + ItemList.Quantum_Chest_HV.set( + new GT_MetaTileEntity_QuantumChest(QUANTUM_CHEST_HV.ID, "quantum.chest.tier.08", "Quantum Chest III", 8) + .getStackForm(1L)); + ItemList.Quantum_Chest_EV.set( + new GT_MetaTileEntity_QuantumChest(QUANTUM_CHEST_EV.ID, "quantum.chest.tier.09", "Quantum Chest IV", 9) + .getStackForm(1L)); + ItemList.Quantum_Chest_IV.set( + new GT_MetaTileEntity_QuantumChest(QUANTUM_CHEST_IV.ID, "quantum.chest.tier.10", "Quantum Chest V", 10) + .getStackForm(1L)); + } + + private static void registerSuperTank() { + ItemList.Super_Tank_LV.set( + new GT_MetaTileEntity_SuperTank(SUPER_TANK_LV.ID, "super.tank.tier.01", "Super Tank I", 1) + .getStackForm(1L)); + ItemList.Super_Tank_MV.set( + new GT_MetaTileEntity_SuperTank(SUPER_TANK_MV.ID, "super.tank.tier.02", "Super Tank II", 2) + .getStackForm(1L)); + ItemList.Super_Tank_HV.set( + new GT_MetaTileEntity_SuperTank(SUPER_TANK_HV.ID, "super.tank.tier.03", "Super Tank III", 3) + .getStackForm(1L)); + ItemList.Super_Tank_EV.set( + new GT_MetaTileEntity_SuperTank(SUPER_TANK_EV.ID, "super.tank.tier.04", "Super Tank IV", 4) + .getStackForm(1L)); + ItemList.Super_Tank_IV.set( + new GT_MetaTileEntity_SuperTank(SUPER_TANK_IV.ID, "super.tank.tier.05", "Super Tank V", 5) + .getStackForm(1L)); + } + + private static void registerSuperChest() { + ItemList.Super_Chest_LV.set( + new GT_MetaTileEntity_SuperChest(SUPER_CHEST_LV.ID, "super.chest.tier.01", "Super Chest I", 1) + .getStackForm(1L)); + ItemList.Super_Chest_MV.set( + new GT_MetaTileEntity_SuperChest(SUPER_CHEST_MV.ID, "super.chest.tier.02", "Super Chest II", 2) + .getStackForm(1L)); + ItemList.Super_Chest_HV.set( + new GT_MetaTileEntity_SuperChest(SUPER_CHEST_HV.ID, "super.chest.tier.03", "Super Chest III", 3) + .getStackForm(1L)); + ItemList.Super_Chest_EV.set( + new GT_MetaTileEntity_SuperChest(SUPER_CHEST_EV.ID, "super.chest.tier.04", "Super Chest IV", 4) + .getStackForm(1L)); + ItemList.Super_Chest_IV.set( + new GT_MetaTileEntity_SuperChest(SUPER_CHEST_IV.ID, "super.chest.tier.05", "Super Chest V", 5) + .getStackForm(1L)); + } + + private static void registerLongDistancePipe() { + ItemList.Long_Distance_Pipeline_Fluid.set( + new GT_MetaTileEntity_LongDistancePipelineFluid( + LONG_DISTANCE_PIPELINE_FLUID.ID, + "long.distance.pipeline.fluid", + "Long Distance Fluid Pipeline", + 1).getStackForm(1L)); + ItemList.Long_Distance_Pipeline_Item.set( + new GT_MetaTileEntity_LongDistancePipelineItem( + LONG_DISTANCE_PIPELINE_ITEM.ID, + "long.distance.pipeline.item", + "Long Distance Item Pipeline", + 1).getStackForm(1L)); + } + + private static void registerAE2Hatches() { + ItemList.Hatch_Output_Bus_ME.set( + new GT_MetaTileEntity_Hatch_OutputBus_ME(OUTPUT_BUS_ME.ID, "hatch.output_bus.me", "Output Bus (ME)") + .getStackForm(1L)); + ItemList.Hatch_Input_Bus_ME.set( + new GT_MetaTileEntity_Hatch_InputBus_ME( + INPUT_BUS_ME.ID, + false, + "hatch.input_bus.me.basic", + "Stocking Input Bus (ME)").getStackForm(1L)); + ItemList.Hatch_Input_Bus_ME_Advanced.set( + new GT_MetaTileEntity_Hatch_InputBus_ME( + INPUT_BUS_ME_ADVANCED.ID, + true, + "hatch.input_bus.me", + "Advanced Stocking Input Bus (ME)").getStackForm(1L)); + ItemList.Hatch_Input_ME.set( + new GT_MetaTileEntity_Hatch_Input_ME( + INPUT_HATCH_ME.ID, + false, + "hatch.input.me.basic", + "Stocking Input Hatch (ME)").getStackForm(1L)); + ItemList.Hatch_Input_ME_Advanced.set( + new GT_MetaTileEntity_Hatch_Input_ME( + INPUT_HATCH_ME_ADVANCED.ID, + true, + "hatch.input.me", + "Advanced Stocking Input Hatch (ME)").getStackForm(1L)); + ItemList.Hatch_Output_ME.set( + new GT_MetaTileEntity_Hatch_Output_ME(OUTPUT_HATCH_ME.ID, "hatch.output.me", "Output Hatch (ME)") + .getStackForm(1L)); + ItemList.Hatch_CraftingInput_Bus_ME.set( + new GT_MetaTileEntity_Hatch_CraftingInput_ME( + CRAFTING_INPUT_ME.ID, + "hatch.crafting_input.me", + "Crafting Input Buffer (ME)", + true).getStackForm(1L)); + ItemList.Hatch_CraftingInput_Bus_ME_ItemOnly.set( + new GT_MetaTileEntity_Hatch_CraftingInput_ME( + CRAFTING_INPUT_ME_BUS.ID, + "hatch.crafting_input.me.item_only", + "Crafting Input Bus (ME)", + false).getStackForm(1L)); + ItemList.Hatch_CraftingInput_Bus_Slave.set( + new GT_MetaTileEntity_Hatch_CraftingInput_Slave( + CRAFTING_INPUT_SLAVE.ID, + "hatch.crafting_input.slave", + "Crafting Input Slave").getStackForm(1L)); + } + + private static void registerInputBus() { + ItemList.Hatch_Input_Bus_ULV.set( + new GT_MetaTileEntity_Hatch_InputBus(INPUT_BUS_ULV.ID, "hatch.input_bus.tier.00", "Input Bus (ULV)", 0) + .getStackForm(1L)); + ItemList.Hatch_Input_Bus_LV.set( + new GT_MetaTileEntity_Hatch_InputBus(INPUT_BUS_LV.ID, "hatch.input_bus.tier.01", "Input Bus (LV)", 1) + .getStackForm(1L)); + ItemList.Hatch_Input_Bus_MV.set( + new GT_MetaTileEntity_Hatch_InputBus(INPUT_BUS_MV.ID, "hatch.input_bus.tier.02", "Input Bus (MV)", 2) + .getStackForm(1L)); + ItemList.Hatch_Input_Bus_HV.set( + new GT_MetaTileEntity_Hatch_InputBus(INPUT_BUS_HV.ID, "hatch.input_bus.tier.03", "Input Bus (HV)", 3) + .getStackForm(1L)); + ItemList.Hatch_Input_Bus_EV.set( + new GT_MetaTileEntity_Hatch_InputBus(INPUT_BUS_EV.ID, "hatch.input_bus.tier.04", "Input Bus (EV)", 4) + .getStackForm(1L)); + ItemList.Hatch_Input_Bus_IV.set( + new GT_MetaTileEntity_Hatch_InputBus(INPUT_BUS_IV.ID, "hatch.input_bus.tier.05", "Input Bus (IV)", 5) + .getStackForm(1L)); + ItemList.Hatch_Input_Bus_LuV.set( + new GT_MetaTileEntity_Hatch_InputBus(INPUT_BUS_LuV.ID, "hatch.input_bus.tier.06", "Input Bus (LuV)", 6) + .getStackForm(1L)); + ItemList.Hatch_Input_Bus_ZPM.set( + new GT_MetaTileEntity_Hatch_InputBus(INPUT_BUS_ZPM.ID, "hatch.input_bus.tier.07", "Input Bus (ZPM)", 7) + .getStackForm(1L)); + ItemList.Hatch_Input_Bus_UV.set( + new GT_MetaTileEntity_Hatch_InputBus(INPUT_BUS_UV.ID, "hatch.input_bus.tier.08", "Input Bus (UV)", 8) + .getStackForm(1L)); + ItemList.Hatch_Input_Bus_MAX.set( + new GT_MetaTileEntity_Hatch_InputBus(INPUT_BUS_UHV.ID, "hatch.input_bus.tier.09", "Input Bus (UHV)", 9) + .getStackForm(1L)); + } + + private static void registerOutputBus() { + ItemList.Hatch_Output_Bus_ULV.set( + new GT_MetaTileEntity_Hatch_OutputBus(OUTPUT_BUS_ULV.ID, "hatch.output_bus.tier.00", "Output Bus (ULV)", 0) + .getStackForm(1L)); + ItemList.Hatch_Output_Bus_LV.set( + new GT_MetaTileEntity_Hatch_OutputBus(OUTPUT_BUS_LV.ID, "hatch.output_bus.tier.01", "Output Bus (LV)", 1) + .getStackForm(1L)); + ItemList.Hatch_Output_Bus_MV.set( + new GT_MetaTileEntity_Hatch_OutputBus(OUTPUT_BUS_MV.ID, "hatch.output_bus.tier.02", "Output Bus (MV)", 2) + .getStackForm(1L)); + ItemList.Hatch_Output_Bus_HV.set( + new GT_MetaTileEntity_Hatch_OutputBus(OUTPUT_BUS_HV.ID, "hatch.output_bus.tier.03", "Output Bus (HV)", 3) + .getStackForm(1L)); + ItemList.Hatch_Output_Bus_EV.set( + new GT_MetaTileEntity_Hatch_OutputBus(OUTPUT_BUS_EV.ID, "hatch.output_bus.tier.04", "Output Bus (EV)", 4) + .getStackForm(1L)); + ItemList.Hatch_Output_Bus_IV.set( + new GT_MetaTileEntity_Hatch_OutputBus(OUTPUT_BUS_IV.ID, "hatch.output_bus.tier.05", "Output Bus (IV)", 5) + .getStackForm(1L)); + ItemList.Hatch_Output_Bus_LuV.set( + new GT_MetaTileEntity_Hatch_OutputBus(OUTPUT_BUS_LuV.ID, "hatch.output_bus.tier.06", "Output Bus (LuV)", 6) + .getStackForm(1L)); + ItemList.Hatch_Output_Bus_ZPM.set( + new GT_MetaTileEntity_Hatch_OutputBus(OUTPUT_BUS_ZPM.ID, "hatch.output_bus.tier.07", "Output Bus (ZPM)", 7) + .getStackForm(1L)); + ItemList.Hatch_Output_Bus_UV.set( + new GT_MetaTileEntity_Hatch_OutputBus(OUTPUT_BUS_UV.ID, "hatch.output_bus.tier.08", "Output Bus (UV)", 8) + .getStackForm(1L)); + ItemList.Hatch_Output_Bus_MAX.set( + new GT_MetaTileEntity_Hatch_OutputBus(OUTPUT_BUS_UHV.ID, "hatch.output_bus.tier.09", "Output Bus (UHV)", 9) + .getStackForm(1L)); + } + + private static void registerMufflerHatch() { + ItemList.Hatch_Muffler_LV.set( + new GT_MetaTileEntity_Hatch_Muffler(MUFFLER_HATCH_LV.ID, "hatch.muffler.tier.01", "Muffler Hatch (LV)", 1) + .getStackForm(1L)); + ItemList.Hatch_Muffler_MV.set( + new GT_MetaTileEntity_Hatch_Muffler(MUFFLER_HATCH_MV.ID, "hatch.muffler.tier.02", "Muffler Hatch (MV)", 2) + .getStackForm(1L)); + ItemList.Hatch_Muffler_HV.set( + new GT_MetaTileEntity_Hatch_Muffler(MUFFLER_HATCH_HV.ID, "hatch.muffler.tier.03", "Muffler Hatch (HV)", 3) + .getStackForm(1L)); + ItemList.Hatch_Muffler_EV.set( + new GT_MetaTileEntity_Hatch_Muffler(MUFFLER_HATCH_EV.ID, "hatch.muffler.tier.04", "Muffler Hatch (EV)", 4) + .getStackForm(1L)); + ItemList.Hatch_Muffler_IV.set( + new GT_MetaTileEntity_Hatch_Muffler(MUFFLER_HATCH_IV.ID, "hatch.muffler.tier.05", "Muffler Hatch (IV)", 5) + .getStackForm(1L)); + ItemList.Hatch_Muffler_LuV.set( + new GT_MetaTileEntity_Hatch_Muffler(MUFFLER_HATCH_LuV.ID, "hatch.muffler.tier.06", "Muffler Hatch (LuV)", 6) + .getStackForm(1L)); + ItemList.Hatch_Muffler_ZPM.set( + new GT_MetaTileEntity_Hatch_Muffler(MUFFLER_HATCH_ZPM.ID, "hatch.muffler.tier.07", "Muffler Hatch (ZPM)", 7) + .getStackForm(1L)); + ItemList.Hatch_Muffler_UV.set( + new GT_MetaTileEntity_Hatch_Muffler(MUFFLER_HATCH_UV.ID, "hatch.muffler.tier.08", "Muffler Hatch (UV)", 8) + .getStackForm(1L)); + ItemList.Hatch_Muffler_MAX.set( + new GT_MetaTileEntity_Hatch_Muffler(MUFFLER_HATCH_UHV.ID, "hatch.muffler.tier.09", "Muffler Hatch (UHV)", 9) + .getStackForm(1L)); + } + + private static void registerBoiler() { + ItemList.Machine_Bronze_Boiler.set( + new GT_MetaTileEntity_Boiler_Bronze(SMALL_COAL_BOILER.ID, "boiler.bronze", "Small Coal Boiler") + .getStackForm(1L)); + ItemList.Machine_Steel_Boiler.set( + new GT_MetaTileEntity_Boiler_Steel( + HIGH_PRESSURE_COAL_BOILER.ID, + "boiler.steel", + "High Pressure Coal Boiler").getStackForm(1L)); + ItemList.Machine_Steel_Boiler_Lava.set( + new GT_MetaTileEntity_Boiler_Lava(HIGH_PRESSURE_LAVA_BOILER.ID, "boiler.lava", "High Pressure Lava Boiler") + .getStackForm(1L)); + ItemList.Machine_Bronze_Boiler_Solar.set( + new GT_MetaTileEntity_Boiler_Solar(SIMPLE_SOLAR_BOILER.ID, "boiler.solar", "Simple Solar Boiler") + .getStackForm(1L)); + ItemList.Machine_HP_Solar.set( + new GT_MetaTileEntity_Boiler_Solar_Steel( + HIGH_PRESSURE_SOLAR_BOILER.ID, + "boiler.steel.solar", + "High Pressure Solar Boiler").getStackForm(1L)); + } + + private static void registerBatteryBuffer1x1() { + ItemList.Battery_Buffer_1by1_ULV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_1_BY_1_ULV.ID, + "batterybuffer.01.tier.00", + "Ultra Low Voltage Battery Buffer", + 0, + "", + 1).getStackForm(1L)); + ItemList.Battery_Buffer_1by1_LV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_1_BY_1_LV.ID, + "batterybuffer.01.tier.01", + "Low Voltage Battery Buffer", + 1, + "", + 1).getStackForm(1L)); + ItemList.Battery_Buffer_1by1_MV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_1_BY_1_MV.ID, + "batterybuffer.01.tier.02", + "Medium Voltage Battery Buffer", + 2, + "", + 1).getStackForm(1L)); + ItemList.Battery_Buffer_1by1_HV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_1_BY_1_HV.ID, + "batterybuffer.01.tier.03", + "High Voltage Battery Buffer", + 3, + "", + 1).getStackForm(1L)); + ItemList.Battery_Buffer_1by1_EV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_1_BY_1_EV.ID, + "batterybuffer.01.tier.04", + "Extreme Voltage Battery Buffer", + 4, + "", + 1).getStackForm(1L)); + ItemList.Battery_Buffer_1by1_IV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_1_BY_1_IV.ID, + "batterybuffer.01.tier.05", + "Insane Voltage Battery Buffer", + 5, + "", + 1).getStackForm(1L)); + ItemList.Battery_Buffer_1by1_LuV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_1_BY_1_LuV.ID, + "batterybuffer.01.tier.06", + "Ludicrous Voltage Battery Buffer", + 6, + "", + 1).getStackForm(1L)); + ItemList.Battery_Buffer_1by1_ZPM.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_1_BY_1_ZPM.ID, + "batterybuffer.01.tier.07", + "ZPM Voltage Battery Buffer", + 7, + "", + 1).getStackForm(1L)); + ItemList.Battery_Buffer_1by1_UV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_1_BY_1_UV.ID, + "batterybuffer.01.tier.08", + "Ultimate Voltage Battery Buffer", + 8, + "", + 1).getStackForm(1L)); + ItemList.Battery_Buffer_1by1_MAX.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_1_BY_1_UHV.ID, + "batterybuffer.01.tier.09", + "Highly Ultimate Voltage Battery Buffer", + 9, + "", + 1).getStackForm(1L)); + } + + private static void registerBatteryBuffer2x2() { + ItemList.Battery_Buffer_2by2_ULV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_2_BY_2_ULV.ID, + "batterybuffer.04.tier.00", + "Ultra Low Voltage Battery Buffer", + 0, + "", + 4).getStackForm(1L)); + ItemList.Battery_Buffer_2by2_LV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_2_BY_2_LV.ID, + "batterybuffer.04.tier.01", + "Low Voltage Battery Buffer", + 1, + "", + 4).getStackForm(1L)); + ItemList.Battery_Buffer_2by2_MV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_2_BY_2_MV.ID, + "batterybuffer.04.tier.02", + "Medium Voltage Battery Buffer", + 2, + "", + 4).getStackForm(1L)); + ItemList.Battery_Buffer_2by2_HV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_2_BY_2_HV.ID, + "batterybuffer.04.tier.03", + "High Voltage Battery Buffer", + 3, + "", + 4).getStackForm(1L)); + ItemList.Battery_Buffer_2by2_EV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_2_BY_2_EV.ID, + "batterybuffer.04.tier.04", + "Extreme Voltage Battery Buffer", + 4, + "", + 4).getStackForm(1L)); + ItemList.Battery_Buffer_2by2_IV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_2_BY_2_IV.ID, + "batterybuffer.04.tier.05", + "Insane Voltage Battery Buffer", + 5, + "", + 4).getStackForm(1L)); + ItemList.Battery_Buffer_2by2_LuV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_2_BY_2_LuV.ID, + "batterybuffer.04.tier.06", + "Ludicrous Voltage Battery Buffer", + 6, + "", + 4).getStackForm(1L)); + ItemList.Battery_Buffer_2by2_ZPM.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_2_BY_2_ZPM.ID, + "batterybuffer.04.tier.07", + "ZPM Voltage Battery Buffer", + 7, + "", + 4).getStackForm(1L)); + ItemList.Battery_Buffer_2by2_UV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_2_BY_2_UV.ID, + "batterybuffer.04.tier.08", + "Ultimate Voltage Battery Buffer", + 8, + "", + 4).getStackForm(1L)); + ItemList.Battery_Buffer_2by2_MAX.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_2_BY_2_UHV.ID, + "batterybuffer.04.tier.09", + "Highly Ultimate Voltage Battery Buffer", + 9, + "", + 4).getStackForm(1L)); + } + + private static void registerBatteryBuffer3x3() { + ItemList.Battery_Buffer_3by3_ULV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_3_BY_3_ULV.ID, + "batterybuffer.09.tier.00", + "Ultra Low Voltage Battery Buffer", + 0, + "", + 9).getStackForm(1L)); + ItemList.Battery_Buffer_3by3_LV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_3_BY_3_LV.ID, + "batterybuffer.09.tier.01", + "Low Voltage Battery Buffer", + 1, + "", + 9).getStackForm(1L)); + ItemList.Battery_Buffer_3by3_MV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_3_BY_3_MV.ID, + "batterybuffer.09.tier.02", + "Medium Voltage Battery Buffer", + 2, + "", + 9).getStackForm(1L)); + ItemList.Battery_Buffer_3by3_HV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_3_BY_3_HV.ID, + "batterybuffer.09.tier.03", + "High Voltage Battery Buffer", + 3, + "", + 9).getStackForm(1L)); + ItemList.Battery_Buffer_3by3_EV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_3_BY_3_EV.ID, + "batterybuffer.09.tier.04", + "Extreme Voltage Battery Buffer", + 4, + "", + 9).getStackForm(1L)); + ItemList.Battery_Buffer_3by3_IV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_3_BY_3_IV.ID, + "batterybuffer.09.tier.05", + "Insane Voltage Battery Buffer", + 5, + "", + 9).getStackForm(1L)); + ItemList.Battery_Buffer_3by3_LuV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_3_BY_3_LuV.ID, + "batterybuffer.09.tier.06", + "Ludicrous Voltage Battery Buffer", + 6, + "", + 9).getStackForm(1L)); + ItemList.Battery_Buffer_3by3_ZPM.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_3_BY_3_ZPM.ID, + "batterybuffer.09.tier.07", + "ZPM Voltage Battery Buffer", + 7, + "", + 9).getStackForm(1L)); + ItemList.Battery_Buffer_3by3_UV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_3_BY_3_UV.ID, + "batterybuffer.09.tier.08", + "Ultimate Voltage Battery Buffer", + 8, + "", + 9).getStackForm(1L)); + ItemList.Battery_Buffer_3by3_MAX.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_3_BY_3_UHV.ID, + "batterybuffer.09.tier.09", + "Highly Ultimate Voltage Battery Buffer", + 9, + "", + 9).getStackForm(1L)); + } + + private static void registerBatteryBuffer4x4() { + ItemList.Battery_Buffer_4by4_ULV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_4_BY_4_ULV.ID, + "batterybuffer.16.tier.00", + "Ultra Low Voltage Battery Buffer", + 0, + "", + 16).getStackForm(1L)); + ItemList.Battery_Buffer_4by4_LV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_4_BY_4_LV.ID, + "batterybuffer.16.tier.01", + "Low Voltage Battery Buffer", + 1, + "", + 16).getStackForm(1L)); + ItemList.Battery_Buffer_4by4_MV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_4_BY_4_MV.ID, + "batterybuffer.16.tier.02", + "Medium Voltage Battery Buffer", + 2, + "", + 16).getStackForm(1L)); + ItemList.Battery_Buffer_4by4_HV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_4_BY_4_HV.ID, + "batterybuffer.16.tier.03", + "High Voltage Battery Buffer", + 3, + "", + 16).getStackForm(1L)); + ItemList.Battery_Buffer_4by4_EV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_4_BY_4_EV.ID, + "batterybuffer.16.tier.04", + "Extreme Voltage Battery Buffer", + 4, + "", + 16).getStackForm(1L)); + ItemList.Battery_Buffer_4by4_IV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_4_BY_4_IV.ID, + "batterybuffer.16.tier.05", + "Insane Voltage Battery Buffer", + 5, + "", + 16).getStackForm(1L)); + ItemList.Battery_Buffer_4by4_LuV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_4_BY_4_LuV.ID, + "batterybuffer.16.tier.06", + "Ludicrous Voltage Battery Buffer", + 6, + "", + 16).getStackForm(1L)); + ItemList.Battery_Buffer_4by4_ZPM.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_4_BY_4_ZPM.ID, + "batterybuffer.16.tier.07", + "ZPM Voltage Battery Buffer", + 7, + "", + 16).getStackForm(1L)); + ItemList.Battery_Buffer_4by4_UV.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_4_BY_4_UV.ID, + "batterybuffer.16.tier.08", + "Ultimate Voltage Battery Buffer", + 8, + "", + 16).getStackForm(1L)); + ItemList.Battery_Buffer_4by4_MAX.set( + new GT_MetaTileEntity_BasicBatteryBuffer( + BATTERY_BUFFER_4_BY_4_UHV.ID, + "batterybuffer.16.tier.09", + "Highly Ultimate Voltage Battery Buffer", + 9, + "", + 16).getStackForm(1L)); + } + + private static void registerCharger4x4() { + ItemList.Battery_Charger_4by4_ULV.set( + new GT_MetaTileEntity_Charger( + BATTERY_CHARGER_4_BY_4_ULV.ID, + "batterycharger.16.tier.00", + "Ultra Low Voltage Battery Charger", + 0, + "Each battery gives 8A in/4A out (min 4A/2A)", + 4).getStackForm(1L)); + ItemList.Battery_Charger_4by4_LV.set( + new GT_MetaTileEntity_Charger( + BATTERY_CHARGER_4_BY_4_LV.ID, + "batterycharger.16.tier.01", + "Low Voltage Battery Charger", + 1, + "Each battery gives 8A in/4A out (min 4A/2A)", + 4).getStackForm(1L)); + ItemList.Battery_Charger_4by4_MV.set( + new GT_MetaTileEntity_Charger( + BATTERY_CHARGER_4_BY_4_MV.ID, + "batterycharger.16.tier.02", + "Medium Voltage Battery Charger", + 2, + "Each battery gives 8A in/4A out (min 4A/2A)", + 4).getStackForm(1L)); + ItemList.Battery_Charger_4by4_HV.set( + new GT_MetaTileEntity_Charger( + BATTERY_CHARGER_4_BY_4_HV.ID, + "batterycharger.16.tier.03", + "High Voltage Battery Charger", + 3, + "Each battery gives 8A in/4A out (min 4A/2A)", + 4).getStackForm(1L)); + ItemList.Battery_Charger_4by4_EV.set( + new GT_MetaTileEntity_Charger( + BATTERY_CHARGER_4_BY_4_EV.ID, + "batterycharger.16.tier.04", + "Extreme Voltage Battery Charger", + 4, + "Each battery gives 8A in/4A out (min 4A/2A)", + 4).getStackForm(1L)); + ItemList.Battery_Charger_4by4_IV.set( + new GT_MetaTileEntity_Charger( + BATTERY_CHARGER_4_BY_4_IV.ID, + "batterycharger.16.tier.05", + "Insane Voltage Battery Charger", + 5, + "Each battery gives 8A in/4A out (min 4A/2A)", + 4).getStackForm(1L)); + ItemList.Battery_Charger_4by4_LuV.set( + new GT_MetaTileEntity_Charger( + BATTERY_CHARGER_4_BY_4_LuV.ID, + "batterycharger.16.tier.06", + "Ludicrous Voltage Battery Charger", + 6, + "Each battery gives 8A in/4A out (min 4A/2A)", + 4).getStackForm(1L)); + ItemList.Battery_Charger_4by4_ZPM.set( + new GT_MetaTileEntity_Charger( + BATTERY_CHARGER_4_BY_4_ZPM.ID, + "batterycharger.16.tier.07", + "ZPM Voltage Battery Charger", + 7, + "Each battery gives 8A in/4A out (min 4A/2A)", + 4).getStackForm(1L)); + ItemList.Battery_Charger_4by4_UV.set( + new GT_MetaTileEntity_Charger( + BATTERY_CHARGER_4_BY_4_UV.ID, + "batterycharger.16.tier.08", + "Ultimate Voltage Battery Charger", + 8, + "Each battery gives 8A in/4A out (min 4A/2A)", + 4).getStackForm(1L)); + ItemList.Battery_Charger_4by4_MAX.set( + new GT_MetaTileEntity_Charger( + BATTERY_CHARGER_4_BY_4_UHV.ID, + "batterycharger.16.tier.09", + "Highly Ultimate Voltage Battery Charger", + 9, + "Each battery gives 8A in/4A out (min 4A/2A)", + 4).getStackForm(1L)); + } + + private static void registerWirelessEnergyHatch() { + ItemList.Wireless_Hatch_Energy_ULV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_ULV.ID, + "hatch.wireless.receiver.tier.00", + "ULV Wireless Energy Hatch", + 0).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_LV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_LV.ID, + "hatch.wireless.receiver.tier.01", + "LV Wireless Energy Hatch", + 1).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_MV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_MV.ID, + "hatch.wireless.receiver.tier.02", + "MV Wireless Energy Hatch", + 2).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_HV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_HV.ID, + "hatch.wireless.receiver.tier.03", + "HV Wireless Energy Hatch", + 3).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_EV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_EV.ID, + "hatch.wireless.receiver.tier.04", + "EV Wireless Energy Hatch", + 4).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_IV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_IV.ID, + "hatch.wireless.receiver.tier.05", + "IV Wireless Energy Hatch", + 5).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_LuV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_LuV.ID, + "hatch.wireless.receiver.tier.06", + "LuV Wireless Energy Hatch", + 6).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_ZPM.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_ZPM.ID, + "hatch.wireless.receiver.tier.07", + "ZPM Wireless Energy Hatch", + 7).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_UV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_UV.ID, + "hatch.wireless.receiver.tier.08", + "UV Wireless Energy Hatch", + 8).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_UHV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_UHV.ID, + "hatch.wireless.receiver.tier.09", + "UHV Wireless Energy Hatch", + 9).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_UEV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_UEV.ID, + "hatch.wireless.receiver.tier.10", + "UEV Wireless Energy Hatch", + 10).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_UIV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_UIV.ID, + "hatch.wireless.receiver.tier.11", + "UIV Wireless Energy Hatch", + 11).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_UMV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_UMV.ID, + "hatch.wireless.receiver.tier.12", + "UMV Wireless Energy Hatch", + 12).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_UXV.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_UXV.ID, + "hatch.wireless.receiver.tier.13", + "UXV Wireless Energy Hatch", + 13).getStackForm(1L)); + ItemList.Wireless_Hatch_Energy_MAX.set( + new GT_MetaTileEntity_Wireless_Hatch( + WIRELESS_HATCH_ENERGY_MAX.ID, + "hatch.wireless.receiver.tier.14", + "MAX Wireless Energy Hatch", + 14).getStackForm(1L)); + } + + private static void registerWirelessDynamoHatch() { + ItemList.Wireless_Dynamo_Energy_ULV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_ULV.ID, + "hatch.wireless.transmitter.tier.00", + "ULV Wireless Energy Dynamo", + 0).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_LV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_LV.ID, + "hatch.wireless.transmitter.tier.01", + "LV Wireless Energy Dynamo", + 1).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_MV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_MV.ID, + "hatch.wireless.transmitter.tier.02", + "MV Wireless Energy Dynamo", + 2).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_HV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_HV.ID, + "hatch.wireless.transmitter.tier.03", + "HV Wireless Energy Dynamo", + 3).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_EV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_EV.ID, + "hatch.wireless.transmitter.tier.04", + "EV Wireless Energy Dynamo", + 4).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_IV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_IV.ID, + "hatch.wireless.transmitter.tier.05", + "IV Wireless Energy Dynamo", + 5).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_LuV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_LuV.ID, + "hatch.wireless.transmitter.tier.06", + "LuV Wireless Energy Dynamo", + 6).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_ZPM.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_ZPM.ID, + "hatch.wireless.transmitter.tier.07", + "ZPM Wireless Energy Dynamo", + 7).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_UV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_UV.ID, + "hatch.wireless.transmitter.tier.08", + "UV Wireless Energy Dynamo", + 8).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_UHV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_UHV.ID, + "hatch.wireless.transmitter.tier.09", + "UHV Wireless Energy Dynamo", + 9).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_UEV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_UEV.ID, + "hatch.wireless.transmitter.tier.10", + "UEV Wireless Energy Dynamo", + 10).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_UIV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_UIV.ID, + "hatch.wireless.transmitter.tier.11", + "UIV Wireless Energy Dynamo", + 11).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_UMV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_UMV.ID, + "hatch.wireless.transmitter.tier.12", + "UMV Wireless Energy Dynamo", + 12).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_UXV.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_UXV.ID, + "hatch.wireless.transmitter.tier.13", + "UXV Wireless Energy Dynamo", + 13).getStackForm(1L)); + ItemList.Wireless_Dynamo_Energy_MAX.set( + new GT_MetaTileEntity_Wireless_Dynamo( + WIRELESS_DYNAMO_ENERGY_HATCH_MAX.ID, + "hatch.wireless.transmitter.tier.14", + "MAX Wireless Energy Dynamo", + 14).getStackForm(1L)); + } + + private static void registerLightningRods() { + ItemList.Machine_HV_LightningRod.set( + new GT_MetaTileEntity_LightningRod( + LIGHTNING_ROD_HV.ID, + "basicgenerator.lightningrod.03", + "Lightning Rod", + 3).getStackForm(1)); + ItemList.Machine_EV_LightningRod.set( + new GT_MetaTileEntity_LightningRod( + LIGHTNING_ROD_EV.ID, + "basicgenerator.lightningrod.04", + "Lightning Rod II", + 4).getStackForm(1)); + ItemList.Machine_IV_LightningRod.set( + new GT_MetaTileEntity_LightningRod( + LIGHTNING_ROD_IV.ID, + "basicgenerator.lightningrod.05", + "Lightning Rod III", + 5).getStackForm(1)); + } + + private static void registerCombustionGenerators() { + ItemList.Generator_Diesel_LV.set( + new GT_MetaTileEntity_DieselGenerator( + COMBUSTION_GENERATOR_LV.ID, + "basicgenerator.diesel.tier.01", + "Basic Combustion Generator", + 1).getStackForm(1L)); + ItemList.Generator_Diesel_MV.set( + new GT_MetaTileEntity_DieselGenerator( + COMBUSTION_GENERATOR_MV.ID, + "basicgenerator.diesel.tier.02", + "Advanced Combustion Generator", + 2).getStackForm(1L)); + ItemList.Generator_Diesel_HV.set( + new GT_MetaTileEntity_DieselGenerator( + COMBUSTION_GENERATOR_HV.ID, + "basicgenerator.diesel.tier.03", + "Turbo Combustion Generator", + 3).getStackForm(1L)); + } + + private static void registerGasTurbines() { + ItemList.Generator_Gas_Turbine_LV.set( + new GT_MetaTileEntity_GasTurbine( + GAS_TURBINE_LV.ID, + "basicgenerator.gasturbine.tier.01", + "Basic Gas Turbine", + 1, + 95).getStackForm(1L)); + ItemList.Generator_Gas_Turbine_MV.set( + new GT_MetaTileEntity_GasTurbine( + GAS_TURBINE_MV.ID, + "basicgenerator.gasturbine.tier.02", + "Advanced Gas Turbine", + 2, + 90).getStackForm(1L)); + ItemList.Generator_Gas_Turbine_HV.set( + new GT_MetaTileEntity_GasTurbine( + GAS_TURBINE_HV.ID, + "basicgenerator.gasturbine.tier.03", + "Turbo Gas Turbine", + 3, + 85).getStackForm(1L)); + ItemList.Generator_Gas_Turbine_EV.set( + new GT_MetaTileEntity_GasTurbine( + GAS_TURBINE_EV.ID, + "basicgenerator.gasturbine.tier.04", + "Turbo Gas Turbine II", + 4, + 60).getStackForm(1L)); + ItemList.Generator_Gas_Turbine_IV.set( + new GT_MetaTileEntity_GasTurbine( + GAS_TURBINE_IV.ID, + "basicgenerator.gasturbine.tier.05", + "Turbo Gas Turbine III", + 5, + 50).getStackForm(1L)); + } + + private static void registerSteamTurbines() { + ItemList.Generator_Steam_Turbine_LV.set( + new GT_MetaTileEntity_SteamTurbine( + STEAM_TURBINE_LV.ID, + "basicgenerator.steamturbine.tier.01", + "Basic Steam Turbine", + 1).getStackForm(1L)); + ItemList.Generator_Steam_Turbine_MV.set( + new GT_MetaTileEntity_SteamTurbine( + STEAM_TURBINE_MV.ID, + "basicgenerator.steamturbine.tier.02", + "Advanced Steam Turbine", + 2).getStackForm(1L)); + ItemList.Generator_Steam_Turbine_HV.set( + new GT_MetaTileEntity_SteamTurbine( + STEAM_TURBINE_HV.ID, + "basicgenerator.steamturbine.tier.03", + "Turbo Steam Turbine", + 3).getStackForm(1L)); + } + + private static void registerNaquadahReactors() { + ItemList.Generator_Naquadah_Mark_I.set( + new GT_MetaTileEntity_NaquadahReactor( + NAQUADAH_REACTOR_EV.ID, + "basicgenerator.naquadah.tier.04", + new String[] { "Requires Enriched Naquadah Bolts" }, + "Naquadah Reactor Mark I", + 4).getStackForm(1L)); + ItemList.Generator_Naquadah_Mark_II.set( + new GT_MetaTileEntity_NaquadahReactor( + NAQUADAH_REACTOR_IV.ID, + "basicgenerator.naquadah.tier.05", + new String[] { "Requires Enriched Naquadah Rods" }, + "Naquadah Reactor Mark II", + 5).getStackForm(1L)); + ItemList.Generator_Naquadah_Mark_III.set( + new GT_MetaTileEntity_NaquadahReactor( + NAQUADAH_REACTOR_LuV.ID, + "basicgenerator.naquadah.tier.06", + new String[] { "Requires Enriched Naquadah Long Rods" }, + "Naquadah Reactor Mark III", + 6).getStackForm(1L)); + ItemList.Generator_Naquadah_Mark_IV.set( + new GT_MetaTileEntity_NaquadahReactor( + NAQUADAH_REACTOR_ZPM.ID, + "basicgenerator.naquadah.tier.07", + new String[] { "Requires Naquadria Bolts" }, + "Naquadah Reactor Mark IV", + 7).getStackForm(1L)); + ItemList.Generator_Naquadah_Mark_V.set( + new GT_MetaTileEntity_NaquadahReactor( + NAQUADAH_REACTOR_UV.ID, + "basicgenerator.naquadah.tier.08", + new String[] { "Requires Naquadria Rods" }, + "Naquadah Reactor Mark V", + 8).getStackForm(1L)); + } + + private static void registerMagicEnergyConverters() { + ItemList.MagicEnergyConverter_LV.set( + new GT_MetaTileEntity_MagicEnergyConverter( + MAGIC_ENERGY_CONVERTER_LV.ID, + "basicgenerator.magicenergyconverter.tier.01", + "Novice Magic Energy Converter", + 1).getStackForm(1L)); + ItemList.MagicEnergyConverter_MV.set( + new GT_MetaTileEntity_MagicEnergyConverter( + MAGIC_ENERGY_CONVERTER_MV.ID, + "basicgenerator.magicenergyconverter.tier.02", + "Adept Magic Energy Converter", + 2).getStackForm(1L)); + ItemList.MagicEnergyConverter_HV.set( + new GT_MetaTileEntity_MagicEnergyConverter( + MAGIC_ENERGY_CONVERTER_HV.ID, + "basicgenerator.magicenergyconverter.tier.03", + "Master Magic Energy Converter", + 3).getStackForm(1L)); + } + + private static void registerMagicEnergyAbsorbers() { + ItemList.MagicEnergyAbsorber_LV.set( + new GT_MetaTileEntity_MagicalEnergyAbsorber( + MAGIC_ENERGY_ABSORBER_LV.ID, + "basicgenerator.magicenergyabsorber.tier.01", + "Novice Magic Energy Absorber", + 1).getStackForm(1L)); + ItemList.MagicEnergyAbsorber_MV.set( + new GT_MetaTileEntity_MagicalEnergyAbsorber( + MAGIC_ENERGY_ABSORBER_MV.ID, + "basicgenerator.magicenergyabsorber.tier.02", + "Adept Magic Energy Absorber", + 2).getStackForm(1L)); + ItemList.MagicEnergyAbsorber_HV.set( + new GT_MetaTileEntity_MagicalEnergyAbsorber( + MAGIC_ENERGY_ABSORBER_HV.ID, + "basicgenerator.magicenergyabsorber.tier.03", + "Master Magic Energy Absorber", + 3).getStackForm(1L)); + ItemList.MagicEnergyAbsorber_EV.set( + new GT_MetaTileEntity_MagicalEnergyAbsorber( + MAGIC_ENERGY_ABSORBER_EV.ID, + "basicgenerator.magicenergyabsorber.tier.04", + "Grandmaster Magic Energy Absorber", + 4).getStackForm(1L)); + } + + private static void registerPlasmaGenerators() { + ItemList.Generator_Plasma_IV.set( + new GT_MetaTileEntity_PlasmaGenerator( + PLASMA_GENERATOR_IV.ID, + "basicgenerator.plasmagenerator.tier.05", + "Plasma Generator Mark I", + 4).getStackForm(1L)); + ItemList.Generator_Plasma_LuV.set( + new GT_MetaTileEntity_PlasmaGenerator( + PLASMA_GENERATOR_LuV.ID, + "basicgenerator.plasmagenerator.tier.06", + "Plasma Generator Mark II", + 5).getStackForm(1L)); + ItemList.Generator_Plasma_ZPMV.set( + new GT_MetaTileEntity_PlasmaGenerator( + PLASMA_GENERATOR_ZPM.ID, + "basicgenerator.plasmagenerator.tier.07", + "Plasma Generator Mark III", + 6).getStackForm(1L)); + } + + private static void generateWiresAndPipes() { + for (int i = 0; i < GregTech_API.sGeneratedMaterials.length; i++) { + if (((GregTech_API.sGeneratedMaterials[i] != null) + && ((GregTech_API.sGeneratedMaterials[i].mTypes & 0x2) != 0)) + || (GregTech_API.sGeneratedMaterials[i] == Materials.Wood)) { + new GT_MetaPipeEntity_Frame( + 4096 + i, + "GT_Frame_" + GregTech_API.sGeneratedMaterials[i], + (GT_LanguageManager.i18nPlaceholder ? "%material" + : GregTech_API.sGeneratedMaterials[i] != null + ? GregTech_API.sGeneratedMaterials[i].mDefaultLocalName + : "") + + " Frame Box", + GregTech_API.sGeneratedMaterials[i]); + } + } + boolean bEC = !GT_Mod.gregtechproxy.mHardcoreCables; + + makeWires(Materials.RedAlloy, 2000, 0L, 1L, 1L, gregtech.api.enums.GT_Values.V[0], true, false); + + makeWires(Materials.Cobalt, 1200, 2L, 4L, 2L, gregtech.api.enums.GT_Values.V[1], true, false); + makeWires(Materials.Lead, 1220, 2L, 4L, 2L, gregtech.api.enums.GT_Values.V[1], true, false); + makeWires(Materials.Tin, 1240, 1L, 2L, 1L, gregtech.api.enums.GT_Values.V[1], true, false); + + makeWires(Materials.Zinc, 1260, 1L, 2L, 1L, gregtech.api.enums.GT_Values.V[1], true, false); + makeWires(Materials.SolderingAlloy, 1280, 1L, 2L, 1L, gregtech.api.enums.GT_Values.V[1], true, false); + + makeWires( + Materials.Iron, + 1300, + bEC ? 3L : 4L, + bEC ? 6L : 8L, + 2L, + gregtech.api.enums.GT_Values.V[2], + true, + false); + makeWires( + Materials.Nickel, + 1320, + bEC ? 3L : 5L, + bEC ? 6L : 10L, + 3L, + gregtech.api.enums.GT_Values.V[2], + true, + false); + makeWires( + Materials.Cupronickel, + 1340, + bEC ? 3L : 4L, + bEC ? 6L : 8L, + 2L, + gregtech.api.enums.GT_Values.V[2], + true, + false); + makeWires( + Materials.Copper, + 1360, + bEC ? 2L : 3L, + bEC ? 4L : 6L, + 1L, + gregtech.api.enums.GT_Values.V[2], + true, + false); + makeWires( + Materials.AnnealedCopper, + 1380, + bEC ? 1L : 2L, + bEC ? 2L : 4L, + 1L, + gregtech.api.enums.GT_Values.V[2], + true, + false); + + makeWires( + Materials.Kanthal, + 1400, + bEC ? 3L : 8L, + bEC ? 6L : 16L, + 4L, + gregtech.api.enums.GT_Values.V[3], + true, + false); + makeWires( + Materials.Gold, + 1420, + bEC ? 2L : 6L, + bEC ? 4L : 12L, + 3L, + gregtech.api.enums.GT_Values.V[3], + true, + false); + makeWires( + Materials.Electrum, + 1440, + bEC ? 2L : 5L, + bEC ? 4L : 10L, + 2L, + gregtech.api.enums.GT_Values.V[3], + true, + false); + makeWires( + Materials.Silver, + 1460, + bEC ? 1L : 4L, + bEC ? 2L : 8L, + 1L, + gregtech.api.enums.GT_Values.V[3], + true, + false); + makeWires( + Materials.BlueAlloy, + 1480, + bEC ? 1L : 4L, + bEC ? 2L : 8L, + 2L, + gregtech.api.enums.GT_Values.V[3], + true, + false); + + makeWires( + Materials.Nichrome, + 1500, + bEC ? 4L : 32L, + bEC ? 8L : 64L, + 3L, + gregtech.api.enums.GT_Values.V[4], + true, + false); + makeWires( + Materials.Steel, + 1520, + bEC ? 2L : 16L, + bEC ? 4L : 32L, + 2L, + gregtech.api.enums.GT_Values.V[4], + true, + false); + makeWires( + Materials.BlackSteel, + 1540, + bEC ? 2L : 14L, + bEC ? 4L : 28L, + 3L, + gregtech.api.enums.GT_Values.V[4], + true, + false); + makeWires( + Materials.Titanium, + 1560, + bEC ? 2L : 12L, + bEC ? 4L : 24L, + 4L, + gregtech.api.enums.GT_Values.V[4], + true, + false); + makeWires( + Materials.Aluminium, + 1580, + bEC ? 1L : 8L, + bEC ? 2L : 16L, + 1L, + gregtech.api.enums.GT_Values.V[4], + true, + false); + + makeWires( + Materials.Graphene, + 1600, + bEC ? 1L : 16L, + bEC ? 2L : 32L, + 1L, + gregtech.api.enums.GT_Values.V[5], + false, + true); + makeWires( + Materials.Osmium, + 1620, + bEC ? 2L : 32L, + bEC ? 4L : 64L, + 4L, + gregtech.api.enums.GT_Values.V[5], + true, + false); + makeWires( + Materials.Platinum, + 1640, + bEC ? 1L : 16L, + bEC ? 2L : 32L, + 2L, + gregtech.api.enums.GT_Values.V[5], + true, + false); + makeWires( + Materials.TungstenSteel, + 1660, + bEC ? 2L : 14L, + bEC ? 4L : 28L, + 3L, + gregtech.api.enums.GT_Values.V[5], + true, + false); + makeWires( + Materials.Tungsten, + 1680, + bEC ? 2L : 12L, + bEC ? 4L : 24L, + 2L, + gregtech.api.enums.GT_Values.V[5], + true, + false); + + makeWires( + Materials.HSSG, + 1700, + bEC ? 2L : 128L, + bEC ? 4L : 256L, + 4L, + gregtech.api.enums.GT_Values.V[6], + true, + false); + makeWires( + Materials.NiobiumTitanium, + 1720, + bEC ? 2L : 128L, + bEC ? 4L : 256L, + 4L, + gregtech.api.enums.GT_Values.V[6], + true, + false); + makeWires( + Materials.VanadiumGallium, + 1740, + bEC ? 2L : 128L, + bEC ? 4L : 256L, + 4L, + gregtech.api.enums.GT_Values.V[6], + true, + false); + makeWires( + Materials.YttriumBariumCuprate, + 1760, + bEC ? 4L : 256L, + bEC ? 8L : 512L, + 4L, + gregtech.api.enums.GT_Values.V[6], + true, + false); + + makeWires( + Materials.Naquadah, + 1780, + bEC ? 2L : 64L, + bEC ? 4L : 128L, + 2L, + gregtech.api.enums.GT_Values.V[7], + true, + false); + + makeWires( + Materials.NaquadahAlloy, + 1800, + bEC ? 4L : 64L, + bEC ? 8L : 128L, + 2L, + gregtech.api.enums.GT_Values.V[8], + true, + false); + makeWires( + Materials.Duranium, + 1820, + bEC ? 8L : 64L, + bEC ? 16L : 128L, + 1L, + gregtech.api.enums.GT_Values.V[8], + true, + false); + makeWires( + Materials.TPV, + 1840, + bEC ? 1L : 14L, + bEC ? 2L : 28L, + 6L, + gregtech.api.enums.GT_Values.V[4], + true, + false); + + // Superconductor base. + makeWires( + Materials.Pentacadmiummagnesiumhexaoxid, + 2200, + 1L, + 2L, + 1L, + gregtech.api.enums.GT_Values.V[2], + false, + false); + makeWires( + Materials.Titaniumonabariumdecacoppereikosaoxid, + 2220, + 1L, + 8L, + 2L, + gregtech.api.enums.GT_Values.V[3], + false, + false); + makeWires(Materials.Uraniumtriplatinid, 2240, 1L, 16L, 3L, gregtech.api.enums.GT_Values.V[4], false, false); + makeWires(Materials.Vanadiumtriindinid, 2260, 1L, 64L, 4L, gregtech.api.enums.GT_Values.V[5], false, false); + makeWires( + Materials.Tetraindiumditindibariumtitaniumheptacoppertetrakaidekaoxid, + 2280, + 2L, + 256L, + 6L, + gregtech.api.enums.GT_Values.V[6], + false, + false); + makeWires( + Materials.Tetranaquadahdiindiumhexaplatiumosminid, + 2300, + 2L, + 1024L, + 8L, + gregtech.api.enums.GT_Values.V[7], + false, + false); + makeWires( + Materials.Longasssuperconductornameforuvwire, + 2500, + 2L, + 4096L, + 12L, + gregtech.api.enums.GT_Values.V[8], + false, + false); + makeWires( + Materials.Longasssuperconductornameforuhvwire, + 2520, + 2L, + 16384L, + 16L, + gregtech.api.enums.GT_Values.V[9], + false, + false); + makeWires( + Materials.SuperconductorUEVBase, + 2032, + 2L, + 65536L, + 24L, + gregtech.api.enums.GT_Values.V[10], + false, + false); + makeWires( + Materials.SuperconductorUIVBase, + 2052, + 2L, + 262144L, + 32L, + gregtech.api.enums.GT_Values.V[11], + false, + false); + makeWires(Materials.SuperconductorUMVBase, 2072, 2L, 1048576L, 32L, GT_Values.V[12], false, false); + + // Actual superconductors. + makeWires(Materials.SuperconductorMV, 2320, 0L, 0L, 4L, gregtech.api.enums.GT_Values.V[2], false, true); + makeWires(Materials.SuperconductorHV, 2340, 0L, 0L, 6L, gregtech.api.enums.GT_Values.V[3], false, true); + makeWires(Materials.SuperconductorEV, 2360, 0L, 0L, 8L, gregtech.api.enums.GT_Values.V[4], false, true); + makeWires(Materials.SuperconductorIV, 2380, 0L, 0L, 12L, gregtech.api.enums.GT_Values.V[5], false, true); + makeWires(Materials.SuperconductorLuV, 2400, 0L, 0L, 16L, gregtech.api.enums.GT_Values.V[6], false, true); + makeWires(Materials.SuperconductorZPM, 2420, 0L, 0L, 24L, gregtech.api.enums.GT_Values.V[7], false, true); + makeWires(Materials.SuperconductorUV, 2440, 0L, 0L, 32L, gregtech.api.enums.GT_Values.V[8], false, true); + makeWires(Materials.SuperconductorUHV, 2020, 0L, 0L, 48L, gregtech.api.enums.GT_Values.V[9], false, true); + makeWires(Materials.SuperconductorUEV, 2026, 0L, 0L, 64L, gregtech.api.enums.GT_Values.V[10], false, true); + makeWires(Materials.SuperconductorUIV, 2081, 0L, 0L, 64L, gregtech.api.enums.GT_Values.V[11], false, true); + makeWires(Materials.SuperconductorUMV, 2089, 0L, 0L, 64L, gregtech.api.enums.GT_Values.V[12], false, true); + + makeWires(Materials.Ichorium, 2600, 2L, 2L, 12L, GT_Values.V[9], false, true); + makeWires(MaterialsUEVplus.SpaceTime, 2606, 0L, 0L, 1_000_000L, GT_Values.V[14], false, true); + + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeSmall.get(Materials.Wood), + new GT_MetaPipeEntity_Fluid( + 5101, + "GT_Pipe_Wood_Small", + "Small Wooden Fluid Pipe", + 0.375F, + Materials.Wood, + 10, + 350, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeMedium.get(Materials.Wood), + new GT_MetaPipeEntity_Fluid(5102, "GT_Pipe_Wood", "Wooden Fluid Pipe", 0.5F, Materials.Wood, 30, 350, false) + .getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeLarge.get(Materials.Wood), + new GT_MetaPipeEntity_Fluid( + 5103, + "GT_Pipe_Wood_Large", + "Large Wooden Fluid Pipe", + 0.75F, + Materials.Wood, + 60, + 350, + false).getStackForm(1L)); + + generateFluidPipes(Materials.Copper, Materials.Copper.mName, 5110, 20, 1000, true); + generateFluidMultiPipes(Materials.Copper, Materials.Copper.mName, 5115, 20, 1000, true); + generateFluidPipes(Materials.Bronze, Materials.Bronze.mName, 5120, 120, 2000, true); + generateFluidMultiPipes(Materials.Bronze, Materials.Bronze.mName, 5125, 120, 2000, true); + generateFluidPipes(Materials.Steel, Materials.Steel.mName, 5130, 240, 2500, true); + generateFluidMultiPipes(Materials.Steel, Materials.Steel.mName, 5135, 240, 2500, true); + generateFluidPipes(Materials.StainlessSteel, Materials.StainlessSteel.mName, 5140, 360, 3000, true); + generateFluidMultiPipes(Materials.StainlessSteel, Materials.StainlessSteel.mName, 5145, 360, 3000, true); + generateFluidPipes(Materials.Titanium, Materials.Titanium.mName, 5150, 480, 5000, true); + generateFluidMultiPipes(Materials.Titanium, Materials.Titanium.mName, 5155, 480, 5000, true); + generateFluidPipes(Materials.TungstenSteel, Materials.TungstenSteel.mName, 5160, 600, 7500, true); + generateFluidMultiPipes(Materials.TungstenSteel, Materials.TungstenSteel.mName, 5270, 600, 7500, true); + generateFluidPipes( + Materials.Polybenzimidazole, + Materials.Polybenzimidazole.mName, + "PBI", + 5280, + 600, + 1000, + true); + generateFluidMultiPipes( + Materials.Polybenzimidazole, + Materials.Polybenzimidazole.mName, + "PBI", + 5290, + 600, + 1000, + true); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeSmall.get(Materials.Ultimate), + new GT_MetaPipeEntity_Fluid( + 5165, + "GT_Pipe_HighPressure_Small", + "Small High Pressure Fluid Pipe", + 0.375F, + Materials.Redstone, + 4800, + 1500, + true).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeMedium.get(Materials.Ultimate), + new GT_MetaPipeEntity_Fluid( + 5166, + "GT_Pipe_HighPressure", + "High Pressure Fluid Pipe", + 0.5F, + Materials.Redstone, + 7200, + 1500, + true).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeLarge.get(Materials.Ultimate), + new GT_MetaPipeEntity_Fluid( + 5167, + "GT_Pipe_HighPressure_Large", + "Large High Pressure Fluid Pipe", + 0.75F, + Materials.Redstone, + 9600, + 1500, + true).getStackForm(1L)); + generateFluidPipes(Materials.Plastic, Materials.Plastic.mName, "Plastic", 5170, 360, 350, true); + generateFluidMultiPipes(Materials.Plastic, Materials.Plastic.mName, "Plastic", 5175, 360, 350, true); + generateFluidPipes(Materials.NiobiumTitanium, Materials.NiobiumTitanium.mName, 5180, 900, 2900, true); + generateFluidMultiPipes(Materials.NiobiumTitanium, Materials.NiobiumTitanium.mName, 5185, 900, 2900, true); + generateFluidPipes(Materials.Enderium, Materials.Enderium.mName, 5190, 1800, 15000, true); + generateFluidMultiPipes(Materials.Enderium, Materials.Enderium.mName, 5195, 1800, 15000, true); + generateFluidPipes(Materials.Naquadah, Materials.Naquadah.mName, 5200, 9000, 19000, true); + generateFluidMultiPipes(Materials.Naquadah, Materials.Naquadah.mName, 5205, 9000, 19000, true); + generateFluidPipes(Materials.Neutronium, Materials.Neutronium.mName, 5210, 16800, 1000000, true); + generateFluidMultiPipes(Materials.Neutronium, Materials.Neutronium.mName, 5215, 16800, 1000000, true); + generateFluidPipes(Materials.NetherStar, Materials.NetherStar.mName, 5220, 19200, 1000000, true); + generateFluidMultiPipes(Materials.NetherStar, Materials.NetherStar.mName, 5225, 19200, 1000000, true); + generateFluidPipes(Materials.MysteriousCrystal, Materials.MysteriousCrystal.mName, 5230, 24000, 1000000, true); + generateFluidMultiPipes( + Materials.MysteriousCrystal, + Materials.MysteriousCrystal.mName, + 5235, + 24000, + 1000000, + true); + generateFluidPipes(Materials.DraconiumAwakened, Materials.DraconiumAwakened.mName, 5240, 45000, 10000000, true); + generateFluidMultiPipes( + Materials.DraconiumAwakened, + Materials.DraconiumAwakened.mName, + 5245, + 45000, + 10000000, + true); + generateFluidPipes(Materials.Infinity, Materials.Infinity.mName, 5250, 60000, 10000000, true); + generateFluidMultiPipes(Materials.Infinity, Materials.Infinity.mName, 5255, 60000, 10000000, true); + generateFluidPipes(Materials.WroughtIron, Materials.WroughtIron.mName, 5260, 180, 2250, true); + generateFluidMultiPipes(Materials.WroughtIron, Materials.WroughtIron.mName, 5265, 180, 2250, true); + generateFluidPipes( + Materials.Polytetrafluoroethylene, + Materials.Polytetrafluoroethylene.mName, + "PTFE", + 5680, + 480, + 600, + true); + generateFluidMultiPipes( + Materials.Polytetrafluoroethylene, + Materials.Polytetrafluoroethylene.mName, + "PTFE", + 5685, + 480, + 600, + true); + generateFluidPipes( + MaterialsUEVplus.SpaceTime, + MaterialsUEVplus.SpaceTime.mName, + 5300, + 250000, + 2147483647, + true); + generateFluidMultiPipes( + MaterialsUEVplus.SpaceTime, + MaterialsUEVplus.SpaceTime.mName, + 5305, + 250000, + 2147483647, + true); + generateFluidPipes( + MaterialsUEVplus.TranscendentMetal, + MaterialsUEVplus.TranscendentMetal.mName, + 5310, + 220000, + 2147483647, + true); + generateFluidMultiPipes( + MaterialsUEVplus.TranscendentMetal, + MaterialsUEVplus.TranscendentMetal.mName, + 5315, + 220000, + 2147483647, + true); + + generateItemPipes(Materials.Brass, Materials.Brass.mName, 5602, 1); + generateItemPipes(Materials.Electrum, Materials.Electrum.mName, 5612, 2); + generateItemPipes(Materials.Platinum, Materials.Platinum.mName, 5622, 4); + generateItemPipes(Materials.Osmium, Materials.Osmium.mName, 5632, 8); + generateItemPipes(Materials.PolyvinylChloride, Materials.PolyvinylChloride.mName, "PVC", 5690, 4); + generateItemPipes(Materials.Nickel, Materials.Nickel.mName, 5700, 1); + generateItemPipes(Materials.Cobalt, Materials.Cobalt.mName, 5710, 2); + generateItemPipes(Materials.Aluminium, Materials.Aluminium.mName, 5720, 2); + if (NewHorizonsCoreMod.isModLoaded()) { + generateFluidPipes(Materials.get("RadoxPoly"), "RadoxPoly", 5760, 5000, 1500, true); + } + } + + @SuppressWarnings("PointlessArithmeticExpression") + private static void makeWires(Materials aMaterial, int aStartID, long aLossInsulated, long aLoss, long aAmperage, + long aVoltage, boolean aInsulatable, boolean aAutoInsulated) { + String name = GT_LanguageManager.i18nPlaceholder ? "%material" : aMaterial.mDefaultLocalName; + GT_OreDictUnificator.registerOre( + OrePrefixes.wireGt01, + aMaterial, + new GT_MetaPipeEntity_Cable( + aStartID + 0, + aTextWire1 + aMaterial.mName.toLowerCase() + ".01", + "1x " + name + aTextWire2, + 0.125F, + aMaterial, + aLoss, + 1L * aAmperage, + aVoltage, + false, + !aAutoInsulated).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.wireGt02, + aMaterial, + new GT_MetaPipeEntity_Cable( + aStartID + 1, + aTextWire1 + aMaterial.mName.toLowerCase() + ".02", + "2x " + name + aTextWire2, + 0.25F, + aMaterial, + aLoss, + 2L * aAmperage, + aVoltage, + false, + !aAutoInsulated).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.wireGt04, + aMaterial, + new GT_MetaPipeEntity_Cable( + aStartID + 2, + aTextWire1 + aMaterial.mName.toLowerCase() + ".04", + "4x " + name + aTextWire2, + 0.375F, + aMaterial, + aLoss, + 4L * aAmperage, + aVoltage, + false, + !aAutoInsulated).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.wireGt08, + aMaterial, + new GT_MetaPipeEntity_Cable( + aStartID + 3, + aTextWire1 + aMaterial.mName.toLowerCase() + ".08", + "8x " + name + aTextWire2, + 0.5F, + aMaterial, + aLoss, + 8L * aAmperage, + aVoltage, + false, + !aAutoInsulated).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.wireGt12, + aMaterial, + new GT_MetaPipeEntity_Cable( + aStartID + 4, + aTextWire1 + aMaterial.mName.toLowerCase() + ".12", + "12x " + name + aTextWire2, + 0.625F, + aMaterial, + aLoss, + 12L * aAmperage, + aVoltage, + false, + !aAutoInsulated).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.wireGt16, + aMaterial, + new GT_MetaPipeEntity_Cable( + aStartID + 5, + aTextWire1 + aMaterial.mName.toLowerCase() + ".16", + "16x " + name + aTextWire2, + 0.75F, + aMaterial, + aLoss, + 16L * aAmperage, + aVoltage, + false, + !aAutoInsulated).getStackForm(1L)); + if (aInsulatable) { + GT_OreDictUnificator.registerOre( + OrePrefixes.cableGt01, + aMaterial, + new GT_MetaPipeEntity_Cable( + aStartID + 6, + aTextCable1 + aMaterial.mName.toLowerCase() + ".01", + "1x " + name + aTextCable2, + 0.25F, + aMaterial, + aLossInsulated, + 1L * aAmperage, + aVoltage, + true, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.cableGt02, + aMaterial, + new GT_MetaPipeEntity_Cable( + aStartID + 7, + aTextCable1 + aMaterial.mName.toLowerCase() + ".02", + "2x " + name + aTextCable2, + 0.375F, + aMaterial, + aLossInsulated, + 2L * aAmperage, + aVoltage, + true, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.cableGt04, + aMaterial, + new GT_MetaPipeEntity_Cable( + aStartID + 8, + aTextCable1 + aMaterial.mName.toLowerCase() + ".04", + "4x " + name + aTextCable2, + 0.5F, + aMaterial, + aLossInsulated, + 4L * aAmperage, + aVoltage, + true, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.cableGt08, + aMaterial, + new GT_MetaPipeEntity_Cable( + aStartID + 9, + aTextCable1 + aMaterial.mName.toLowerCase() + ".08", + "8x " + name + aTextCable2, + 0.625F, + aMaterial, + aLossInsulated, + 8L * aAmperage, + aVoltage, + true, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.cableGt12, + aMaterial, + new GT_MetaPipeEntity_Cable( + aStartID + 10, + aTextCable1 + aMaterial.mName.toLowerCase() + ".12", + "12x " + name + aTextCable2, + 0.75F, + aMaterial, + aLossInsulated, + 12L * aAmperage, + aVoltage, + true, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.cableGt16, + aMaterial, + new GT_MetaPipeEntity_Cable( + aStartID + 11, + aTextCable1 + aMaterial.mName.toLowerCase() + ".16", + "16x " + name + aTextCable2, + 0.875F, + aMaterial, + aLossInsulated, + 16L * aAmperage, + aVoltage, + true, + false).getStackForm(1L)); + } + } + + @Override + public void run() { + GT_Log.out.println("GT_Mod: Registering MetaTileEntities."); + registerMachineHull(); + registerTransformer(); + registerDynamoHatch(); + registerEnergyHatch(); + registerInputHatch(); + registerQuadrupleInputHatch(); + registerOutputHatch(); + registerQuantumTank(); + registerQuantumChest(); + registerSuperTank(); + registerSuperChest(); + registerLongDistancePipe(); + registerAE2Hatches(); + registerInputBus(); + registerOutputBus(); + registerMufflerHatch(); + registerBoiler(); + registerBatteryBuffer1x1(); + registerBatteryBuffer2x2(); + registerBatteryBuffer3x3(); + registerBatteryBuffer4x4(); + registerCharger4x4(); + registerWirelessEnergyHatch(); + registerWirelessDynamoHatch(); + registerSteamMachines(); + registerHPSteamMachines(); + registerLocker(); + registerScanner(); + registerPackager(); + registerRockBreaker(); + registerIndustrialApiary(); + registerMassFab(); + registerReplicator(); + registerBrewery(); + registerMiner(); + registerPump(); + registerTeleporter(); + registerMonsterRepellator(); + registerAdvancedSeismicProspector(); + registerMicrowaveEnergyTransmitter(); + registerChestBuffer(); + registerItemFilter(); + registerTypeFilter(); + registerRegulator(); + registerSuperBuffer(); + registerItemDistributor(); + registerRecipeFilter(); + registerLightningRods(); + registerCombustionGenerators(); + registerGasTurbines(); + registerSteamTurbines(); + registerNaquadahReactors(); + registerMagicEnergyAbsorbers(); + registerMagicEnergyConverters(); + registerPlasmaGenerators(); + registerMultiblockControllers(); + + ItemList.AdvDebugStructureWriter.set( + new GT_MetaTileEntity_AdvDebugStructureWriter( + ADVANCED_DEBUG_STRUCTURE_WRITTER.ID, + "advdebugstructurewriter", + "Advanced Debug Structure Writer", + 5).getStackForm(1L)); + ItemList.Hatch_Maintenance.set( + new GT_MetaTileEntity_Hatch_Maintenance(MAINTENANCE_HATCH.ID, "hatch.maintenance", "Maintenance Hatch", 1) + .getStackForm(1L)); + ItemList.Hatch_AutoMaintenance.set( + new GT_MetaTileEntity_Hatch_Maintenance( + AUTO_MAINTENANCE_HATCH.ID, + "hatch.maintenance.auto", + "Auto Maintenance Hatch", + 6, + true).getStackForm(1L)); + ItemList.Hatch_DroneDownLink.set( + new GT_MetaTileEntity_Hatch_DroneDownLink( + DroneDownLink.ID, + "hatch.dronedownlink", + "Drone DownLink Module", + 5).getStackForm(1)); + ItemList.Hatch_DataAccess_EV.set( + new GT_MetaTileEntity_Hatch_DataAccess(DATA_ACCESS_HATCH.ID, "hatch.dataaccess", "Data Access Hatch", 4) + .getStackForm(1L)); + ItemList.Hatch_DataAccess_LuV.set( + new GT_MetaTileEntity_Hatch_DataAccess( + ADVANCED_DATA_ACCESS_HATCH.ID, + "hatch.dataaccess.adv", + "Advanced Data Access Hatch", + 6).getStackForm(1L)); + ItemList.Hatch_DataAccess_UV.set( + new GT_MetaTileEntity_Hatch_DataAccess( + AUTOMATABLE_DATA_ACCESS_HATCH.ID, + "hatch.dataaccess.auto", + "Automatable Data Access Hatch", + 8).getStackForm(1L)); + generateWiresAndPipes(); + } + + private static void generateItemPipes(Materials aMaterial, String name, int startID, int baseInvSlots) { + generateItemPipes( + aMaterial, + name, + GT_LanguageManager.i18nPlaceholder ? "%material" : aMaterial.mDefaultLocalName, + startID, + baseInvSlots); + } + + private static void generateItemPipes(Materials aMaterial, String name, String displayName, int startID, + int baseInvSlots) { + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeMedium.get(aMaterial), + new GT_MetaPipeEntity_Item( + startID, + "GT_Pipe_" + name, + displayName + " Item Pipe", + 0.50F, + aMaterial, + baseInvSlots, + 32768 / baseInvSlots, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeLarge.get(aMaterial), + new GT_MetaPipeEntity_Item( + startID + 1, + "GT_Pipe_" + name + "_Large", + "Large " + displayName + " Item Pipe", + 0.75F, + aMaterial, + baseInvSlots * 2, + 16384 / baseInvSlots, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeHuge.get(aMaterial), + new GT_MetaPipeEntity_Item( + startID + 2, + "GT_Pipe_" + name + "_Huge", + "Huge " + displayName + " Item Pipe", + 1.00F, + aMaterial, + baseInvSlots * 4, + 8192 / baseInvSlots, + false).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeRestrictiveMedium.get(aMaterial), + new GT_MetaPipeEntity_Item( + startID + 3, + "GT_Pipe_Restrictive_" + name, + "Restrictive " + displayName + " Item Pipe", + 0.50F, + aMaterial, + baseInvSlots, + 3276800 / baseInvSlots, + true).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeRestrictiveLarge.get(aMaterial), + new GT_MetaPipeEntity_Item( + startID + 4, + "GT_Pipe_Restrictive_" + name + "_Large", + "Large Restrictive " + displayName + " Item Pipe", + 0.75F, + aMaterial, + baseInvSlots * 2, + 1638400 / baseInvSlots, + true).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeRestrictiveHuge.get(aMaterial), + new GT_MetaPipeEntity_Item( + startID + 5, + "GT_Pipe_Restrictive_" + name + "_Huge", + "Huge Restrictive " + displayName + " Item Pipe", + 0.875F, + aMaterial, + baseInvSlots * 4, + 819200 / baseInvSlots, + true).getStackForm(1L)); + } + + @SuppressWarnings("SameParameterValue") + private static void generateFluidPipes(Materials aMaterial, String name, int startID, int baseCapacity, + int heatCapacity, boolean gasProof) { + generateFluidPipes( + aMaterial, + name, + GT_LanguageManager.i18nPlaceholder ? "%material" : aMaterial.mDefaultLocalName, + startID, + baseCapacity, + heatCapacity, + gasProof); + } + + private static void generateFluidPipes(Materials aMaterial, String name, String displayName, int startID, + int baseCapacity, int heatCapacity, boolean gasProof) { + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeTiny.get(aMaterial), + new GT_MetaPipeEntity_Fluid( + startID, + "GT_Pipe_" + name + "_Tiny", + "Tiny " + displayName + " Fluid Pipe", + 0.25F, + aMaterial, + baseCapacity / 6, + heatCapacity, + gasProof).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeSmall.get(aMaterial), + new GT_MetaPipeEntity_Fluid( + startID + 1, + "GT_Pipe_" + name + "_Small", + "Small " + displayName + " Fluid Pipe", + 0.375F, + aMaterial, + baseCapacity / 3, + heatCapacity, + gasProof).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeMedium.get(aMaterial), + new GT_MetaPipeEntity_Fluid( + startID + 2, + "GT_Pipe_" + name, + displayName + " Fluid Pipe", + 0.5F, + aMaterial, + baseCapacity, + heatCapacity, + gasProof).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeLarge.get(aMaterial), + new GT_MetaPipeEntity_Fluid( + startID + 3, + "GT_Pipe_" + name + "_Large", + "Large " + displayName + " Fluid Pipe", + 0.75F, + aMaterial, + baseCapacity * 2, + heatCapacity, + gasProof).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeHuge.get(aMaterial), + new GT_MetaPipeEntity_Fluid( + startID + 4, + "GT_Pipe_" + name + "_Huge", + "Huge " + displayName + " Fluid Pipe", + 0.875F, + aMaterial, + baseCapacity * 4, + heatCapacity, + gasProof).getStackForm(1L)); + } + + @SuppressWarnings("SameParameterValue") + private static void generateFluidMultiPipes(Materials aMaterial, String name, int startID, int baseCapacity, + int heatCapacity, boolean gasProof) { + generateFluidMultiPipes(aMaterial, name, "%material", startID, baseCapacity, heatCapacity, gasProof); + } + + private static void generateFluidMultiPipes(Materials aMaterial, String name, String displayName, int startID, + int baseCapacity, int heatCapacity, boolean gasProof) { + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeQuadruple.get(aMaterial), + new GT_MetaPipeEntity_Fluid( + startID, + "GT_Pipe_" + name + "_Quadruple", + "Quadruple " + displayName + " Fluid Pipe", + 1.0F, + aMaterial, + baseCapacity, + heatCapacity, + gasProof, + 4).getStackForm(1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.pipeNonuple.get(aMaterial), + new GT_MetaPipeEntity_Fluid( + startID + 1, + "GT_Pipe_" + name + "_Nonuple", + "Nonuple " + displayName + " Fluid Pipe", + 1.0F, + aMaterial, + baseCapacity / 3, + heatCapacity, + gasProof, + 9).getStackForm(1L)); + } +} diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_MultiTileEntities.java b/src/main/java/gregtech/loaders/preload/GT_Loader_MultiTileEntities.java new file mode 100644 index 0000000000..fd290935df --- /dev/null +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_MultiTileEntities.java @@ -0,0 +1,1447 @@ +package gregtech.loaders.preload; + +import static gregtech.GT_Mod.GT_FML_LOGGER; +import static gregtech.api.multitileentity.enums.GT_MultiTileCasing.*; +import static gregtech.api.multitileentity.enums.GT_MultiTileComponentCasing.*; +import static gregtech.api.multitileentity.enums.GT_MultiTileUpgradeCasing.*; +import static gregtech.api.multitileentity.enums.GT_MultiTileUpgradeCasing.Insulator_OmegaType; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; + +import gregtech.api.enums.Materials; +import gregtech.api.multitileentity.MultiTileEntityBlock; +import gregtech.api.multitileentity.MultiTileEntityRegistry; +import gregtech.api.multitileentity.multiblock.base.WallShareablePart; +import gregtech.api.multitileentity.multiblock.casing.BasicCasing; +import gregtech.common.tileentities.casings.functional.Conveyor; +import gregtech.common.tileentities.casings.functional.Emitter; +import gregtech.common.tileentities.casings.functional.FieldGenerator; +import gregtech.common.tileentities.casings.functional.Motor; +import gregtech.common.tileentities.casings.functional.Piston; +import gregtech.common.tileentities.casings.functional.Pump; +import gregtech.common.tileentities.casings.functional.RobotArm; +import gregtech.common.tileentities.casings.functional.Sensor; +import gregtech.common.tileentities.casings.upgrade.Ampere; +import gregtech.common.tileentities.casings.upgrade.Cleanroom; +import gregtech.common.tileentities.casings.upgrade.Heater; +import gregtech.common.tileentities.casings.upgrade.Insulator; +import gregtech.common.tileentities.casings.upgrade.Inventory; +import gregtech.common.tileentities.casings.upgrade.Laser; +import gregtech.common.tileentities.casings.upgrade.Tank; +import gregtech.common.tileentities.casings.upgrade.Wireless; +import gregtech.common.tileentities.machines.multiblock.AdvChemicalProcessor; +import gregtech.common.tileentities.machines.multiblock.CokeOven; +import gregtech.common.tileentities.machines.multiblock.DistillationTower; +import gregtech.common.tileentities.machines.multiblock.LaserEngraver; +import gregtech.common.tileentities.machines.multiblock.LayeredCokeBattery; +import gregtech.common.tileentities.machines.multiblock.Macerator; + +public class GT_Loader_MultiTileEntities implements Runnable { + + public static final String COMPONENT_CASING_REGISTRY_NAME = "gt.multitileentity.component.casings"; + public static final String UPGRADE_CASING_REGISTRY_NAME = "gt.multitileentity.upgrade.casings"; + public static final String CASING_REGISTRY_NAME = "gt.multitileentity.casings"; + public static final String MACHINE_REGISTRY_NAME = "gt.multitileentity.controllers"; + public static final MultiTileEntityRegistry MACHINE_REGISTRY = new MultiTileEntityRegistry(MACHINE_REGISTRY_NAME); + public static final MultiTileEntityBlock MACHINE_BLOCK = MultiTileEntityBlock + .getOrCreate("GregTech", "machine", Material.iron, Block.soundTypeMetal, "wrench", 0, 0, 15, true, true); + public static final MultiTileEntityRegistry CASING_REGISTRY = new MultiTileEntityRegistry(CASING_REGISTRY_NAME); + public static final MultiTileEntityBlock CASING_BLOCK = MultiTileEntityBlock + .getOrCreate("GregTech", "casing", Material.iron, Block.soundTypeMetal, "wrench", 0, 0, 15, true, true); + public static final MultiTileEntityRegistry COMPONENT_CASING_REGISTRY = new MultiTileEntityRegistry( + COMPONENT_CASING_REGISTRY_NAME); + + public static final MultiTileEntityRegistry UPGRADE_CASING_REGISTRY = new MultiTileEntityRegistry( + UPGRADE_CASING_REGISTRY_NAME); + + public static final MultiTileEntityBlock COMPONENT_CASING_BLOCK = MultiTileEntityBlock.getOrCreate( + "GregTech", + "componentCasing", + Material.iron, + Block.soundTypeMetal, + "wrench", + 0, + 0, + 15, + true, + true); + + @Override + public void run() { + GT_FML_LOGGER.info("GT_Mod: Registering MultiTileEntities"); + registerMachines(); + registerCasings(); + registerComponentCasings(); + } + + private static void registerMachines() { + // Disable for now + MACHINE_REGISTRY.create(1000, Macerator.class) + .name("Large Macerator") + .category("Multiblock Controller") + .setBlock(MACHINE_BLOCK) + .material(Materials.Iron) + .textureFolder("macerator") + .tankCapacity(128000L) + .inputInventorySize(16) + .outputInventorySize(16) + .register(); + MACHINE_REGISTRY.create(0, CokeOven.class) + .name("Coke Oven") + .category("MultiblockController") + .setBlock(MACHINE_BLOCK) + .textureFolder("cokeOven") + .inputInventorySize(1) + .outputInventorySize(1) + .register(); + MACHINE_REGISTRY.create(1, AdvChemicalProcessor.class) + .name("Advanced Chemical Processor") + .category("MultiblockController") + .setBlock(MACHINE_BLOCK) + // TODO: Texture + .textureFolder("advChemicalProcessor") + .inputInventorySize(16) + .outputInventorySize(16) + .tankCapacity(128000L) + .register(); + MACHINE_REGISTRY.create(2, DistillationTower.class) + .name("Distillation Tower") + .category("MultiblockController") + .setBlock(MACHINE_BLOCK) + .textureFolder("distillationTower") + .inputInventorySize(16) + .outputInventorySize(16) + .tankCapacity(128000L) + .register(); + MACHINE_REGISTRY.create(3, LayeredCokeBattery.class) + .name("Layered Coke Battery") + .category("Multiblock Controller") + .setBlock(MACHINE_BLOCK) + .material(Materials.Iron) + .textureFolder("macerator") + .tankCapacity(128000L) + .inputInventorySize(16) + .outputInventorySize(16) + .register(); + MACHINE_REGISTRY.create(4, LaserEngraver.class) + .name("Big Laser Engraver") + .category("Multiblock Controller") + .setBlock(MACHINE_BLOCK) + .textureFolder("BigLaserEngraver") + .inputInventorySize(16) + .outputInventorySize(16) + .tankCapacity(128000L) + .register(); + } + + private static void registerCasings() { + + CASING_REGISTRY.create(CokeOven.getId(), WallShareablePart.class) + .name("Coke Oven Bricks") + .category("MultiBlock Casing") + .setBlock(CASING_BLOCK) + .textureFolder("cokeOven") + .register(); + CASING_REGISTRY.create(Chemical.getId(), BasicCasing.class) + .name("Chemical Casing") + .category("MultiBlock Casing") + .setBlock(CASING_BLOCK) + .textureFolder("advChemicalProcessor") + .register(); + CASING_REGISTRY.create(Distillation.getId(), BasicCasing.class) + .name("Distillation Casing") + .category("MultiBlock Casing") + .setBlock(CASING_BLOCK) + .textureFolder("distillationTower") + .register(); + CASING_REGISTRY.create(18000, BasicCasing.class) + .name("Test Casing") + .category("Multiblock Casing") + .setBlock(CASING_BLOCK) + .material(Materials.Cobalt) + .textureFolder("macerator") + .register(); + CASING_REGISTRY.create(LaserEngraver.getId(), BasicCasing.class) + .name("Laser Engraver Casing") + .category("MultiBlock Casing") + .setBlock(CASING_BLOCK) + .textureFolder("BigLaserEngraver") + .register(); + CASING_REGISTRY.create(Mirror.getId(), BasicCasing.class) + .name("Mirror") + .category("MultiBlock Casing") + .setBlock(CASING_BLOCK) + .textureFolder("Laserblock") + .register(); + CASING_REGISTRY.create(BlackLaserEngraverCasing.getId(), BasicCasing.class) + .name("Black Laser Engraver Casing") + .category("MultiBlock Casing") + .setBlock(CASING_BLOCK) + .textureFolder("BlackLaserEngraver") + .register(); + CASING_REGISTRY.create(LaserEngraverUpgrade1.getId(), BasicCasing.class) + .name("Crude Laser Engraving Casing") + .category("MultiBlock Casing") + .setBlock(CASING_BLOCK) + .textureFolder("laserengraverupgrade1") + .register(); + CASING_REGISTRY.create(LaserEngraverUpgrade2.getId(), BasicCasing.class) + .name("Advanced Laser Engraving Casing") + .category("MultiBlock Casing") + .setBlock(CASING_BLOCK) + .textureFolder("laserengraverupgrade2") + .register(); + CASING_REGISTRY.create(LaserEngraverUpgrade3.getId(), BasicCasing.class) + .name("Ultimate Laser Engraving Casing") + .category("MultiBlock Casing") + .setBlock(CASING_BLOCK) + .textureFolder("laserengraverupgrade3") + .register(); + CASING_REGISTRY.create(LaserEngraverUpgrade4.getId(), BasicCasing.class) + .name("Superb Laser Engraving Casing") + .category("MultiBlock Casing") + .setBlock(CASING_BLOCK) + .textureFolder("laserengraverupgrade4") + .register(); + + } + + private static void registerComponentCasings() { + + registerMotorCasings(); + registerPumpCasings(); + registerPistonCasings(); + registerRobotArmCasings(); + registerConveyorCasings(); + registerEmitterCasings(); + registerSensorCasings(); + registerFieldGeneratorCasings(); + + UPGRADE_CASING_REGISTRY.create(ULV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade ULV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(1) + .tier(0) + .register(); + UPGRADE_CASING_REGISTRY.create(LV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade LV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(4) + .tier(1) + .register(); + UPGRADE_CASING_REGISTRY.create(MV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade MV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(8) + .tier(2) + .register(); + UPGRADE_CASING_REGISTRY.create(HV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade HV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(16) + .tier(3) + .register(); + UPGRADE_CASING_REGISTRY.create(EV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade EV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(32) + .tier(4) + .register(); + UPGRADE_CASING_REGISTRY.create(IV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade IV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(64) + .tier(5) + .register(); + UPGRADE_CASING_REGISTRY.create(LuV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade LuV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(128) + .tier(6) + .register(); + UPGRADE_CASING_REGISTRY.create(ZPM_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade ZPM") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(256) + .tier(7) + .register(); + UPGRADE_CASING_REGISTRY.create(UV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade UV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(256) + .tier(8) + .register(); + UPGRADE_CASING_REGISTRY.create(UHV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade UHV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(256) + .tier(9) + .register(); + UPGRADE_CASING_REGISTRY.create(UEV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade UEV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(256) + .tier(10) + .register(); + UPGRADE_CASING_REGISTRY.create(UIV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade UIV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(256) + .tier(11) + .register(); + UPGRADE_CASING_REGISTRY.create(UMV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade UMV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(256) + .tier(12) + .register(); + UPGRADE_CASING_REGISTRY.create(UXV_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade UXV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(256) + .tier(13) + .register(); + UPGRADE_CASING_REGISTRY.create(MAX_Inventory.getId(), Inventory.class) + .name("Inventory Upgrade MAX") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("inventory") + .upgradeInventorySize(256) + .tier(14) + .register(); + + UPGRADE_CASING_REGISTRY.create(ULV_Tank.getId(), Tank.class) + .name("Tank Upgrade ULV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(8_000L) + .upgradeTankCount(1) + .tier(0) + .register(); + UPGRADE_CASING_REGISTRY.create(LV_Tank.getId(), Tank.class) + .name("Tank Upgrade LV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(16_000L) + .upgradeTankCount(2) + .tier(1) + .register(); + UPGRADE_CASING_REGISTRY.create(MV_Tank.getId(), Tank.class) + .name("Tank Upgrade MV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(32_000L) + .upgradeTankCount(4) + .tier(2) + .register(); + UPGRADE_CASING_REGISTRY.create(HV_Tank.getId(), Tank.class) + .name("Tank Upgrade HV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(64_000L) + .upgradeTankCount(6) + .tier(3) + .register(); + UPGRADE_CASING_REGISTRY.create(EV_Tank.getId(), Tank.class) + .name("Tank Upgrade EV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(128_000L) + .upgradeTankCount(8) + .tier(4) + .register(); + UPGRADE_CASING_REGISTRY.create(IV_Tank.getId(), Tank.class) + .name("Tank Upgrade IV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(256_000L) + .upgradeTankCount(10) + .tier(5) + .register(); + UPGRADE_CASING_REGISTRY.create(LuV_Tank.getId(), Tank.class) + .name("Tank Upgrade LuV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(512_000L) + .upgradeTankCount(12) + .tier(6) + .register(); + UPGRADE_CASING_REGISTRY.create(ZPM_Tank.getId(), Tank.class) + .name("Tank Upgrade ZPM") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(1_024_000L) + .upgradeTankCount(14) + .tier(7) + .register(); + UPGRADE_CASING_REGISTRY.create(UV_Tank.getId(), Tank.class) + .name("Tank Upgrade UV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(2_048_000L) + .upgradeTankCount(16) + .tier(8) + .register(); + UPGRADE_CASING_REGISTRY.create(UHV_Tank.getId(), Tank.class) + .name("Tank Upgrade UHV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(4_096_000L) + .upgradeTankCount(16) + .tier(9) + .register(); + UPGRADE_CASING_REGISTRY.create(UEV_Tank.getId(), Tank.class) + .name("Tank Upgrade UEV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(8_192_000L) + .upgradeTankCount(16) + .tier(10) + .register(); + UPGRADE_CASING_REGISTRY.create(UIV_Tank.getId(), Tank.class) + .name("Tank Upgrade UIV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(16_384_000L) + .upgradeTankCount(16) + .tier(11) + .register(); + UPGRADE_CASING_REGISTRY.create(UMV_Tank.getId(), Tank.class) + .name("Tank Upgrade UMV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(32_768_000L) + .upgradeTankCount(16) + .tier(12) + .register(); + UPGRADE_CASING_REGISTRY.create(UXV_Tank.getId(), Tank.class) + .name("Tank Upgrade UXV") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(65_536_000L) + .upgradeTankCount(16) + .tier(13) + .register(); + UPGRADE_CASING_REGISTRY.create(MAX_Tank.getId(), Tank.class) + .name("Tank Upgrade MAX") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("tank") + .upgradeTankCapacity(131_072_000L) + .upgradeTankCount(16) + .tier(14) + .register(); + + UPGRADE_CASING_REGISTRY.create(Amp_4.getId(), Ampere.class) + .name("Amperage Upgrade (4 A)") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("amperage") + .upgradeAmperage(4) + .tier(1) + .register(); + UPGRADE_CASING_REGISTRY.create(Amp_16.getId(), Ampere.class) + .name("Amperage Upgrade (16 A)") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("amperage") + .upgradeAmperage(16) + .tier(2) + .register(); + UPGRADE_CASING_REGISTRY.create(Amp_64.getId(), Ampere.class) + .name("Amperage Upgrade (64 A)") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("amperage") + .upgradeAmperage(64) + .tier(3) + .register(); + UPGRADE_CASING_REGISTRY.create(Amp_256.getId(), Ampere.class) + .name("Amperage Upgrade (256 A)") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("amperage") + .upgradeAmperage(256) + .tier(4) + .register(); + UPGRADE_CASING_REGISTRY.create(Amp_1_024.getId(), Ampere.class) + .name("Amperage Upgrade (1,024 A)") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("amperage") + .upgradeAmperage(1_024) + .tier(5) + .register(); + UPGRADE_CASING_REGISTRY.create(Amp_4_096.getId(), Ampere.class) + .name("Amperage Upgrade (4,096 A)") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("amperage") + .upgradeAmperage(4_096) + .tier(6) + .register(); + UPGRADE_CASING_REGISTRY.create(Amp_16_384.getId(), Ampere.class) + .name("Amperage Upgrade (16,384 A)") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("amperage") + .upgradeAmperage(16_384) + .tier(7) + .register(); + UPGRADE_CASING_REGISTRY.create(Amp_65_536.getId(), Ampere.class) + .name("Amperage Upgrade (65,536 A)") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("amperage") + .upgradeAmperage(65_536) + .tier(8) + .register(); + UPGRADE_CASING_REGISTRY.create(Amp_262_144.getId(), Ampere.class) + .name("Amperage Upgrade (262,144 A)") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("amperage") + .upgradeAmperage(262_144) + .tier(9) + .register(); + UPGRADE_CASING_REGISTRY.create(Amp_1_048_576.getId(), Ampere.class) + .name("Amperage Upgrade (1,048,576 A)") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("amperage") + .upgradeAmperage(1_048_576) + .tier(10) + .register(); + + UPGRADE_CASING_REGISTRY.create(Cleanroom.getId(), Cleanroom.class) + .name("Cleanroom Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("cleanroom") + .tier(1) + .register(); + UPGRADE_CASING_REGISTRY.create(Laser.getId(), Laser.class) + .name("Laser Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("laser") + .tier(8) + .register(); + UPGRADE_CASING_REGISTRY.create(Wireless.getId(), Wireless.class) + .name("Wireless Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("wireless") + .tier(11) + .register(); + + UPGRADE_CASING_REGISTRY.create(Heater_Prototype.getId(), Heater.class) + .name("Prototype Heater Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("heater") + .tier(1) + .register(); + UPGRADE_CASING_REGISTRY.create(Heater_IndustrialGrade.getId(), Heater.class) + .name("Industrial-Grade Heater Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("heater") + .tier(4) + .register(); + UPGRADE_CASING_REGISTRY.create(Heater_NextGen.getId(), Heater.class) + .name("Next-Gen Heater Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("heater") + .tier(7) + .register(); + UPGRADE_CASING_REGISTRY.create(Heater_Omnipotent.getId(), Heater.class) + .name("Omnipotent Heater Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("heater") + .tier(10) + .register(); + UPGRADE_CASING_REGISTRY.create(Heater_OmegaType.getId(), Heater.class) + .name("OMEGA-Type Heater Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("heater") + .tier(12) + .register(); + + UPGRADE_CASING_REGISTRY.create(Insulator_Prototype.getId(), Insulator.class) + .name("Prototype Insulator Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("insulator") + .tier(1) + .register(); + UPGRADE_CASING_REGISTRY.create(Insulator_IndustrialGrade.getId(), Insulator.class) + .name("Industrial-Grade Insulator Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("insulator") + .tier(4) + .register(); + UPGRADE_CASING_REGISTRY.create(Insulator_NextGen.getId(), Insulator.class) + .name("Next-Gen Insulator Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("insulator") + .tier(7) + .register(); + UPGRADE_CASING_REGISTRY.create(Insulator_Omnipotent.getId(), Insulator.class) + .name("Omnipotent Insulator Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("insulator") + .tier(10) + .register(); + UPGRADE_CASING_REGISTRY.create(Insulator_OmegaType.getId(), Insulator.class) + .name("OMEGA-Type Insulator Upgrade") + .category("MultiBlock Upgrade Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("insulator") + .tier(12) + .register(); + } + + private static void registerMotorCasings() { + COMPONENT_CASING_REGISTRY.create(LV_Motor.getId(), Motor.class) + .name("Motor Casing LV") + .tier(1) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(MV_Motor.getId(), Motor.class) + .name("Motor Casing MV") + .tier(2) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(HV_Motor.getId(), Motor.class) + .name("Motor Casing HV") + .tier(3) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(EV_Motor.getId(), Motor.class) + .name("Motor Casing EV") + .tier(4) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(IV_Motor.getId(), Motor.class) + .name("Motor Casing IV") + .tier(5) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(LuV_Motor.getId(), Motor.class) + .name("Motor Casing LuV") + .tier(6) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(ZPM_Motor.getId(), Motor.class) + .name("Motor Casing ZPM") + .tier(7) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(UV_Motor.getId(), Motor.class) + .name("Motor Casing UV") + .tier(8) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(UHV_Motor.getId(), Motor.class) + .name("Motor Casing UHV") + .tier(9) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(UEV_Motor.getId(), Motor.class) + .name("Motor Casing UEV") + .tier(10) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(UIV_Motor.getId(), Motor.class) + .name("Motor Casing UIV") + .tier(11) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(UMV_Motor.getId(), Motor.class) + .name("Motor Casing UMV") + .tier(12) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(UXV_Motor.getId(), Motor.class) + .name("Motor Casing UXV") + .tier(13) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + COMPONENT_CASING_REGISTRY.create(MAX_Motor.getId(), Motor.class) + .name("Motor Casing MAX") + .tier(14) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("motor") + .register(); + } + + private static void registerPumpCasings() { + COMPONENT_CASING_REGISTRY.create(LV_Pump.getId(), Pump.class) + .name("Pump Casing LV") + .tier(1) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(MV_Pump.getId(), Pump.class) + .name("Pump Casing MV") + .tier(2) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(HV_Pump.getId(), Pump.class) + .name("Pump Casing HV") + .tier(3) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(EV_Pump.getId(), Pump.class) + .name("Pump Casing EV") + .tier(4) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(IV_Pump.getId(), Pump.class) + .name("Pump Casing IV") + .tier(5) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(LuV_Pump.getId(), Pump.class) + .name("Pump Casing LuV") + .tier(6) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(LuV_Pump.getId(), Pump.class) + .name("Pump Casing LuV") + .tier(6) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(ZPM_Pump.getId(), Pump.class) + .name("Pump Casing ZPM") + .tier(7) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(UV_Pump.getId(), Pump.class) + .name("Pump Casing UV") + .tier(8) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(UHV_Pump.getId(), Pump.class) + .name("Pump Casing UHV") + .tier(9) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(UEV_Pump.getId(), Pump.class) + .name("Pump Casing UEV") + .tier(10) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(UIV_Pump.getId(), Pump.class) + .name("Pump Casing UIV") + .tier(11) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(UMV_Pump.getId(), Pump.class) + .name("Pump Casing UMV") + .tier(12) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(UXV_Pump.getId(), Pump.class) + .name("Pump Casing UXV") + .tier(13) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + COMPONENT_CASING_REGISTRY.create(MAX_Pump.getId(), Pump.class) + .name("Pump Casing MAX") + .tier(14) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("pump") + .register(); + } + + private static void registerPistonCasings() { + COMPONENT_CASING_REGISTRY.create(LV_Piston.getId(), Piston.class) + .name("Piston Casing LV") + .tier(1) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(MV_Piston.getId(), Piston.class) + .name("Piston Casing MV") + .tier(2) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(HV_Piston.getId(), Piston.class) + .name("Piston Casing HV") + .tier(3) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(EV_Piston.getId(), Piston.class) + .name("Piston Casing EV") + .tier(4) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(IV_Piston.getId(), Piston.class) + .name("Piston Casing IV") + .tier(5) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(LuV_Piston.getId(), Piston.class) + .name("Piston Casing LuV") + .tier(6) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(ZPM_Piston.getId(), Piston.class) + .name("Piston Casing ZPM") + .tier(7) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(UV_Piston.getId(), Piston.class) + .name("Piston Casing UV") + .tier(8) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(UHV_Piston.getId(), Piston.class) + .name("Piston Casing UHV") + .tier(9) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(UEV_Piston.getId(), Piston.class) + .name("Piston Casing UEV") + .tier(10) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(UIV_Piston.getId(), Piston.class) + .name("Piston Casing UIV") + .tier(11) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(UMV_Piston.getId(), Piston.class) + .name("Piston Casing UMV") + .tier(12) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(UXV_Piston.getId(), Piston.class) + .name("Piston Casing UXV") + .tier(13) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + COMPONENT_CASING_REGISTRY.create(MAX_Piston.getId(), Piston.class) + .name("Piston Casing MAX") + .tier(14) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("piston") + .register(); + } + + private static void registerConveyorCasings() { + COMPONENT_CASING_REGISTRY.create(LV_Conveyor.getId(), Conveyor.class) + .name("Conveyor Casing LV") + .tier(1) + .category("MultiBlock Structural Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("conveyor") + .register(); + COMPONENT_CASING_REGISTRY.create(MV_Conveyor.getId(), Conveyor.class) + .name("Conveyor Casing MV") + .tier(2) + .category("MultiBlock Structural Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("conveyor") + .register(); + COMPONENT_CASING_REGISTRY.create(HV_Conveyor.getId(), Conveyor.class) + .name("Conveyor Casing HV") + .tier(3) + .category("MultiBlock Structural Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("conveyor") + .register(); + COMPONENT_CASING_REGISTRY.create(EV_Conveyor.getId(), Conveyor.class) + .name("Conveyor Casing EV") + .tier(4) + .category("MultiBlock Structural Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("conveyor") + .register(); + COMPONENT_CASING_REGISTRY.create(IV_Conveyor.getId(), Conveyor.class) + .name("Conveyor Casing IV") + .tier(5) + .category("MultiBlock Structural Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("conveyor") + .register(); + COMPONENT_CASING_REGISTRY.create(LuV_Conveyor.getId(), Conveyor.class) + .name("Conveyor Casing LuV") + .tier(6) + .category("MultiBlock Structural Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("conveyor") + .register(); + COMPONENT_CASING_REGISTRY.create(ZPM_Conveyor.getId(), Conveyor.class) + .name("Conveyor Casing ZPM") + .tier(7) + .category("MultiBlock Structural Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("conveyor") + .register(); + COMPONENT_CASING_REGISTRY.create(UV_Conveyor.getId(), Conveyor.class) + .name("Conveyor Casing UV") + .tier(8) + .category("MultiBlock Structural Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("conveyor") + .register(); + COMPONENT_CASING_REGISTRY.create(UHV_Conveyor.getId(), Conveyor.class) + .name("Conveyor Casing UHV") + .tier(9) + .category("MultiBlock Structural Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("conveyor") + .register(); + COMPONENT_CASING_REGISTRY.create(UEV_Conveyor.getId(), Conveyor.class) + .name("Conveyor Casing UEV") + .tier(10) + .category("MultiBlock Structural Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("conveyor") + .register(); + COMPONENT_CASING_REGISTRY.create(UIV_Conveyor.getId(), Conveyor.class) + .name("Conveyor Casing UIV") + .tier(11) + .category("MultiBlock Structural Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("conveyor") + .register(); + } + + private static void registerRobotArmCasings() { + COMPONENT_CASING_REGISTRY.create(LV_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing LV") + .tier(1) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(MV_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing MV") + .tier(2) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(HV_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing HV") + .tier(3) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(EV_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing EV") + .tier(4) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(IV_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing IV") + .tier(5) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(LuV_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing LuV") + .tier(6) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(ZPM_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing ZPM") + .tier(7) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(UV_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing UV") + .tier(8) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(UHV_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing UHV") + .tier(9) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(UEV_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing UEV") + .tier(10) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(UIV_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing UIV") + .tier(11) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(UMV_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing UMV") + .tier(12) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(UXV_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing UXV") + .tier(13) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + COMPONENT_CASING_REGISTRY.create(MAX_RobotArm.getId(), RobotArm.class) + .name("Robot Arm Casing MAX") + .tier(14) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("robotArm") + .register(); + } + + private static void registerSensorCasings() { + COMPONENT_CASING_REGISTRY.create(LV_Sensor.getId(), Sensor.class) + .name("Sensor Casing LV") + .tier(1) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(MV_Sensor.getId(), Sensor.class) + .name("Sensor Casing MV") + .tier(2) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(HV_Sensor.getId(), Sensor.class) + .name("Sensor Casing HV") + .tier(3) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(EV_Sensor.getId(), Sensor.class) + .name("Sensor Casing EV") + .tier(4) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(IV_Sensor.getId(), Sensor.class) + .name("Sensor Casing IV") + .tier(5) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(LuV_Sensor.getId(), Sensor.class) + .name("Sensor Casing LuV") + .tier(6) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(ZPM_Sensor.getId(), Sensor.class) + .name("Sensor Casing ZPM") + .tier(7) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(UV_Sensor.getId(), Sensor.class) + .name("Sensor Casing UV") + .tier(8) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(UHV_Sensor.getId(), Sensor.class) + .name("Sensor Casing UHV") + .tier(9) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(UEV_Sensor.getId(), Sensor.class) + .name("Sensor Casing UEV") + .tier(10) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(UIV_Sensor.getId(), Sensor.class) + .name("Sensor Casing UIV") + .tier(11) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(UMV_Sensor.getId(), Sensor.class) + .name("Sensor Casing UMV") + .tier(12) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(UXV_Sensor.getId(), Sensor.class) + .name("Sensor Casing UXV") + .tier(13) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + COMPONENT_CASING_REGISTRY.create(MAX_Sensor.getId(), Sensor.class) + .name("Sensor Casing MAX") + .tier(14) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("sensor") + .register(); + } + + private static void registerEmitterCasings() { + COMPONENT_CASING_REGISTRY.create(LV_Emitter.getId(), Emitter.class) + .name("Emitter Casing LV") + .tier(1) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(MV_Emitter.getId(), Emitter.class) + .name("Emitter Casing MV") + .tier(2) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(HV_Emitter.getId(), Emitter.class) + .name("Emitter Casing HV") + .tier(3) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(EV_Emitter.getId(), Emitter.class) + .name("Emitter Casing EV") + .tier(4) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(IV_Emitter.getId(), Emitter.class) + .name("Emitter Casing IV") + .tier(5) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(LuV_Emitter.getId(), Emitter.class) + .name("Emitter Casing LuV") + .tier(6) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(ZPM_Emitter.getId(), Emitter.class) + .name("Emitter Casing ZPM") + .tier(7) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(UV_Emitter.getId(), Emitter.class) + .name("Emitter Casing UV") + .tier(8) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(UHV_Emitter.getId(), Emitter.class) + .name("Emitter Casing UHV") + .tier(9) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(UEV_Emitter.getId(), Emitter.class) + .name("Emitter Casing UEV") + .tier(10) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(UIV_Emitter.getId(), Emitter.class) + .name("Emitter Casing UIV") + .tier(11) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(UMV_Emitter.getId(), Emitter.class) + .name("Emitter Casing UMV") + .tier(12) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(UXV_Emitter.getId(), Emitter.class) + .name("Emitter Casing UXV") + .tier(13) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + COMPONENT_CASING_REGISTRY.create(MAX_Emitter.getId(), Emitter.class) + .name("Emitter Casing MAX") + .tier(14) + .category("MultiBlock Functional Casing") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("emitter") + .register(); + } + + private static void registerFieldGeneratorCasings() { + COMPONENT_CASING_REGISTRY.create(LV_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator LV") + .tier(1) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(MV_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator MV") + .tier(2) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(HV_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator HV") + .tier(3) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(EV_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator EV") + .tier(4) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(IV_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator IV") + .tier(5) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(LuV_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator LuV") + .tier(6) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(ZPM_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator ZPM") + .tier(7) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(UV_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator UV") + .tier(8) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(UHV_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator UHV") + .tier(9) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(UEV_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator UEV") + .tier(10) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(UIV_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator UIV") + .tier(11) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(UMV_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator UMV") + .tier(12) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(UXV_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator UXV") + .tier(13) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + COMPONENT_CASING_REGISTRY.create(MAX_FieldGenerator.getId(), FieldGenerator.class) + .name("Field Generator MAX") + .tier(14) + .category("Multiblock Energy Field") + .setBlock(COMPONENT_CASING_BLOCK) + .textureFolder("fieldGenerator") + .register(); + } +} diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_OreDictionary.java b/src/main/java/gregtech/loaders/preload/GT_Loader_OreDictionary.java new file mode 100644 index 0000000000..4d51c90cb5 --- /dev/null +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_OreDictionary.java @@ -0,0 +1,449 @@ +package gregtech.loaders.preload; + +import static gregtech.api.enums.Mods.AppliedEnergistics2; +import static gregtech.api.enums.Mods.Botania; +import static gregtech.api.enums.Mods.IndustrialCraft2; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.enums.Mods.Railcraft; +import static gregtech.api.enums.Mods.Thaumcraft; +import static gregtech.api.enums.Mods.TwilightForest; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsBotania; +import gregtech.api.enums.OreDictNames; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; + +public class GT_Loader_OreDictionary implements Runnable { + + @Override + public void run() { + GT_Log.out.println("GT_Mod: Register OreDict Entries of Non-GT-Items."); + GT_OreDictUnificator.set(OrePrefixes.cell, Materials.Empty, ItemList.Cell_Empty.get(1L)); + GT_OreDictUnificator.set(OrePrefixes.cell, Materials.Lava, ItemList.Cell_Lava.get(1L)); + GT_OreDictUnificator.set(OrePrefixes.cell, Materials.Lava, GT_ModHandler.getIC2Item("lavaCell", 1L)); + GT_OreDictUnificator.set(OrePrefixes.cell, Materials.Water, ItemList.Cell_Water.get(1L)); + GT_OreDictUnificator.set(OrePrefixes.cell, Materials.Water, GT_ModHandler.getIC2Item("waterCell", 1L)); + GT_OreDictUnificator.set( + OrePrefixes.cell, + Materials.Creosote, + GT_ModHandler.getModItem(Railcraft.ID, "fluid.creosote.cell", 1L)); + + GT_OreDictUnificator.set(OrePrefixes.cell, Materials.UUMatter, GT_ModHandler.getIC2Item("uuMatterCell", 1L)); + GT_OreDictUnificator.set(OrePrefixes.cell, Materials.ConstructionFoam, GT_ModHandler.getIC2Item("CFCell", 1L)); + + GT_OreDictUnificator.set(OrePrefixes.bucket, Materials.Empty, new ItemStack(Items.bucket, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.bucket, Materials.Water, new ItemStack(Items.water_bucket, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.bucket, Materials.Lava, new ItemStack(Items.lava_bucket, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.bucket, Materials.Milk, new ItemStack(Items.milk_bucket, 1, 0)); + // Clay buckets handled in gregtech.common.GT_Proxy.onLoad() as they aren't registered until Iguana Tweaks + // pre-init. + + GT_OreDictUnificator.set(OrePrefixes.bottle, Materials.Empty, new ItemStack(Items.glass_bottle, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.bottle, Materials.Water, new ItemStack(Items.potionitem, 1, 0)); + + GT_OreDictUnificator + .set(OrePrefixes.plateAlloy, Materials.Iridium, GT_ModHandler.getIC2Item("iridiumPlate", 1L)); + GT_OreDictUnificator + .set(OrePrefixes.plateAlloy, Materials.Advanced, GT_ModHandler.getIC2Item("advancedAlloy", 1L)); + GT_OreDictUnificator.set(OrePrefixes.plateAlloy, Materials.Carbon, GT_ModHandler.getIC2Item("carbonPlate", 1L)); + + GT_OreDictUnificator.set(OrePrefixes.ore, Materials.Coal, new ItemStack(Blocks.coal_ore, 1)); + GT_OreDictUnificator.set(OrePrefixes.ore, Materials.Iron, new ItemStack(Blocks.iron_ore, 1)); + GT_OreDictUnificator.set(OrePrefixes.ore, Materials.Lapis, new ItemStack(Blocks.lapis_ore, 1)); + GT_OreDictUnificator.set(OrePrefixes.ore, Materials.Redstone, new ItemStack(Blocks.redstone_ore, 1)); + GT_OreDictUnificator.set(OrePrefixes.ore, Materials.Redstone, new ItemStack(Blocks.lit_redstone_ore, 1)); + GT_OreDictUnificator.set(OrePrefixes.ore, Materials.Gold, new ItemStack(Blocks.gold_ore, 1)); + GT_OreDictUnificator.set(OrePrefixes.ore, Materials.Diamond, new ItemStack(Blocks.diamond_ore, 1)); + GT_OreDictUnificator.set(OrePrefixes.ore, Materials.Emerald, new ItemStack(Blocks.emerald_ore, 1)); + GT_OreDictUnificator.set(OrePrefixes.ore, Materials.NetherQuartz, new ItemStack(Blocks.quartz_ore, 1)); + GT_OreDictUnificator.set(OrePrefixes.ingot, Materials.Copper, GT_ModHandler.getIC2Item("copperIngot", 1L)); + GT_OreDictUnificator.set(OrePrefixes.ingot, Materials.Tin, GT_ModHandler.getIC2Item("tinIngot", 1L)); + GT_OreDictUnificator.set(OrePrefixes.ingot, Materials.Lead, GT_ModHandler.getIC2Item("leadIngot", 1L)); + GT_OreDictUnificator.set(OrePrefixes.ingot, Materials.Bronze, GT_ModHandler.getIC2Item("bronzeIngot", 1L)); + GT_OreDictUnificator.set(OrePrefixes.ingot, Materials.Silver, GT_ModHandler.getIC2Item("silverIngot", 1L)); + GT_OreDictUnificator.set(OrePrefixes.gem, Materials.Iridium, GT_ModHandler.getIC2Item("iridiumOre", 1L)); + GT_OreDictUnificator.set(OrePrefixes.gem, Materials.Lapis, new ItemStack(Items.dye, 1, 4)); + GT_OreDictUnificator.set(OrePrefixes.gem, Materials.EnderEye, new ItemStack(Items.ender_eye, 1)); + GT_OreDictUnificator.set(OrePrefixes.gem, Materials.EnderPearl, new ItemStack(Items.ender_pearl, 1)); + GT_OreDictUnificator.set(OrePrefixes.gem, Materials.Diamond, new ItemStack(Items.diamond, 1)); + GT_OreDictUnificator.set(OrePrefixes.gem, Materials.Emerald, new ItemStack(Items.emerald, 1)); + GT_OreDictUnificator.set(OrePrefixes.gem, Materials.Coal, new ItemStack(Items.coal, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.gem, Materials.Charcoal, new ItemStack(Items.coal, 1, 1)); + GT_OreDictUnificator.set(OrePrefixes.gem, Materials.NetherQuartz, new ItemStack(Items.quartz, 1)); + GT_OreDictUnificator.set(OrePrefixes.gem, Materials.NetherStar, new ItemStack(Items.nether_star, 1)); + GT_OreDictUnificator.set(OrePrefixes.nugget, Materials.Gold, new ItemStack(Items.gold_nugget, 1)); + GT_OreDictUnificator.set(OrePrefixes.ingot, Materials.Gold, new ItemStack(Items.gold_ingot, 1)); + GT_OreDictUnificator.set(OrePrefixes.ingot, Materials.Iron, new ItemStack(Items.iron_ingot, 1)); + GT_OreDictUnificator.set(OrePrefixes.plate, Materials.Paper, new ItemStack(Items.paper, 1)); + GT_OreDictUnificator.set(OrePrefixes.dust, Materials.Sugar, new ItemStack(Items.sugar, 1)); + GT_OreDictUnificator.set(OrePrefixes.dust, Materials.Bone, ItemList.Dye_Bonemeal.get(1L)); + GT_OreDictUnificator.set(OrePrefixes.stick, Materials.Wood, new ItemStack(Items.stick, 1)); + GT_OreDictUnificator.set(OrePrefixes.dust, Materials.Redstone, new ItemStack(Items.redstone, 1)); + GT_OreDictUnificator.set(OrePrefixes.dust, Materials.Gunpowder, new ItemStack(Items.gunpowder, 1)); + GT_OreDictUnificator.set(OrePrefixes.dust, Materials.Glowstone, new ItemStack(Items.glowstone_dust, 1)); + GT_OreDictUnificator.set(OrePrefixes.dust, Materials.Blaze, new ItemStack(Items.blaze_powder, 1)); + GT_OreDictUnificator.set(OrePrefixes.stick, Materials.Blaze, new ItemStack(Items.blaze_rod, 1)); + GT_OreDictUnificator.set(OrePrefixes.block, Materials.Iron, new ItemStack(Blocks.iron_block, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.block, Materials.Gold, new ItemStack(Blocks.gold_block, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.block, Materials.Diamond, new ItemStack(Blocks.diamond_block, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.block, Materials.Emerald, new ItemStack(Blocks.emerald_block, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.block, Materials.Lapis, new ItemStack(Blocks.lapis_block, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.block, Materials.Coal, new ItemStack(Blocks.coal_block, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.block, Materials.Redstone, new ItemStack(Blocks.redstone_block, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.block, Materials.NetherQuartz, new ItemStack(Blocks.quartz_block, 1, 0)); + GT_OreDictUnificator.set(OrePrefixes.block, Materials.Clay, new ItemStack(Blocks.clay, 1, 0)); + if (Blocks.ender_chest != null) { + GT_OreDictUnificator.registerOre(OreDictNames.enderChest, new ItemStack(Blocks.ender_chest, 1)); + } + GT_OreDictUnificator.registerOre(OreDictNames.craftingAnvil, new ItemStack(Blocks.anvil, 1)); + GT_OreDictUnificator + .registerOre(OreDictNames.craftingAnvil, GT_ModHandler.getModItem(Railcraft.ID, "anvil", 1L, 0)); + GT_OreDictUnificator + .registerOre(OreDictNames.craftingIndustrialDiamond, ItemList.IC2_Industrial_Diamond.get(1L)); + GT_OreDictUnificator + .registerOre(OrePrefixes.glass, Materials.Reinforced, GT_ModHandler.getIC2Item("reinforcedGlass", 1L)); + + GT_OreDictUnificator + .registerOre(OrePrefixes.stone, Materials.Basalt, GT_ModHandler.getModItem(Railcraft.ID, "cube", 1L, 6)); + GT_OreDictUnificator + .registerOre(OrePrefixes.stone, Materials.Marble, GT_ModHandler.getModItem(Railcraft.ID, "cube", 1L, 7)); + GT_OreDictUnificator.registerOre( + OrePrefixes.stone, + Materials.Basalt, + GT_ModHandler.getModItem(Railcraft.ID, "brick.abyssal", 1L, 32767)); + GT_OreDictUnificator.registerOre( + OrePrefixes.stone, + Materials.Marble, + GT_ModHandler.getModItem(Railcraft.ID, "brick.quarried", 1L, 32767)); + GT_OreDictUnificator + .registerOre(OrePrefixes.stone, Materials.Obsidian, new ItemStack(Blocks.obsidian, 1, 32767)); + GT_OreDictUnificator.registerOre(OrePrefixes.stone, Materials.Stone, new ItemStack(Blocks.stone, 1, 32767)); + GT_OreDictUnificator.registerOre(OrePrefixes.stoneMossy, new ItemStack(Blocks.mossy_cobblestone, 1, 32767)); + GT_OreDictUnificator.registerOre(OrePrefixes.stoneCobble, new ItemStack(Blocks.mossy_cobblestone, 1, 32767)); + GT_OreDictUnificator.registerOre(OrePrefixes.stoneCobble, new ItemStack(Blocks.cobblestone, 1, 32767)); + GT_OreDictUnificator.registerOre(OrePrefixes.stoneSmooth, new ItemStack(Blocks.stone, 1, 32767)); + GT_OreDictUnificator.registerOre(OrePrefixes.stoneBricks, new ItemStack(Blocks.stonebrick, 1, 32767)); + GT_OreDictUnificator.registerOre(OrePrefixes.stoneMossy, new ItemStack(Blocks.stonebrick, 1, 1)); + GT_OreDictUnificator.registerOre(OrePrefixes.stoneCracked, new ItemStack(Blocks.stonebrick, 1, 2)); + GT_OreDictUnificator.registerOre(OrePrefixes.stoneChiseled, new ItemStack(Blocks.stonebrick, 1, 3)); + GT_OreDictUnificator.registerOre(OrePrefixes.stone, Materials.Sand, new ItemStack(Blocks.sandstone, 1, 32767)); + GT_OreDictUnificator + .registerOre(OrePrefixes.stone, Materials.Netherrack, new ItemStack(Blocks.netherrack, 1, 32767)); + GT_OreDictUnificator + .registerOre(OrePrefixes.stone, Materials.NetherBrick, new ItemStack(Blocks.nether_brick, 1, 32767)); + GT_OreDictUnificator + .registerOre(OrePrefixes.stone, Materials.Endstone, new ItemStack(Blocks.end_stone, 1, 32767)); + GT_OreDictUnificator + .registerOre(OrePrefixes.stone, Materials.Glowstone, new ItemStack(Blocks.glowstone, 1, 32767)); + + GT_OreDictUnificator + .registerOre("paperResearchFragment", GT_ModHandler.getModItem(Thaumcraft.ID, "ItemResource", 1L, 9)); + GT_OreDictUnificator.registerOre( + "itemCertusQuartz", + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 1)); + GT_OreDictUnificator.registerOre( + "itemCertusQuartz", + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 10)); + GT_OreDictUnificator.registerOre( + "itemNetherQuartz", + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 11)); + GT_OreDictUnificator.registerOre( + OreDictNames.craftingQuartz, + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 1)); + GT_OreDictUnificator.registerOre( + OreDictNames.craftingQuartz, + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 10)); + GT_OreDictUnificator.registerOre( + OreDictNames.craftingQuartz, + GT_ModHandler.getModItem(AppliedEnergistics2.ID, "item.ItemMultiMaterial", 1L, 11)); + GT_OreDictUnificator.registerOre("cropLemon", ItemList.FR_Lemon.get(1L)); + GT_OreDictUnificator.registerOre("cropCoffee", ItemList.IC2_CoffeeBeans.get(1L)); + GT_OreDictUnificator.registerOre("cropPotato", ItemList.Food_Raw_Potato.get(1L)); + GT_OreDictUnificator + .registerOre(OrePrefixes.battery, Materials.Basic, GT_ModHandler.getIC2Item("reBattery", 1L)); + GT_OreDictUnificator + .registerOre(OrePrefixes.battery, Materials.Basic, GT_ModHandler.getIC2Item("chargedReBattery", 1L, 32767)); + GT_OreDictUnificator + .registerOre(OrePrefixes.battery, Materials.Advanced, GT_ModHandler.getIC2Item("advBattery", 1L, 32767)); + GT_OreDictUnificator + .registerOre(OrePrefixes.battery, Materials.Elite, GT_ModHandler.getIC2Item("energyCrystal", 1L, 32767)); + GT_OreDictUnificator + .registerOre(OrePrefixes.battery, Materials.Master, GT_ModHandler.getIC2Item("lapotronCrystal", 1L, 32767)); + + GT_OreDictUnificator + .registerOre(OreDictNames.craftingWireCopper, GT_ModHandler.getIC2Item("insulatedCopperCableItem", 1L)); + GT_OreDictUnificator + .registerOre(OreDictNames.craftingWireGold, GT_ModHandler.getIC2Item("insulatedGoldCableItem", 1L)); + GT_OreDictUnificator + .registerOre(OreDictNames.craftingWireIron, GT_ModHandler.getIC2Item("insulatedIronCableItem", 1L)); + GT_OreDictUnificator.registerOre( + OreDictNames.craftingWireTin, + GT_ModHandler + .getIC2Item("insulatedTinCableItem", 1L, GT_ModHandler.getIC2Item("insulatedCopperCableItem", 1L))); + + GT_OreDictUnificator + .registerOre(OreDictNames.craftingRedstoneTorch, new ItemStack(Blocks.redstone_torch, 1, 32767)); + GT_OreDictUnificator + .registerOre(OreDictNames.craftingRedstoneTorch, new ItemStack(Blocks.unlit_redstone_torch, 1, 32767)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingWorkBench, new ItemStack(Blocks.crafting_table, 1)); + GT_OreDictUnificator + .registerOre(OreDictNames.craftingWorkBench, new ItemStack(GregTech_API.sBlockMachines, 1, 16)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingPiston, new ItemStack(Blocks.piston, 1, 32767)); + GT_OreDictUnificator.registerOre(OreDictNames.craftingPiston, new ItemStack(Blocks.sticky_piston, 1, 32767)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingSafe, new ItemStack(GregTech_API.sBlockMachines, 1, 45)); + GT_OreDictUnificator.registerOre(OreDictNames.craftingSafe, GT_ModHandler.getIC2Item("personalSafe", 1L)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingChest, new ItemStack(Blocks.chest, 1, 32767)); + GT_OreDictUnificator.registerOre(OreDictNames.craftingChest, new ItemStack(Blocks.trapped_chest, 1, 32767)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingFurnace, new ItemStack(Blocks.furnace, 1, 32767)); + GT_OreDictUnificator.registerOre(OreDictNames.craftingFurnace, new ItemStack(Blocks.lit_furnace, 1, 32767)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingPump, GT_ModHandler.getIC2Item("pump", 1L)); + GT_OreDictUnificator + .registerOre(OreDictNames.craftingElectromagnet, GT_ModHandler.getIC2Item("magnetizer", 1L)); + GT_OreDictUnificator.registerOre(OreDictNames.craftingTeleporter, GT_ModHandler.getIC2Item("teleporter", 1L)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingMacerator, GT_ModHandler.getIC2Item("macerator", 1L)); + GT_OreDictUnificator + .registerOre(OreDictNames.craftingMacerator, new ItemStack(GregTech_API.sBlockMachines, 1, 50)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingExtractor, GT_ModHandler.getIC2Item("extractor", 1L)); + GT_OreDictUnificator + .registerOre(OreDictNames.craftingExtractor, new ItemStack(GregTech_API.sBlockMachines, 1, 51)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingCompressor, GT_ModHandler.getIC2Item("compressor", 1L)); + GT_OreDictUnificator + .registerOre(OreDictNames.craftingCompressor, new ItemStack(GregTech_API.sBlockMachines, 1, 52)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingRecycler, GT_ModHandler.getIC2Item("recycler", 1L)); + GT_OreDictUnificator + .registerOre(OreDictNames.craftingRecycler, new ItemStack(GregTech_API.sBlockMachines, 1, 53)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingIronFurnace, GT_ModHandler.getIC2Item("ironFurnace", 1L)); + + GT_OreDictUnificator + .registerOre(OreDictNames.craftingCentrifuge, new ItemStack(GregTech_API.sBlockMachines, 1, 62)); + + GT_OreDictUnificator + .registerOre(OreDictNames.craftingInductionFurnace, GT_ModHandler.getIC2Item("inductionFurnace", 1L)); + + GT_OreDictUnificator + .registerOre(OreDictNames.craftingElectricFurnace, GT_ModHandler.getIC2Item("electroFurnace", 1L)); + GT_OreDictUnificator + .registerOre(OreDictNames.craftingElectricFurnace, new ItemStack(GregTech_API.sBlockMachines, 1, 54)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingGenerator, GT_ModHandler.getIC2Item("generator", 1L)); + + GT_OreDictUnificator + .registerOre(OreDictNames.craftingGeothermalGenerator, GT_ModHandler.getIC2Item("geothermalGenerator", 1L)); + + GT_OreDictUnificator.registerOre(OreDictNames.craftingFeather, new ItemStack(Items.feather, 1, 32767)); + GT_OreDictUnificator.registerOre( + OreDictNames.craftingFeather, + GT_ModHandler.getModItem(TwilightForest.ID, "item.tfFeather", 1L, 32767)); + + GT_OreDictUnificator.registerOre("itemWheat", new ItemStack(Items.wheat, 1, 32767)); + GT_OreDictUnificator.registerOre("paperEmpty", new ItemStack(Items.paper, 1, 32767)); + GT_OreDictUnificator.registerOre("paperMap", new ItemStack(Items.map, 1, 32767)); + GT_OreDictUnificator.registerOre("paperMap", new ItemStack(Items.filled_map, 1, 32767)); + GT_OreDictUnificator.registerOre("bookEmpty", new ItemStack(Items.book, 1, 32767)); + GT_OreDictUnificator.registerOre("bookWritable", new ItemStack(Items.writable_book, 1, 32767)); + GT_OreDictUnificator.registerOre("bookWritten", new ItemStack(Items.written_book, 1, 32767)); + GT_OreDictUnificator.registerOre("bookEnchanted", new ItemStack(Items.enchanted_book, 1, 32767)); + GT_OreDictUnificator.registerOre(OreDictNames.craftingBook, new ItemStack(Items.book, 1, 32767)); + GT_OreDictUnificator.registerOre(OreDictNames.craftingBook, new ItemStack(Items.writable_book, 1, 32767)); + GT_OreDictUnificator.registerOre(OreDictNames.craftingBook, new ItemStack(Items.written_book, 1, 32767)); + GT_OreDictUnificator.registerOre(OreDictNames.craftingBook, new ItemStack(Items.enchanted_book, 1, 32767)); + + GT_OreDictUnificator + .registerOre(OrePrefixes.circuit, Materials.Basic, GT_ModHandler.getIC2Item("electronicCircuit", 1L)); + GT_OreDictUnificator + .registerOre(OrePrefixes.circuit, Materials.Advanced, GT_ModHandler.getIC2Item("advancedCircuit", 1L)); + + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Copper, + GT_ModHandler.getModItem(IndustrialCraft2.ID, "itemCasing", 1L, 0)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Tin, + GT_ModHandler.getModItem(IndustrialCraft2.ID, "itemCasing", 1L, 1)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Bronze, + GT_ModHandler.getModItem(IndustrialCraft2.ID, "itemCasing", 1L, 2)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Gold, + GT_ModHandler.getModItem(IndustrialCraft2.ID, "itemCasing", 1L, 3)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Iron, + GT_ModHandler.getModItem(IndustrialCraft2.ID, "itemCasing", 1L, 4)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Steel, + GT_ModHandler.getModItem(IndustrialCraft2.ID, "itemCasing", 1L, 5)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Lead, + GT_ModHandler.getModItem(IndustrialCraft2.ID, "itemCasing", 1L, 6)); + + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Osmium, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.OsmiumItemCasing", 1L, 0)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Aluminium, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.AluminiumItemCasing", 1L, 0)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.StainlessSteel, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.StainlessSteelItemCasing", 1L, 0)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Tungsten, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TungstenItemCasing", 1L, 0)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Neutronium, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.NeutroniumItemCasing", 1L, 0)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.TungstenSteel, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TungstenSteelItemCasing", 1L, 0)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Iridium, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.IridiumItemCasing", 1L, 0)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Titanium, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TitaniumItemCasing", 1L, 0)); + GT_OreDictUnificator.registerOre( + OrePrefixes.itemCasing, + Materials.Chrome, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.ChromeItemCasing", 1L, 0)); + + // Fake Circuits + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.Primitive, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitULV", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.Good, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitMV", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.Data, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitEV", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.Elite, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitIV", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.Master, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitLuV", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.Ultimate, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitZPM", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.SuperconductorUHV, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitUV", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.Infinite, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitUHV", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.Bio, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitUEV", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.Optical, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitUIV", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.Exotic, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitUMV", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.Cosmic, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitUXV", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.circuit, + Materials.Transcendent, + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CircuitMAX", 1L)); + + GT_OreDictUnificator.registerOre( + OrePrefixes.block, + MaterialsBotania.Manasteel, + GT_ModHandler.getModItem(Botania.ID, "storage", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.block, + MaterialsBotania.Terrasteel, + GT_ModHandler.getModItem(Botania.ID, "storage", 1L, 1)); + GT_OreDictUnificator.registerOre( + OrePrefixes.ingot, + MaterialsBotania.ElvenElementium, + GT_ModHandler.getModItem(Botania.ID, "manaResource", 1L, 7)); + GT_OreDictUnificator.registerOre( + OrePrefixes.nugget, + MaterialsBotania.ElvenElementium, + GT_ModHandler.getModItem(Botania.ID, "manaResource", 1L, 19)); + GT_OreDictUnificator.registerOre( + OrePrefixes.block, + MaterialsBotania.ElvenElementium, + GT_ModHandler.getModItem(Botania.ID, "storage", 1L, 2)); + GT_OreDictUnificator.registerOre( + OrePrefixes.block, + MaterialsBotania.Livingrock, + GT_ModHandler.getModItem(Botania.ID, "livingrock", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.ingot, + MaterialsBotania.GaiaSpirit, + GT_ModHandler.getModItem(Botania.ID, "manaResource", 1L, 14)); + GT_OreDictUnificator.registerOre( + OrePrefixes.block, + MaterialsBotania.Livingwood, + GT_ModHandler.getModItem(Botania.ID, "livingwood", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.block, + MaterialsBotania.Dreamwood, + GT_ModHandler.getModItem(Botania.ID, "dreamwood", 1L)); + GT_OreDictUnificator.registerOre( + OrePrefixes.gem, + MaterialsBotania.ManaDiamond, + GT_ModHandler.getModItem(Botania.ID, "manaResource", 1L, 2)); + GT_OreDictUnificator.registerOre( + OrePrefixes.block, + MaterialsBotania.ManaDiamond, + GT_ModHandler.getModItem(Botania.ID, "storage", 1L, 3)); + GT_OreDictUnificator.registerOre( + OrePrefixes.gem, + MaterialsBotania.BotaniaDragonstone, + GT_ModHandler.getModItem(Botania.ID, "manaResource", 1L, 9)); + GT_OreDictUnificator.registerOre( + OrePrefixes.block, + MaterialsBotania.BotaniaDragonstone, + GT_ModHandler.getModItem(Botania.ID, "storage", 1L, 4)); + } +} diff --git a/src/main/java/gregtech/loaders/preload/GT_Loader_OreProcessing.java b/src/main/java/gregtech/loaders/preload/GT_Loader_OreProcessing.java new file mode 100644 index 0000000000..116b6928e4 --- /dev/null +++ b/src/main/java/gregtech/loaders/preload/GT_Loader_OreProcessing.java @@ -0,0 +1,115 @@ +package gregtech.loaders.preload; + +import gregtech.api.util.GT_Log; +import gregtech.loaders.oreprocessing.ProcessingAll; +import gregtech.loaders.oreprocessing.ProcessingArrows; +import gregtech.loaders.oreprocessing.ProcessingBeans; +import gregtech.loaders.oreprocessing.ProcessingBlock; +import gregtech.loaders.oreprocessing.ProcessingBolt; +import gregtech.loaders.oreprocessing.ProcessingCell; +import gregtech.loaders.oreprocessing.ProcessingCircuit; +import gregtech.loaders.oreprocessing.ProcessingCompressed; +import gregtech.loaders.oreprocessing.ProcessingCrafting; +import gregtech.loaders.oreprocessing.ProcessingCrate; +import gregtech.loaders.oreprocessing.ProcessingCrop; +import gregtech.loaders.oreprocessing.ProcessingCrushedOre; +import gregtech.loaders.oreprocessing.ProcessingCrystallized; +import gregtech.loaders.oreprocessing.ProcessingDirty; +import gregtech.loaders.oreprocessing.ProcessingDust; +import gregtech.loaders.oreprocessing.ProcessingDye; +import gregtech.loaders.oreprocessing.ProcessingFineWire; +import gregtech.loaders.oreprocessing.ProcessingFoil; +import gregtech.loaders.oreprocessing.ProcessingFood; +import gregtech.loaders.oreprocessing.ProcessingGear; +import gregtech.loaders.oreprocessing.ProcessingGem; +import gregtech.loaders.oreprocessing.ProcessingIngot; +import gregtech.loaders.oreprocessing.ProcessingItem; +import gregtech.loaders.oreprocessing.ProcessingLens; +import gregtech.loaders.oreprocessing.ProcessingLog; +import gregtech.loaders.oreprocessing.ProcessingNugget; +import gregtech.loaders.oreprocessing.ProcessingOre; +import gregtech.loaders.oreprocessing.ProcessingOrePoor; +import gregtech.loaders.oreprocessing.ProcessingOreSmelting; +import gregtech.loaders.oreprocessing.ProcessingPipe; +import gregtech.loaders.oreprocessing.ProcessingPlank; +import gregtech.loaders.oreprocessing.ProcessingPlate; +import gregtech.loaders.oreprocessing.ProcessingPure; +import gregtech.loaders.oreprocessing.ProcessingRawOre; +import gregtech.loaders.oreprocessing.ProcessingRecycling; +import gregtech.loaders.oreprocessing.ProcessingRotor; +import gregtech.loaders.oreprocessing.ProcessingRound; +import gregtech.loaders.oreprocessing.ProcessingSand; +import gregtech.loaders.oreprocessing.ProcessingSaplings; +import gregtech.loaders.oreprocessing.ProcessingScrew; +import gregtech.loaders.oreprocessing.ProcessingShaping; +import gregtech.loaders.oreprocessing.ProcessingSlab; +import gregtech.loaders.oreprocessing.ProcessingStick; +import gregtech.loaders.oreprocessing.ProcessingStickLong; +import gregtech.loaders.oreprocessing.ProcessingStone; +import gregtech.loaders.oreprocessing.ProcessingStoneCobble; +import gregtech.loaders.oreprocessing.ProcessingStoneVarious; +import gregtech.loaders.oreprocessing.ProcessingToolHead; +import gregtech.loaders.oreprocessing.ProcessingToolOther; +import gregtech.loaders.oreprocessing.ProcessingTransforming; +import gregtech.loaders.oreprocessing.ProcessingWax; +import gregtech.loaders.oreprocessing.ProcessingWire; + +public class GT_Loader_OreProcessing implements Runnable { + + @Override + public void run() { + GT_Log.out.println("GT_Mod: Register Ore processing."); + new ProcessingAll(); + new ProcessingArrows(); + new ProcessingBeans(); + new ProcessingBlock(); + new ProcessingBolt(); + new ProcessingCell(); + new ProcessingCrate(); + new ProcessingCircuit(); + new ProcessingCompressed(); + new ProcessingCrafting(); + new ProcessingCrop(); + new ProcessingCrushedOre(); + new ProcessingCrystallized(); + new ProcessingDirty(); + new ProcessingDust(); + new ProcessingDye(); + new ProcessingFoil(); + new ProcessingFineWire(); + new ProcessingFood(); + new ProcessingLens(); + new ProcessingShaping(); + new ProcessingGem(); + new ProcessingGear(); + new ProcessingIngot(); + new ProcessingItem(); + new ProcessingLog(); + new ProcessingTransforming(); + new ProcessingNugget(); + new ProcessingOre(); + new ProcessingOrePoor(); + new ProcessingOreSmelting(); + new ProcessingRawOre(); + new ProcessingPipe(); + new ProcessingPlank(); + new ProcessingPlate(); + new ProcessingPure(); + new ProcessingRecycling(); + new ProcessingRound(); + new ProcessingRotor(); + new ProcessingSand(); + new ProcessingSaplings(); + new ProcessingScrew(); + new ProcessingSlab(); + new ProcessingStick(); + new ProcessingStickLong(); + new ProcessingStone(); + new ProcessingStoneCobble(); + new ProcessingStoneVarious(); + new ProcessingToolHead(); + new ProcessingToolOther(); + new ProcessingWax(); + new ProcessingWire(); + } +} diff --git a/src/main/java/gregtech/loaders/preload/GT_PreLoad.java b/src/main/java/gregtech/loaders/preload/GT_PreLoad.java new file mode 100644 index 0000000000..bbbb9af59d --- /dev/null +++ b/src/main/java/gregtech/loaders/preload/GT_PreLoad.java @@ -0,0 +1,967 @@ +package gregtech.loaders.preload; + +import static gregtech.GT_Mod.GT_FML_LOGGER; +import static gregtech.api.enums.Mods.Avaritia; +import static gregtech.api.enums.Mods.CraftTweaker; +import static gregtech.api.enums.Mods.EnderIO; +import static gregtech.api.enums.Mods.GTPlusPlus; +import static gregtech.api.enums.Mods.GalacticraftCore; +import static gregtech.api.enums.Mods.GregTech; +import static gregtech.api.enums.Mods.HodgePodge; +import static gregtech.api.enums.Mods.IndustrialCraft2Classic; +import static gregtech.api.enums.Mods.TinkerConstruct; +import static gregtech.api.enums.Mods.Translocator; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.PrintStream; +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Calendar; +import java.util.List; +import java.util.Objects; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import net.minecraft.client.Minecraft; +import net.minecraft.init.Blocks; +import net.minecraft.launchwrapper.Launch; +import net.minecraftforge.common.config.Configuration; + +import org.apache.commons.lang3.StringUtils; + +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.LoadController; +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.ModContainer; +import cpw.mods.fml.common.discovery.ASMDataTable; +import cpw.mods.fml.common.discovery.ModDiscoverer; +import gregtech.GT_Mod; +import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.Dyes; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.recipe.RecipeCategory; +import gregtech.api.recipe.RecipeCategoryHolder; +import gregtech.api.recipe.RecipeCategorySetting; +import gregtech.api.util.GT_Config; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_RecipeBuilder; +import gregtech.api.util.GT_Utility; +import gregtech.common.GT_Proxy; +import gregtech.common.tileentities.machines.long_distance.GT_MetaTileEntity_LongDistancePipelineBase; +import gregtech.common.tileentities.machines.multi.GT_MetaTileEntity_Cleanroom; + +public class GT_PreLoad { + + public static void sortToTheEnd() { + if (GT_Mod.gregtechproxy.mSortToTheEnd) { + try { + GT_FML_LOGGER.info("GT_Mod: Sorting GregTech to the end of the Mod List for further processing."); + LoadController tLoadController = (LoadController) GT_Utility + .getFieldContent(Loader.instance(), "modController", true, true); + assert tLoadController != null; + List<ModContainer> tModList = tLoadController.getActiveModList(); + List<ModContainer> tNewModsList = new ArrayList<>(); + ModContainer tGregTech = null; + short tModList_sS = (short) tModList.size(); + for (short i = 0; i < tModList_sS; i = (short) (i + 1)) { + ModContainer tMod = tModList.get(i); + if (tMod.getModId() + .equalsIgnoreCase(GregTech.ID)) { + tGregTech = tMod; + } else { + tNewModsList.add(tMod); + } + } + if (tGregTech != null) { + tNewModsList.add(tGregTech); + } + Objects.requireNonNull(GT_Utility.getField(tLoadController, "activeModList", true, true)) + .set(tLoadController, tNewModsList); + } catch (Throwable e) { + GT_Mod.logStackTrace(e); + } + } + } + + public static void initLocalization(File languageDir) { + GT_FML_LOGGER.info("GT_Mod: Generating Lang-File"); + + if (FMLCommonHandler.instance() + .getEffectiveSide() + .isClient()) { + String userLang = Minecraft.getMinecraft() + .getLanguageManager() + .getCurrentLanguage() + .getLanguageCode(); + GT_FML_LOGGER.info("User lang is " + userLang); + if (userLang.equals("en_US")) { + GT_FML_LOGGER.info("Loading GregTech.lang"); + GT_LanguageManager.isEN_US = true; + GT_LanguageManager.sEnglishFile = new Configuration(new File(languageDir, "GregTech.lang")); + } else { + String l10nFileName = "GregTech_" + userLang + ".lang"; + File l10nFile = new File(languageDir, l10nFileName); + if (l10nFile.isFile()) { + GT_FML_LOGGER.info("Loading l10n file: " + l10nFileName); + GT_LanguageManager.sEnglishFile = new Configuration(l10nFile); + } else { + GT_FML_LOGGER.info("Cannot find l10n file " + l10nFileName + ", fallback to GregTech.lang"); + GT_LanguageManager.isEN_US = true; + GT_LanguageManager.sEnglishFile = new Configuration(new File(languageDir, "GregTech.lang")); + } + } + } else { + GT_LanguageManager.isEN_US = true; + GT_LanguageManager.sEnglishFile = new Configuration(new File(languageDir, "GregTech.lang")); + } + GT_LanguageManager.sEnglishFile.load(); + + Materials.getMaterialsMap() + .values() + .parallelStream() + .filter(Objects::nonNull) + .forEach( + aMaterial -> aMaterial.mLocalizedName = GT_LanguageManager + .addStringLocalization("Material." + aMaterial.mName.toLowerCase(), aMaterial.mDefaultLocalName)); + } + + public static Configuration getConfiguration(File configDir) { + File tFile = new File(new File(configDir, "GregTech"), "GregTech.cfg"); + Configuration tMainConfig = new Configuration(tFile); + tMainConfig.load(); + tFile = new File(new File(configDir, "GregTech"), "IDs.cfg"); + GT_Config.sConfigFileIDs = new Configuration(tFile); + GT_Config.sConfigFileIDs.load(); + GT_Config.sConfigFileIDs.save(); + GregTech_API.sMachineFile = new GT_Config( + new Configuration(new File(new File(configDir, "GregTech"), "MachineStats.cfg"))); + GregTech_API.sWorldgenFile = new GT_Config( + new Configuration(new File(new File(configDir, "GregTech"), "WorldGeneration.cfg"))); + GregTech_API.sMaterialProperties = new GT_Config( + new Configuration(new File(new File(configDir, "GregTech"), "MaterialProperties.cfg"))); + GregTech_API.sUnification = new GT_Config( + new Configuration(new File(new File(configDir, "GregTech"), "Unification.cfg"))); + GregTech_API.sSpecialFile = new GT_Config( + new Configuration(new File(new File(configDir, "GregTech"), "Other.cfg"))); + GregTech_API.sOPStuff = new GT_Config( + new Configuration(new File(new File(configDir, "GregTech"), "OverpoweredStuff.cfg"))); + + GregTech_API.sClientDataFile = new GT_Config( + new Configuration(new File(new File(configDir, "GregTech"), "Client.cfg"))); + return tMainConfig; + } + + public static void initCompat() { + GregTech_API.mIC2Classic = IndustrialCraft2Classic.isModLoaded(); + GregTech_API.mGTPlusPlus = GTPlusPlus.isModLoaded(); + GregTech_API.mTranslocator = Translocator.isModLoaded(); + GregTech_API.mTConstruct = TinkerConstruct.isModLoaded(); + GregTech_API.mGalacticraft = GalacticraftCore.isModLoaded(); + GregTech_API.mHodgepodge = HodgePodge.isModLoaded(); + GregTech_API.mAvaritia = Avaritia.isModLoaded(); + } + + public static void createLogFiles(File parentFile, Configuration tMainConfig) { + GT_Log.mLogFile = new File(parentFile, "logs/GregTech.log"); + if (!GT_Log.mLogFile.exists()) { + try { + GT_Log.mLogFile.createNewFile(); + } catch (Throwable ignored) {} + } + try { + GT_Log.out = GT_Log.err = new PrintStream(GT_Log.mLogFile); + } catch (FileNotFoundException ignored) {} + + if (tMainConfig.get(GT_Mod.aTextGeneral, "LoggingOreDict", false) + .getBoolean(false)) { + GT_Log.mOreDictLogFile = new File(parentFile, "logs/OreDict.log"); + if (!GT_Log.mOreDictLogFile.exists()) { + try { + GT_Log.mOreDictLogFile.createNewFile(); + } catch (Throwable ignored) {} + } + List<String> tList = ((GT_Log.LogBuffer) GT_Log.ore).mBufferedOreDictLog; + try { + GT_Log.ore = new PrintStream(GT_Log.mOreDictLogFile); + } catch (Throwable ignored) {} + GT_Log.ore.println("******************************************************************************"); + GT_Log.ore.println("* This is the complete log of the GT5-Unofficial OreDictionary Handler. It *"); + GT_Log.ore.println("* processes all OreDictionary entries and can sometimes cause errors. All *"); + GT_Log.ore.println("* entries and errors are being logged. If you see an error please raise an *"); + GT_Log.ore.println("* issue at https://github.com/GTNewHorizons/GT-New-Horizons-Modpack/issues. *"); + GT_Log.ore.println("******************************************************************************"); + tList.forEach(GT_Log.ore::println); + } + if (tMainConfig.get(GT_Mod.aTextGeneral, "LoggingExplosions", true) + .getBoolean(true)) { + GT_Log.mExplosionLog = new File(parentFile, "logs/Explosion.log"); + if (!GT_Log.mExplosionLog.exists()) { + try { + GT_Log.mExplosionLog.createNewFile(); + } catch (Throwable ignored) {} + } + try { + GT_Log.exp = new PrintStream(GT_Log.mExplosionLog); + } catch (Throwable ignored) {} + } + + if (tMainConfig.get(GT_Mod.aTextGeneral, "LoggingPlayerActivity", true) + .getBoolean(true)) { + GT_Log.mPlayerActivityLogFile = new File(parentFile, "logs/PlayerActivity.log"); + if (!GT_Log.mPlayerActivityLogFile.exists()) { + try { + GT_Log.mPlayerActivityLogFile.createNewFile(); + } catch (Throwable ignored) {} + } + try { + GT_Log.pal = new PrintStream(GT_Log.mPlayerActivityLogFile); + } catch (Throwable ignored) {} + } + } + + public static void runMineTweakerCompat() { + if (!CraftTweaker.isModLoaded()) return; + + GT_FML_LOGGER.info("preReader"); + final List<String> oreTags = new ArrayList<>(); + final File globalDir = new File("scripts"); + if (globalDir.exists()) { + final List<String> scripts = new ArrayList<>(); + for (File file : Objects.requireNonNull(globalDir.listFiles())) { + if (file.getName() + .endsWith(".zs")) { + try (BufferedReader br = new BufferedReader(new FileReader(file))) { + String line; + while ((line = br.readLine()) != null) { + scripts.add(line); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + } + String pattern1 = "<"; + String pattern2 = ">"; + + Pattern p = Pattern.compile(Pattern.quote(pattern1) + "(.*?)" + Pattern.quote(pattern2)); + for (String text : scripts) { + Matcher m = p.matcher(text); + while (m.find()) { + String hit = m.group(1); + if (hit.startsWith("ore:")) { + hit = hit.substring(4); + if (!oreTags.contains(hit)) oreTags.add(hit); + } else if (hit.startsWith("gregtech:gt.metaitem.0")) { + hit = hit.substring(22); + int mIt = Integer.parseInt(hit.substring(0, 1)); + if (mIt > 0) { + int meta = 0; + try { + hit = hit.substring(2); + meta = Integer.parseInt(hit); + } catch (Exception e) { + GT_FML_LOGGER.info("parseError: " + hit); + } + if (meta > 0 && meta < 32000) { + int prefix = meta / 1000; + int material = meta % 1000; + String tag = ""; + String[] tags = new String[] {}; + if (mIt == 1) tags = new String[] { "dustTiny", "dustSmall", "dust", "dustImpure", + "dustPure", "crushed", "crushedPurified", "crushedCentrifuged", "gem", "nugget", + null, "ingot", "ingotHot", "ingotDouble", "ingotTriple", "ingotQuadruple", + "ingotQuintuple", "plate", "plateDouble", "plateTriple", "plateQuadruple", + "plateQuintuple", "plateDense", "stick", "lens", "round", "bolt", "screw", "ring", + "foil", "cell", "cellPlasma", "cellMolten", "rawOre" }; + if (mIt == 2) tags = new String[] { "toolHeadSword", "toolHeadPickaxe", + "toolHeadShovel", "toolHeadAxe", "toolHeadHoe", "toolHeadHammer", "toolHeadFile", + "toolHeadSaw", "toolHeadDrill", "toolHeadChainsaw", "toolHeadWrench", + "toolHeadUniversalSpade", "toolHeadSense", "toolHeadPlow", "toolHeadArrow", + "toolHeadBuzzSaw", "turbineBlade", null, null, "wireFine", "gearGtSmall", "rotor", + "stickLong", "springSmall", "spring", "arrowGtWood", "arrowGtPlastic", "gemChipped", + "gemFlawed", "gemFlawless", "gemExquisite", "gearGt" }; + if (mIt == 3) tags = new String[] { "crateGtDust", "crateGtIngot", "crateGtGem", + "crateGtPlate", "itemCasing", "nanite" }; + if (tags.length > prefix) tag = tags[prefix]; + if (GregTech_API.sGeneratedMaterials[material] != null) { + tag += GregTech_API.sGeneratedMaterials[material].mName; + if (!oreTags.contains(tag)) oreTags.add(tag); + } else if (material > 0) { + GT_FML_LOGGER.info("MaterialDisabled: " + material + " " + m.group(1)); + } + } + } + } + } + } + } + + final String[] preS = new String[] { "dustTiny", "dustSmall", "dust", "dustImpure", "dustPure", "crushed", + "crushedPurified", "crushedCentrifuged", "gem", "nugget", "ingot", "ingotHot", "ingotDouble", "ingotTriple", + "ingotQuadruple", "ingotQuintuple", "plate", "plateDouble", "plateTriple", "plateQuadruple", + "plateQuintuple", "plateDense", "stick", "lens", "round", "bolt", "screw", "ring", "foil", "cell", + "cellPlasma", "toolHeadSword", "toolHeadPickaxe", "toolHeadShovel", "toolHeadAxe", "toolHeadHoe", + "toolHeadHammer", "toolHeadFile", "toolHeadSaw", "toolHeadDrill", "toolHeadChainsaw", "toolHeadWrench", + "toolHeadUniversalSpade", "toolHeadSense", "toolHeadPlow", "toolHeadArrow", "toolHeadBuzzSaw", + "turbineBlade", "wireFine", "gearGtSmall", "rotor", "stickLong", "springSmall", "spring", "arrowGtWood", + "arrowGtPlastic", "gemChipped", "gemFlawed", "gemFlawless", "gemExquisite", "gearGt", "crateGtDust", + "crateGtIngot", "crateGtGem", "crateGtPlate", "nanite", "cellMolten", "rawOre" }; + + List<String> mMTTags = new ArrayList<>(); + oreTags.stream() + .filter(test -> StringUtils.startsWithAny(test, preS)) + .forEach(test -> { + mMTTags.add(test); + if (GT_Values.D1) GT_FML_LOGGER.info("oretag: " + test); + }); + + GT_FML_LOGGER.info("reenableMetaItems"); + + for (String reEnable : mMTTags) { + OrePrefixes tPrefix = OrePrefixes.getOrePrefix(reEnable); + if (tPrefix != null) { + Materials tName = Materials.get(reEnable.replaceFirst(tPrefix.toString(), "")); + if (tName != null) { + tPrefix.mDisabledItems.remove(tName); + tPrefix.mGeneratedItems.add(tName); + if (tPrefix == OrePrefixes.screw) { + OrePrefixes.bolt.mDisabledItems.remove(tName); + OrePrefixes.bolt.mGeneratedItems.add(tName); + OrePrefixes.stick.mDisabledItems.remove(tName); + OrePrefixes.stick.mGeneratedItems.add(tName); + } + if (tPrefix == OrePrefixes.round) { + OrePrefixes.nugget.mDisabledItems.remove(tName); + OrePrefixes.nugget.mGeneratedItems.add(tName); + } + if (tPrefix == OrePrefixes.spring) { + OrePrefixes.stickLong.mDisabledItems.remove(tName); + OrePrefixes.stickLong.mGeneratedItems.add(tName); + OrePrefixes.stick.mDisabledItems.remove(tName); + OrePrefixes.stick.mGeneratedItems.add(tName); + } + if (tPrefix == OrePrefixes.springSmall) { + OrePrefixes.stick.mDisabledItems.remove(tName); + OrePrefixes.stick.mGeneratedItems.add(tName); + } + if (tPrefix == OrePrefixes.stickLong) { + OrePrefixes.stick.mDisabledItems.remove(tName); + OrePrefixes.stick.mGeneratedItems.add(tName); + } + if (tPrefix == OrePrefixes.rotor) { + OrePrefixes.ring.mDisabledItems.remove(tName); + OrePrefixes.ring.mGeneratedItems.add(tName); + } + } else { + GT_FML_LOGGER.info("noMaterial " + reEnable); + } + } else { + GT_FML_LOGGER.info("noPrefix " + reEnable); + } + } + } + + public static void adjustScrap() { + GT_FML_LOGGER.info("GT_Mod: Removing all original Scrapbox Drops."); + try { + Objects.requireNonNull(GT_Utility.getField("ic2.core.item.ItemScrapbox$Drop", "topChance", true, true)) + .set(null, 0); + ((List<?>) Objects.requireNonNull( + GT_Utility.getFieldContent( + GT_Utility.getFieldContent("ic2.api.recipe.Recipes", "scrapboxDrops", true, true), + "drops", + true, + true))).clear(); + } catch (Throwable e) { + if (GT_Values.D1) { + e.printStackTrace(GT_Log.err); + } + } + GT_Log.out.println("GT_Mod: Adding Scrap with a Weight of 200.0F to the Scrapbox Drops."); + GT_ModHandler.addScrapboxDrop(200.0F, GT_ModHandler.getIC2Item("scrap", 1L)); + } + + public static void loadConfig(Configuration tMainConfig) { + GT_Values.D1 = tMainConfig.get(GT_Mod.aTextGeneral, "Debug", false) + .getBoolean(false); + GT_Values.D2 = tMainConfig.get(GT_Mod.aTextGeneral, "Debug2", false) + .getBoolean(false); + GT_Values.allow_broken_recipemap = tMainConfig.get(GT_Mod.aTextGeneral, "debug allow broken recipemap", false) + .getBoolean(false); + GT_Values.debugCleanroom = tMainConfig.get(GT_Mod.aTextGeneral, "debugCleanroom", false) + .getBoolean(false); + GT_Values.debugDriller = tMainConfig.get(GT_Mod.aTextGeneral, "debugDriller", false) + .getBoolean(false); + GT_Values.debugWorldGen = tMainConfig.get(GT_Mod.aTextGeneral, "debugWorldGen", false) + .getBoolean(false); + GT_Values.debugOrevein = tMainConfig.get(GT_Mod.aTextGeneral, "debugOrevein", false) + .getBoolean(false); + GT_Values.debugSmallOres = tMainConfig.get(GT_Mod.aTextGeneral, "debugSmallOres", false) + .getBoolean(false); + GT_Values.debugStones = tMainConfig.get(GT_Mod.aTextGeneral, "debugStones", false) + .getBoolean(false); + GT_Values.debugBlockMiner = tMainConfig.get(GT_Mod.aTextGeneral, "debugBlockMiner", false) + .getBoolean(false); + GT_Values.debugBlockPump = tMainConfig.get(GT_Mod.aTextGeneral, "debugBlockPump", false) + .getBoolean(false); + GT_Values.debugEntityCramming = tMainConfig.get(GT_Mod.aTextGeneral, "debugEntityCramming", false) + .getBoolean(false); + GT_Values.debugWorldData = tMainConfig.get(GT_Mod.aTextGeneral, "debugWorldData", false) + .getBoolean(false); + GT_Values.oreveinPercentage = tMainConfig.get(GT_Mod.aTextGeneral, "oreveinPercentage_100", 100) + .getInt(100); + GT_Values.oreveinAttempts = tMainConfig.get(GT_Mod.aTextGeneral, "oreveinAttempts_64", 64) + .getInt(64); + GT_Values.oreveinMaxPlacementAttempts = tMainConfig.get(GT_Mod.aTextGeneral, "oreveinMaxPlacementAttempts_8", 8) + .getInt(8); + GT_Values.oreveinPlacerOres = tMainConfig.get(GT_Mod.aTextGeneral, "oreveinPlacerOres", true) + .getBoolean(true); + GT_Values.oreveinPlacerOresMultiplier = tMainConfig.get(GT_Mod.aTextGeneral, "oreveinPlacerOresMultiplier", 2) + .getInt(2); + // GT_Values.oreveinMaxSize = tMainConfig.get(aTextGeneral, "oreveinMaxSize_64",64).getInt(64); + GT_Values.ticksBetweenSounds = tMainConfig.get("machines", "TicksBetweenSounds", 30) + .getInt(30); + GT_Values.cleanroomGlass = (float) tMainConfig.get("machines", "ReinforcedGlassPercentageForCleanroom", 5D) + .getDouble(5D); + GT_Values.enableChunkloaders = tMainConfig.get("machines", "enableChunkloaders", true) + .getBoolean(true); + GT_Values.alwaysReloadChunkloaders = tMainConfig.get("machines", "alwaysReloadChunkloaders", false) + .getBoolean(false); + GT_Values.debugChunkloaders = tMainConfig.get("machines", "debugChunkloaders", false) + .getBoolean(false); + GT_Values.disableDigitalChestsExternalAccess = tMainConfig + .get("machines", "disableDigitalChestsExternalAccess", false) + .getBoolean(false); + GT_Values.enableMultiTileEntities = tMainConfig.get( + "machines", + "enableMultiTileEntities", + false, + "This enabled MuTEs(multitile entities) to be added to the game. MuTEs are in the start of development and its not recommended to enable them unless you know what you are doing.") + .getBoolean(false) + // Make sure MuTEs are enabled in development + || (boolean) Launch.blackboard.get("fml.deobfuscatedEnvironment"); + GregTech_API.TICKS_FOR_LAG_AVERAGING = tMainConfig + .get(GT_Mod.aTextGeneral, "TicksForLagAveragingWithScanner", 25) + .getInt(25); + GregTech_API.MILLISECOND_THRESHOLD_UNTIL_LAG_WARNING = tMainConfig + .get(GT_Mod.aTextGeneral, "MillisecondsPassedInGTTileEntityUntilLagWarning", 100) + .getInt(100); + if (tMainConfig.get(GT_Mod.aTextGeneral, "disable_STDOUT", false) + .getBoolean(false)) { + GT_FML_LOGGER.info("Disableing Console Messages."); + GT_FML_LOGGER.exit(); + System.out.close(); + System.err.close(); + } + GregTech_API.sMachineExplosions = tMainConfig.get("machines", "machines_explosion_damage", true) + .getBoolean(false); + GregTech_API.sMachineFlammable = tMainConfig.get("machines", "machines_flammable", true) + .getBoolean(false); + GregTech_API.sMachineNonWrenchExplosions = tMainConfig.get("machines", "explosions_on_nonwrenching", true) + .getBoolean(false); + GregTech_API.sMachineWireFire = tMainConfig.get("machines", "wirefire_on_explosion", true) + .getBoolean(false); + GregTech_API.sMachineFireExplosions = tMainConfig.get("machines", "fire_causes_explosions", true) + .getBoolean(false); + GregTech_API.sMachineRainExplosions = tMainConfig.get("machines", "rain_causes_explosions", true) + .getBoolean(false); + GregTech_API.sMachineThunderExplosions = tMainConfig.get("machines", "lightning_causes_explosions", true) + .getBoolean(false); + GregTech_API.sConstantEnergy = tMainConfig.get("machines", "constant_need_of_energy", true) + .getBoolean(false); + GregTech_API.sColoredGUI = tMainConfig.get("machines", "colored_guis_when_painted", true) + .getBoolean(false); + GregTech_API.sMachineMetalGUI = tMainConfig.get("machines", "guis_in_consistent_machine_metal_color", false) + .getBoolean(false); + + // Implementation for this is actually handled in NewHorizonsCoreMod in MainRegistry.java! + GregTech_API.sUseMachineMetal = tMainConfig.get("machines", "use_machine_metal_tint", true) + .getBoolean(true); + + GregTech_API.sTimber = tMainConfig.get(GT_Mod.aTextGeneral, "timber_axe", true) + .getBoolean(true); + GregTech_API.sDrinksAlwaysDrinkable = tMainConfig.get(GT_Mod.aTextGeneral, "drinks_always_drinkable", false) + .getBoolean(false); + GregTech_API.sDoShowAllItemsInCreative = tMainConfig + .get(GT_Mod.aTextGeneral, "show_all_metaitems_in_creative_and_NEI", false) + .getBoolean(false); + GregTech_API.sMultiThreadedSounds = tMainConfig.get(GT_Mod.aTextGeneral, "sound_multi_threading", false) + .getBoolean(false); + + loadClientConfig(); + + GT_Mod.gregtechproxy.mMaxEqualEntitiesAtOneSpot = tMainConfig + .get(GT_Mod.aTextGeneral, "MaxEqualEntitiesAtOneSpot", 3) + .getInt(3); + GT_Mod.gregtechproxy.mSkeletonsShootGTArrows = tMainConfig + .get(GT_Mod.aTextGeneral, "SkeletonsShootGTArrows", 16) + .getInt(16); + GT_Mod.gregtechproxy.mFlintChance = tMainConfig.get(GT_Mod.aTextGeneral, "FlintAndSteelChance", 30) + .getInt(30); + GT_Mod.gregtechproxy.mItemDespawnTime = tMainConfig.get(GT_Mod.aTextGeneral, "ItemDespawnTime", 6000) + .getInt(6000); + GT_Mod.gregtechproxy.mAllowSmallBoilerAutomation = tMainConfig + .get(GT_Mod.aTextGeneral, "AllowSmallBoilerAutomation", false) + .getBoolean(false); + GT_Mod.gregtechproxy.mHardMachineCasings = tMainConfig.get(GT_Mod.aTextGeneral, "HardMachineCasings", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mDisableVanillaOres = tMainConfig.get(GT_Mod.aTextGeneral, "DisableVanillaOres", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mNerfDustCrafting = tMainConfig.get(GT_Mod.aTextGeneral, "NerfDustCrafting", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mIncreaseDungeonLoot = tMainConfig.get(GT_Mod.aTextGeneral, "IncreaseDungeonLoot", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mAxeWhenAdventure = tMainConfig.get(GT_Mod.aTextGeneral, "AdventureModeStartingAxe", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mHardcoreCables = tMainConfig.get(GT_Mod.aTextGeneral, "HardCoreCableLoss", false) + .getBoolean(false); + GT_Mod.gregtechproxy.mSurvivalIntoAdventure = tMainConfig.get(GT_Mod.aTextGeneral, "forceAdventureMode", false) + .getBoolean(false); + GT_Mod.gregtechproxy.mHungerEffect = tMainConfig.get(GT_Mod.aTextGeneral, "AFK_Hunger", false) + .getBoolean(false); + GT_Mod.gregtechproxy.mHardRock = tMainConfig.get(GT_Mod.aTextGeneral, "harderstone", false) + .getBoolean(false); + GT_Mod.gregtechproxy.mInventoryUnification = tMainConfig.get(GT_Mod.aTextGeneral, "InventoryUnification", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mGTBees = tMainConfig.get(GT_Mod.aTextGeneral, "GTBees", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mCraftingUnification = tMainConfig.get(GT_Mod.aTextGeneral, "CraftingUnification", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mNerfedWoodPlank = tMainConfig.get(GT_Mod.aTextGeneral, "WoodNeedsSawForCrafting", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mNerfedVanillaTools = tMainConfig + .get(GT_Mod.aTextGeneral, "smallerVanillaToolDurability", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mSortToTheEnd = tMainConfig.get(GT_Mod.aTextGeneral, "EnsureToBeLoadedLast", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mDisableIC2Cables = tMainConfig.get(GT_Mod.aTextGeneral, "DisableIC2Cables", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mAchievements = tMainConfig.get(GT_Mod.aTextGeneral, "EnableAchievements", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mNerfedCombs = tMainConfig.get(GT_Mod.aTextGeneral, "NerfCombs", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mNerfedCrops = tMainConfig.get(GT_Mod.aTextGeneral, "NerfCrops", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mHideUnusedOres = tMainConfig.get(GT_Mod.aTextGeneral, "HideUnusedOres", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mArcSmeltIntoAnnealed = tMainConfig + .get(GT_Mod.aTextGeneral, "ArcSmeltIntoAnnealedWrought", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mEnableAllMaterials = tMainConfig.get("general", "EnableAllMaterials", false) + .getBoolean(false); + + // Pollution: edit GT_Proxy.java to change default values + GT_Mod.gregtechproxy.mPollution = tMainConfig + .get("Pollution", "EnablePollution", GT_Mod.gregtechproxy.mPollution) + .getBoolean(GT_Mod.gregtechproxy.mPollution); + GT_Mod.gregtechproxy.mPollutionSmogLimit = tMainConfig + .get("Pollution", "SmogLimit", GT_Mod.gregtechproxy.mPollutionSmogLimit) + .getInt(GT_Mod.gregtechproxy.mPollutionSmogLimit); + GT_Mod.gregtechproxy.mPollutionPoisonLimit = tMainConfig + .get("Pollution", "PoisonLimit", GT_Mod.gregtechproxy.mPollutionPoisonLimit) + .getInt(GT_Mod.gregtechproxy.mPollutionPoisonLimit); + GT_Mod.gregtechproxy.mPollutionVegetationLimit = tMainConfig + .get("Pollution", "VegetationLimit", GT_Mod.gregtechproxy.mPollutionVegetationLimit) + .getInt(GT_Mod.gregtechproxy.mPollutionVegetationLimit); + GT_Mod.gregtechproxy.mPollutionSourRainLimit = tMainConfig + .get("Pollution", "SourRainLimit", GT_Mod.gregtechproxy.mPollutionSourRainLimit) + .getInt(GT_Mod.gregtechproxy.mPollutionSourRainLimit); + GT_Mod.gregtechproxy.mPollutionOnExplosion = tMainConfig + .get("Pollution", "SourRainLimit", GT_Mod.gregtechproxy.mPollutionOnExplosion) + .getInt(GT_Mod.gregtechproxy.mPollutionOnExplosion); + GT_Mod.gregtechproxy.mExplosionItemDrop = tMainConfig + .get("general", "ExplosionItemDrops", GT_Mod.gregtechproxy.mExplosionItemDrop) + .getBoolean(GT_Mod.gregtechproxy.mExplosionItemDrop); + GT_Mod.gregtechproxy.mPollutionPrimitveBlastFurnacePerSecond = tMainConfig + .get( + "Pollution", + "PollutionPrimitiveBlastFurnace", + GT_Mod.gregtechproxy.mPollutionPrimitveBlastFurnacePerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionPrimitveBlastFurnacePerSecond); + GT_Mod.gregtechproxy.mPollutionCharcoalPitPerSecond = tMainConfig + .get("Pollution", "PollutionCharcoalPit", GT_Mod.gregtechproxy.mPollutionCharcoalPitPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionCharcoalPitPerSecond); + GT_Mod.gregtechproxy.mPollutionEBFPerSecond = tMainConfig + .get("Pollution", "PollutionEBF", GT_Mod.gregtechproxy.mPollutionEBFPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionEBFPerSecond); + GT_Mod.gregtechproxy.mPollutionLargeCombustionEnginePerSecond = tMainConfig + .get( + "Pollution", + "PollutionLargeCombustionEngine", + GT_Mod.gregtechproxy.mPollutionLargeCombustionEnginePerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionLargeCombustionEnginePerSecond); + GT_Mod.gregtechproxy.mPollutionExtremeCombustionEnginePerSecond = tMainConfig + .get( + "Pollution", + "PollutionExtremeCombustionEngine", + GT_Mod.gregtechproxy.mPollutionExtremeCombustionEnginePerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionExtremeCombustionEnginePerSecond); + GT_Mod.gregtechproxy.mPollutionImplosionCompressorPerSecond = tMainConfig + .get( + "Pollution", + "PollutionImplosionCompressor", + GT_Mod.gregtechproxy.mPollutionImplosionCompressorPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionImplosionCompressorPerSecond); + GT_Mod.gregtechproxy.mPollutionLargeBronzeBoilerPerSecond = tMainConfig + .get("Pollution", "PollutionLargeBronzeBoiler", GT_Mod.gregtechproxy.mPollutionLargeBronzeBoilerPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionLargeBronzeBoilerPerSecond); + GT_Mod.gregtechproxy.mPollutionLargeSteelBoilerPerSecond = tMainConfig + .get("Pollution", "PollutionLargeSteelBoiler", GT_Mod.gregtechproxy.mPollutionLargeSteelBoilerPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionLargeSteelBoilerPerSecond); + GT_Mod.gregtechproxy.mPollutionLargeTitaniumBoilerPerSecond = tMainConfig + .get( + "Pollution", + "PollutionLargeTitaniumBoiler", + GT_Mod.gregtechproxy.mPollutionLargeTitaniumBoilerPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionLargeTitaniumBoilerPerSecond); + GT_Mod.gregtechproxy.mPollutionLargeTungstenSteelBoilerPerSecond = tMainConfig + .get( + "Pollution", + "PollutionLargeTungstenSteelBoiler", + GT_Mod.gregtechproxy.mPollutionLargeTungstenSteelBoilerPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionLargeTungstenSteelBoilerPerSecond); + GT_Mod.gregtechproxy.mPollutionReleasedByThrottle = tMainConfig + .get("Pollution", "PollutionReleasedByThrottle", GT_Mod.gregtechproxy.mPollutionReleasedByThrottle) + .getDouble(GT_Mod.gregtechproxy.mPollutionReleasedByThrottle); + GT_Mod.gregtechproxy.mPollutionLargeGasTurbinePerSecond = tMainConfig + .get("Pollution", "PollutionLargeGasTurbine", GT_Mod.gregtechproxy.mPollutionLargeGasTurbinePerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionLargeGasTurbinePerSecond); + GT_Mod.gregtechproxy.mPollutionMultiSmelterPerSecond = tMainConfig + .get("Pollution", "PollutionMultiSmelter", GT_Mod.gregtechproxy.mPollutionMultiSmelterPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionMultiSmelterPerSecond); + GT_Mod.gregtechproxy.mPollutionPyrolyseOvenPerSecond = tMainConfig + .get("Pollution", "PollutionPyrolyseOven", GT_Mod.gregtechproxy.mPollutionPyrolyseOvenPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionPyrolyseOvenPerSecond); + GT_Mod.gregtechproxy.mPollutionSmallCoalBoilerPerSecond = tMainConfig + .get("Pollution", "PollutionSmallCoalBoiler", GT_Mod.gregtechproxy.mPollutionSmallCoalBoilerPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionSmallCoalBoilerPerSecond); + GT_Mod.gregtechproxy.mPollutionHighPressureLavaBoilerPerSecond = tMainConfig + .get( + "Pollution", + "PollutionHighPressureLavaBoiler", + GT_Mod.gregtechproxy.mPollutionHighPressureLavaBoilerPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionHighPressureLavaBoilerPerSecond); + GT_Mod.gregtechproxy.mPollutionHighPressureCoalBoilerPerSecond = tMainConfig + .get( + "Pollution", + "PollutionHighPressureCoalBoiler", + GT_Mod.gregtechproxy.mPollutionHighPressureCoalBoilerPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionHighPressureCoalBoilerPerSecond); + GT_Mod.gregtechproxy.mPollutionBaseDieselGeneratorPerSecond = tMainConfig + .get( + "Pollution", + "PollutionBaseDieselGenerator", + GT_Mod.gregtechproxy.mPollutionBaseDieselGeneratorPerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionBaseDieselGeneratorPerSecond); + double[] mPollutionDieselGeneratorReleasedByTier = tMainConfig + .get( + "Pollution", + "PollutionReleasedByTierDieselGenerator", + GT_Mod.gregtechproxy.mPollutionDieselGeneratorReleasedByTier) + .getDoubleList(); + if (mPollutionDieselGeneratorReleasedByTier.length + == GT_Mod.gregtechproxy.mPollutionDieselGeneratorReleasedByTier.length) { + GT_Mod.gregtechproxy.mPollutionDieselGeneratorReleasedByTier = mPollutionDieselGeneratorReleasedByTier; + } else { + GT_FML_LOGGER + .error("The Length of the Diesel Turbine Pollution Array Config must be the same as the Default"); + } + GT_Mod.gregtechproxy.mPollutionBaseGasTurbinePerSecond = tMainConfig + .get( + "Pollution", + "PollutionBaseGasTurbineGenerator", + GT_Mod.gregtechproxy.mPollutionBaseGasTurbinePerSecond) + .getInt(GT_Mod.gregtechproxy.mPollutionBaseGasTurbinePerSecond); + double[] mPollutionGasTurbineReleasedByTier = tMainConfig + .get( + "Pollution", + "PollutionReleasedByTierGasTurbineGenerator", + GT_Mod.gregtechproxy.mPollutionGasTurbineReleasedByTier) + .getDoubleList(); + if (mPollutionGasTurbineReleasedByTier.length + == GT_Mod.gregtechproxy.mPollutionGasTurbineReleasedByTier.length) { + GT_Mod.gregtechproxy.mPollutionGasTurbineReleasedByTier = mPollutionGasTurbineReleasedByTier; + } else { + GT_FML_LOGGER.error("The Length of the Gas Turbine Pollution Array Config must be the same as the Default"); + } + + GT_Mod.gregtechproxy.mUndergroundOil.getConfig(tMainConfig, "undergroundfluid"); + GT_Mod.gregtechproxy.enableUndergroundGravelGen = GregTech_API.sWorldgenFile + .get("general", "enableUndergroundGravelGen", GT_Mod.gregtechproxy.enableUndergroundGravelGen); + GT_Mod.gregtechproxy.enableUndergroundDirtGen = GregTech_API.sWorldgenFile + .get("general", "enableUndergroundDirtGen", GT_Mod.gregtechproxy.enableUndergroundDirtGen); + GT_Mod.gregtechproxy.mEnableCleanroom = tMainConfig.get("general", "EnableCleanroom", true) + .getBoolean(true); + if (GT_Mod.gregtechproxy.mEnableCleanroom) GT_MetaTileEntity_Cleanroom.loadConfig(tMainConfig); + GT_Mod.gregtechproxy.mLowGravProcessing = GalacticraftCore.isModLoaded() + && tMainConfig.get("general", "LowGravProcessing", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mUseGreatlyShrukenReplacementList = tMainConfig + .get("general", "GTNH Optimised Material Loading", true) + .getBoolean(true); + Calendar now = Calendar.getInstance(); + GT_Mod.gregtechproxy.mAprilFool = GregTech_API.sSpecialFile.get( + ConfigCategories.general, + "AprilFool", + now.get(Calendar.MONTH) == Calendar.APRIL && now.get(Calendar.DAY_OF_MONTH) == 1); + GT_Mod.gregtechproxy.mCropNeedBlock = tMainConfig.get("general", "CropNeedBlockBelow", true) + .getBoolean(true); + GT_Mod.gregtechproxy.mAMHInteraction = tMainConfig.get("general", "AllowAutoMaintenanceHatchInteraction", false) + .getBoolean(false); + GregTech_API.mOutputRF = GregTech_API.sOPStuff.get(ConfigCategories.general, "OutputRF", true); + GregTech_API.mInputRF = GregTech_API.sOPStuff.get(ConfigCategories.general, "InputRF", false); + GregTech_API.mEUtoRF = GregTech_API.sOPStuff.get(ConfigCategories.general, "100EUtoRF", 360); + GregTech_API.mRFtoEU = GregTech_API.sOPStuff.get(ConfigCategories.general, "100RFtoEU", 20); + GregTech_API.mRFExplosions = GregTech_API.sOPStuff.get(ConfigCategories.general, "RFExplosions", false); + GregTech_API.meIOLoaded = EnderIO.isModLoaded(); + GT_Mod.gregtechproxy.mForceFreeFace = GregTech_API.sMachineFile + .get(ConfigCategories.machineconfig, "forceFreeFace", true); + GT_Mod.gregtechproxy.mBrickedBlastFurnace = tMainConfig.get("general", "BrickedBlastFurnace", true) + .getBoolean(true); + + GT_Mod.gregtechproxy.mMixedOreOnlyYieldsTwoThirdsOfPureOre = tMainConfig + .get("general", "MixedOreOnlyYieldsTwoThirdsOfPureOre", false) + .getBoolean(false); + GT_Mod.gregtechproxy.mRichOreYieldMultiplier = tMainConfig.get("general", "RichOreYieldMultiplier", true) + .getBoolean(false); + GT_Mod.gregtechproxy.mNetherOreYieldMultiplier = tMainConfig.get("general", "NetherOreYieldMultiplier", true) + .getBoolean(false); + GT_Mod.gregtechproxy.mEndOreYieldMultiplier = tMainConfig.get("general", "EndOreYieldMultiplier", true) + .getBoolean(false); + GT_Mod.gregtechproxy.enableBlackGraniteOres = GregTech_API.sWorldgenFile + .get("general", "enableBlackGraniteOres", GT_Mod.gregtechproxy.enableBlackGraniteOres); + GT_Mod.gregtechproxy.enableRedGraniteOres = GregTech_API.sWorldgenFile + .get("general", "enableRedGraniteOres", GT_Mod.gregtechproxy.enableRedGraniteOres); + GT_Mod.gregtechproxy.enableMarbleOres = GregTech_API.sWorldgenFile + .get("general", "enableMarbleOres", GT_Mod.gregtechproxy.enableMarbleOres); + GT_Mod.gregtechproxy.enableBasaltOres = GregTech_API.sWorldgenFile + .get("general", "enableBasaltOres", GT_Mod.gregtechproxy.enableBasaltOres); + GT_Mod.gregtechproxy.gt6Pipe = tMainConfig.get("general", "GT6StyledPipesConnection", true) + .getBoolean(true); + GT_Mod.gregtechproxy.gt6Cable = tMainConfig.get("general", "GT6StyledWiresConnection", true) + .getBoolean(true); + GT_Mod.gregtechproxy.ic2EnergySourceCompat = tMainConfig.get("general", "Ic2EnergySourceCompat", true) + .getBoolean(true); + GT_Mod.gregtechproxy.costlyCableConnection = tMainConfig + .get("general", "CableConnectionRequiresSolderingMaterial", false) + .getBoolean(false); + GT_Mod.gregtechproxy.crashOnNullRecipeInput = tMainConfig.get("general", "crashOnNullRecipeInput", false) + .getBoolean(false); + GT_LanguageManager.i18nPlaceholder = tMainConfig + .get("general", "EnablePlaceholderForMaterialNamesInLangFile", true) + .getBoolean(true); + GT_MetaTileEntity_LongDistancePipelineBase.minimalDistancePoints = tMainConfig + .get("general", "LongDistancePipelineMinimalDistancePoints", 64) + .getInt(64); + try { + String setting_string = tMainConfig.get( + "OreDropBehaviour", + "general", + "FortuneItem", + "Settings: \n'PerDimBlock': Sets the drop to the block variant of the ore block based on dimension, defaults to stone type, \n'UnifiedBlock': Sets the drop to the stone variant of the ore block, \n'Block': Sets the drop to the ore mined, \n'FortuneItem': Sets the drop to the new ore item and makes it affected by fortune, \n'Item': Sets the drop to the new ore item, \nDefaults to: 'FortuneItem'") + .getString(); + GT_Log.out.println("Trying to set it to: " + setting_string); + GT_Proxy.OreDropSystem setting = GT_Proxy.OreDropSystem.valueOf(setting_string); + GT_Mod.gregtechproxy.oreDropSystem = setting; + + } catch (IllegalArgumentException e) { + GT_Log.err.println(e); + GT_Mod.gregtechproxy.oreDropSystem = GT_Proxy.OreDropSystem.FortuneItem; + } + + GT_Mod.gregtechproxy.mChangeHarvestLevels = GregTech_API.sMaterialProperties + .get("havestLevel", "activateHarvestLevelChange", false); // TODO CHECK + if (GT_Mod.gregtechproxy.mChangeHarvestLevels) { + GT_Mod.gregtechproxy.mGraniteHavestLevel = GregTech_API.sMaterialProperties + .get("havestLevel", "graniteHarvestLevel", 3); + GT_Mod.gregtechproxy.mMaxHarvestLevel = Math + .min(15, GregTech_API.sMaterialProperties.get("havestLevel", "maxLevel", 7)); + Materials.getMaterialsMap() + .values() + .parallelStream() + .filter( + tMaterial -> tMaterial != null && tMaterial.mToolQuality > 0 + && tMaterial.mMetaItemSubID < GT_Mod.gregtechproxy.mHarvestLevel.length + && tMaterial.mMetaItemSubID >= 0) + .forEach( + tMaterial -> GT_Mod.gregtechproxy.mHarvestLevel[tMaterial.mMetaItemSubID] = GregTech_API.sMaterialProperties + .get("materialHavestLevel", tMaterial.mDefaultLocalName, tMaterial.mToolQuality)); + } + + if (tMainConfig.get("general", "hardermobspawners", true) + .getBoolean(true)) { + Blocks.mob_spawner.setHardness(500.0F) + .setResistance(6000000.0F); + } + GT_Mod.gregtechproxy.mOnline = tMainConfig.get(GT_Mod.aTextGeneral, "online", true) + .getBoolean(false); + + GT_Mod.gregtechproxy.mUpgradeCount = Math.min( + 64, + Math.max( + 1, + tMainConfig.get("features", "UpgradeStacksize", 4) + .getInt())); + for (OrePrefixes tPrefix : OrePrefixes.values()) { + if (tPrefix.mIsUsedForOreProcessing) { + tPrefix.mDefaultStackSize = ((byte) Math.min( + 64, + Math.max( + 1, + tMainConfig.get("features", "MaxOreStackSize", 64) + .getInt()))); + } else if (tPrefix == OrePrefixes.plank) { + tPrefix.mDefaultStackSize = ((byte) Math.min( + 64, + Math.max( + 16, + tMainConfig.get("features", "MaxPlankStackSize", 64) + .getInt()))); + } else if ((tPrefix == OrePrefixes.wood) || (tPrefix == OrePrefixes.treeLeaves) + || (tPrefix == OrePrefixes.treeSapling) + || (tPrefix == OrePrefixes.log)) { + tPrefix.mDefaultStackSize = ((byte) Math.min( + 64, + Math.max( + 16, + tMainConfig.get("features", "MaxLogStackSize", 64) + .getInt()))); + } else if (tPrefix.mIsUsedForBlocks) { + tPrefix.mDefaultStackSize = ((byte) Math.min( + 64, + Math.max( + 16, + tMainConfig.get("features", "MaxOtherBlockStackSize", 64) + .getInt()))); + } + } + + GT_Values.mCTMEnabledBlock + .addAll( + Arrays + .asList( + tMainConfig + .get( + "general", + "ctm_block_whitelist", + new String[] { "team.chisel.block.BlockCarvable", + "team.chisel.block.BlockCarvableGlass" }) + .getStringList())); + GT_Values.mCTMDisabledBlock.addAll( + Arrays.asList( + tMainConfig.get("general", "ctm_block_blacklist", new String[] { "team.chisel.block.BlockRoadLine" }) + .getStringList())); + + GT_RecipeBuilder.onConfigLoad(); + } + + public static void loadClientConfig() { + final String sBDye0 = "ColorModulation."; + Arrays.stream(Dyes.values()) + .filter(tDye -> (tDye != Dyes._NULL) && (tDye.mIndex < 0)) + .forEach(tDye -> { + String sBDye1 = sBDye0 + tDye; + tDye.mRGBa[0] = ((short) Math + .min(255, Math.max(0, GregTech_API.sClientDataFile.get(sBDye1, "R", tDye.mOriginalRGBa[0])))); + tDye.mRGBa[1] = ((short) Math + .min(255, Math.max(0, GregTech_API.sClientDataFile.get(sBDye1, "G", tDye.mOriginalRGBa[1])))); + tDye.mRGBa[2] = ((short) Math + .min(255, Math.max(0, GregTech_API.sClientDataFile.get(sBDye1, "B", tDye.mOriginalRGBa[2])))); + }); + GT_Mod.gregtechproxy.mRenderTileAmbientOcclusion = GregTech_API.sClientDataFile + .get("render", "TileAmbientOcclusion", true); + GT_Mod.gregtechproxy.mRenderGlowTextures = GregTech_API.sClientDataFile.get("render", "GlowTextures", true); + GT_Mod.gregtechproxy.mRenderFlippedMachinesFlipped = GregTech_API.sClientDataFile + .get("render", "RenderFlippedMachinesFlipped", true); + GT_Mod.gregtechproxy.mRenderIndicatorsOnHatch = GregTech_API.sClientDataFile + .get("render", "RenderIndicatorsOnHatch", true); + GT_Mod.gregtechproxy.mRenderDirtParticles = GregTech_API.sClientDataFile + .get("render", "RenderDirtParticles", true); + GT_Mod.gregtechproxy.mRenderPollutionFog = GregTech_API.sClientDataFile + .get("render", "RenderPollutionFog", true); + GT_Mod.gregtechproxy.mRenderItemDurabilityBar = GregTech_API.sClientDataFile + .get("render", "RenderItemDurabilityBar", true); + GT_Mod.gregtechproxy.mRenderItemChargeBar = GregTech_API.sClientDataFile + .get("render", "RenderItemChargeBar", true); + GT_Mod.gregtechproxy.mUseBlockUpdateHandler = GregTech_API.sClientDataFile + .get("render", "UseBlockUpdateHandler", false); + + GT_Mod.gregtechproxy.mCoverTabsVisible = GregTech_API.sClientDataFile + .get("interface", "DisplayCoverTabs", true); + GT_Mod.gregtechproxy.mCoverTabsFlipped = GregTech_API.sClientDataFile.get("interface", "FlipCoverTabs", false); + GT_Mod.gregtechproxy.mTooltipVerbosity = GregTech_API.sClientDataFile.get("interface", "TooltipVerbosity", 2); + GT_Mod.gregtechproxy.mTooltipShiftVerbosity = GregTech_API.sClientDataFile + .get("interface", "TooltipShiftVerbosity", 3); + GT_Mod.gregtechproxy.mTitleTabStyle = GregTech_API.sClientDataFile.get("interface", "TitleTabStyle", 0); + + GT_Mod.gregtechproxy.mNEIRecipeSecondMode = GregTech_API.sClientDataFile.get("nei", "RecipeSecondMode", true); + GT_Mod.gregtechproxy.mNEIRecipeOwner = GregTech_API.sClientDataFile.get("nei", "RecipeOwner", false); + GT_Mod.gregtechproxy.mNEIRecipeOwnerStackTrace = GregTech_API.sClientDataFile + .get("nei", "RecipeOwnerStackTrace", false); + GT_Mod.gregtechproxy.mNEIOriginalVoltage = GregTech_API.sClientDataFile.get("nei", "OriginalVoltage", false); + + GT_Mod.gregtechproxy.recipeCategorySettings.clear(); + for (RecipeCategory recipeCategory : findRecipeCategories()) { + RecipeCategorySetting setting = RecipeCategorySetting.find( + GregTech_API.sClientDataFile.getWithValidValues( + "nei.recipe_categories", + recipeCategory.unlocalizedName, + RecipeCategorySetting.NAMES, + RecipeCategorySetting.getDefault() + .toName())); + GT_Mod.gregtechproxy.recipeCategorySettings.put(recipeCategory, setting); + } + + GT_Mod.gregtechproxy.mWailaTransformerVoltageTier = GregTech_API.sClientDataFile + .get("waila", "WailaTransformerVoltageTier", true); + GT_Mod.gregtechproxy.wailaAverageNS = GregTech_API.sClientDataFile.get("waila", "WailaAverageNS", false); + + final String[] Circuits = GregTech_API.sClientDataFile.get("interface", "CircuitsOrder"); + GT_Mod.gregtechproxy.mCircuitsOrder.clear(); + for (int i = 0; i < Circuits.length; i++) { + GT_Mod.gregtechproxy.mCircuitsOrder.putIfAbsent(Circuits[i], i); + } + + GT_Mod.gregtechproxy.reloadNEICache(); + } + + private static List<RecipeCategory> findRecipeCategories() { + List<RecipeCategory> ret = new ArrayList<>(); + try { + Field discovererField = Loader.class.getDeclaredField("discoverer"); + discovererField.setAccessible(true); + ModDiscoverer discoverer = (ModDiscoverer) discovererField.get(Loader.instance()); + for (ASMDataTable.ASMData asmData : discoverer.getASMTable() + .getAll(RecipeCategoryHolder.class.getName())) { + try { + Object obj = Class.forName(asmData.getClassName()) + .getDeclaredField(asmData.getObjectName()) + .get(null); + if (obj instanceof RecipeCategory recipeCategory) { + ret.add(recipeCategory); + } else { + GT_FML_LOGGER.error( + "{}#{} is not an instance of RecipeCategory", + asmData.getClassName(), + asmData.getObjectName()); + } + } catch (ClassNotFoundException | NoSuchFieldException | IllegalAccessException e) { + GT_FML_LOGGER.error("Failed to find RecipeCategory"); + GT_FML_LOGGER.catching(e); + } + } + } catch (NoSuchFieldException | IllegalAccessException e) { + throw new RuntimeException(e); + } + return ret; + } +} |