diff options
Diffstat (limited to 'src/main/java/gregtech/common/items')
49 files changed, 16766 insertions, 0 deletions
diff --git a/src/main/java/gregtech/common/items/CombType.java b/src/main/java/gregtech/common/items/CombType.java new file mode 100644 index 0000000000..96850727fd --- /dev/null +++ b/src/main/java/gregtech/common/items/CombType.java @@ -0,0 +1,284 @@ +package gregtech.common.items; + +import java.util.Arrays; + +import gregtech.api.enums.Materials; +import gregtech.api.util.GT_LanguageManager; + +public enum CombType { + + // Organic Line + LIGNIE(0, "lignite", true, Materials.Lignite, 100, 0x58300B, 0x906237, ItemComb.Voltage.LV), + COAL(1, "coal", true, Materials.Coal, 100, 0x525252, 0x666666, ItemComb.Voltage.LV), + STICKY(2, "stickyresin", true, Materials._NULL, 50, 0x2E8F5B, 0xDCC289, ItemComb.Voltage.LV), + OIL(3, "oil", true, Materials._NULL, 100, 0x333333, 0x4C4C4C, ItemComb.Voltage.LV), + APATITE(4, "apatite", true, Materials.Apatite, 100, 0xc1c1f6, 0x676784, ItemComb.Voltage.LV), + ASH(5, "ash", true, Materials.Ash, 100, 0x1e1a18, 0xc6c6c6, ItemComb.Voltage.LV), + + // IC2 Line + COOLANT(6, "coolant", true, Materials._NULL, 100, 0x144F5A, 0x2494A2, ItemComb.Voltage.HV), + ENERGY(7, "energy", true, Materials._NULL, 80, 0xC11F1F, 0xEBB9B9, ItemComb.Voltage.HV), + LAPOTRON(8, "lapotron", true, Materials._NULL, 60, 0x1414FF, 0x6478FF, ItemComb.Voltage.HV), + PYROTHEUM(9, "pyrotheum", true, Materials.Pyrotheum, 50, 0xffebc4, 0xe36400, ItemComb.Voltage.HV), + CRYOTHEUM(10, "cryotheum", true, Materials.Cryotheum, 50, 0x2660ff, 0x5af7ff, ItemComb.Voltage.HV), + + // Alloy Line + REDALLOY(11, "redalloy", true, Materials.RedAlloy, 100, 0xE60000, 0xB80000, ItemComb.Voltage.LV), + REDSTONEALLOY(12, "redstonealloy", true, Materials.RedstoneAlloy, 90, 0xB80000, 0xA50808, ItemComb.Voltage.LV), + CONDUCTIVEIRON(13, "conductiveiron", true, Materials.ConductiveIron, 80, 0x817671, 0xCEADA3, ItemComb.Voltage.MV), + VIBRANTALLOY(14, "vibrantalloy", true, Materials.VibrantAlloy, 50, 0x86A12D, 0xC4F2AE, ItemComb.Voltage.HV), + ENERGETICALLOY(15, "energeticalloy", true, Materials.EnergeticAlloy, 70, 0xFF9933, 0xFFAD5C, ItemComb.Voltage.HV), + ELECTRICALSTEEL(16, "electricalsteel", true, Materials.ElectricalSteel, 90, 0x787878, 0xD8D8D8, + ItemComb.Voltage.LV), + DARKSTEEL(17, "darksteel", true, Materials.DarkSteel, 80, 0x252525, 0x443B44, ItemComb.Voltage.MV), + PULSATINGIRON(18, "pulsatingiron", true, Materials.PulsatingIron, 80, 0x006600, 0x6DD284, ItemComb.Voltage.HV), + STAINLESSSTEEL(19, "stainlesssteel", true, Materials.StainlessSteel, 75, 0x778899, 0xC8C8DC, ItemComb.Voltage.HV), + ENDERIUM(20, "enderium", true, Materials.Enderium, 40, 0x2E8B57, 0x599087, ItemComb.Voltage.HV), + + // Thaumcraft Line + THAUMIUMDUST(21, "thaumiumdust", true, Materials.Thaumium, 100, 0x7A007A, 0x5C005C, ItemComb.Voltage.MV), + THAUMIUMSHARD(22, "thaumiumshard", true, Materials._NULL, 85, 0x9966FF, 0xAD85FF, ItemComb.Voltage.LV), + AMBER(23, "amber", true, Materials.Amber, 90, 0x774B15, 0xEE7700, ItemComb.Voltage.LV), + QUICKSILVER(24, "quicksilver", true, Materials.Mercury, 90, 0xc7c7ea, 0xb5b3df, ItemComb.Voltage.LV), + SALISMUNDUS(25, "salismundus", true, Materials._NULL, 75, 0xF7ADDE, 0x592582, ItemComb.Voltage.MV), + TAINTED(26, "tainted", true, Materials._NULL, 80, 0x904BB8, 0xE800FF, ItemComb.Voltage.LV), + MITHRIL(27, "mithril", true, Materials.Mithril, 70, 0xF0E68C, 0xFFFFD2, ItemComb.Voltage.HV), + ASTRALSILVER(28, "astralsilver", true, Materials.AstralSilver, 70, 0xAFEEEE, 0xE6E6FF, ItemComb.Voltage.HV), + THAUMINITE(29, "thauminite", true, Materials._NULL, 50, 0x2E2D79, 0x7581E0, ItemComb.Voltage.HV), + SHADOWMETAL(30, "shadowmetal", true, Materials.Shadow, 50, 0x100322, 0x100342, ItemComb.Voltage.HV), + DIVIDED(31, "divided", true, Materials.Unstable, 40, 0xF0F0F0, 0xDCDCDC, ItemComb.Voltage.HV), + SPARKELING(32, "sparkling", true, Materials.NetherStar, 40, 0x7A007A, 0xFFFFFF, ItemComb.Voltage.EV), + + // Gem Line + STONE(33, "stone", true, Materials._NULL, 70, 0x808080, 0x999999, ItemComb.Voltage.LV), + CERTUS(34, "certus", true, Materials.CertusQuartz, 100, 0x57CFFB, 0xBBEEFF, ItemComb.Voltage.LV), + FLUIX(35, "fluix", true, Materials.Fluix, 100, 0xA375FF, 0xB591FF, ItemComb.Voltage.LV), + REDSTONE(36, "redstone", true, Materials.Redstone, 100, 0x7D0F0F, 0xD11919, ItemComb.Voltage.LV), + RAREEARTH(37, "rareearth", true, Materials.RareEarth, 100, 0x555643, 0x343428, ItemComb.Voltage.LV), + LAPIS(38, "lapis", true, Materials.Lapis, 100, 0x1947D1, 0x476CDA, ItemComb.Voltage.LV), + RUBY(39, "ruby", true, Materials.Ruby, 100, 0xE6005C, 0xCC0052, ItemComb.Voltage.LV), + REDGARNET(40, "redgarnet", true, Materials.GarnetRed, 100, 0xBD4C4C, 0xECCECE, ItemComb.Voltage.LV), + YELLOWGARNET(41, "yellowgarnet", true, Materials.GarnetYellow, 100, 0xA3A341, 0xEDEDCE, ItemComb.Voltage.LV), + SAPPHIRE(42, "sapphire", true, Materials.Sapphire, 100, 0x0033CC, 0x00248F, ItemComb.Voltage.LV), + DIAMOND(43, "diamond", true, Materials.Diamond, 100, 0xCCFFFF, 0xA3CCCC, ItemComb.Voltage.LV), + OLIVINE(44, "olivine", true, Materials.Olivine, 100, 0x248F24, 0xCCFFCC, ItemComb.Voltage.LV), + EMERALD(45, "emerald", true, Materials.Emerald, 100, 0x248F24, 0x2EB82E, ItemComb.Voltage.LV), + PYROPE(46, "pyrope", true, Materials.Pyrope, 100, 0x763162, 0x8B8B8B, ItemComb.Voltage.LV), + GROSSULAR(47, "grossular", true, Materials.Grossular, 100, 0x9B4E00, 0x8B8B8B, ItemComb.Voltage.LV), + FIRESTONE(48, "firestone", true, Materials.Firestone, 100, 0xC00000, 0xFF0000, ItemComb.Voltage.LV), + + // Metals Line + SLAG(49, "slag", true, Materials._NULL, 50, 0xD4D4D4, 0x58300B, ItemComb.Voltage.LV), + COPPER(50, "copper", true, Materials.Copper, 100, 0xFF6600, 0xE65C00, ItemComb.Voltage.LV), + TIN(51, "tin", true, Materials.Tin, 100, 0xD4D4D4, 0xDDDDDD, ItemComb.Voltage.LV), + LEAD(52, "lead", true, Materials.Lead, 100, 0x666699, 0xA3A3CC, ItemComb.Voltage.LV), + IRON(53, "iron", true, Materials.Iron, 100, 0xDA9147, 0xDE9C59, ItemComb.Voltage.LV), + STEEL(54, "steel", true, Materials.Steel, 95, 0x808080, 0x999999, ItemComb.Voltage.LV), + NICKEL(55, "nickel", true, Materials.Nickel, 100, 0x8585AD, 0x9D9DBD, ItemComb.Voltage.LV), + ZINC(56, "zinc", true, Materials.Zinc, 100, 0xF0DEF0, 0xF2E1F2, ItemComb.Voltage.LV), + SILVER(57, "silver", true, Materials.Silver, 100, 0xC2C2D6, 0xCECEDE, ItemComb.Voltage.LV), + GOLD(58, "gold", true, Materials.Gold, 100, 0xE6B800, 0xCFA600, ItemComb.Voltage.LV), + SULFUR(59, "sulfur", true, Materials.Sulfur, 100, 0x6F6F01, 0x8B8B8B, ItemComb.Voltage.LV), + GALLIUM(60, "gallium", true, Materials.Gallium, 75, 0x8B8B8B, 0xC5C5E4, ItemComb.Voltage.LV), + ARSENIC(61, "arsenic", true, Materials.Arsenic, 75, 0x736C52, 0x292412, ItemComb.Voltage.LV), + + // Rare Metals Line + BAUXITE(62, "bauxite", true, Materials.Bauxite, 85, 0x6B3600, 0x8B8B8B, ItemComb.Voltage.LV), + ALUMINIUM(63, "aluminium", true, Materials.Aluminium, 60, 0x008AB8, 0xD6D6FF, ItemComb.Voltage.LV), + MANGANESE(64, "manganese", true, Materials.Manganese, 30, 0xD5D5D5, 0xAAAAAA, ItemComb.Voltage.LV), + MAGNESIUM(65, "magnesium", true, Materials.Magnesium, 75, 0xF1D9D9, 0x8B8B8B, ItemComb.Voltage.LV), + TITANIUM(66, "titanium", true, Materials.Ilmenite, 100, 0xCC99FF, 0xDBB8FF, ItemComb.Voltage.IV), + CHROME(67, "chromium", true, Materials.Chrome, 50, 0xEBA1EB, 0xF2C3F2, ItemComb.Voltage.HV), + TUNGSTEN(68, "tungsten", true, Materials.Tungstate, 100, 0x62626D, 0x161620, ItemComb.Voltage.IV), + PLATINUM(69, "platinum", true, Materials.Platinum, 40, 0xE6E6E6, 0xFFFFCC, ItemComb.Voltage.HV), + IRIDIUM(70, "iridium", true, Materials.Iridium, 20, 0xDADADA, 0xD1D1E0, ItemComb.Voltage.IV), + MOLYBDENUM(71, "molybdenum", true, Materials.Molybdenum, 20, 0xAEAED4, 0x8B8B8B, ItemComb.Voltage.LV), + OSMIUM(72, "osmium", true, Materials.Osmium, 15, 0x2B2BDA, 0x8B8B8B, ItemComb.Voltage.IV), + LITHIUM(73, "lithium", true, Materials.Lithium, 75, 0xF0328C, 0xE1DCFF, ItemComb.Voltage.MV), + SALT(74, "salt", true, Materials.Salt, 90, 0xF0C8C8, 0xFAFAFA, ItemComb.Voltage.MV), + ELECTROTINE(75, "electrotine", true, Materials.Electrotine, 75, 0x1E90FF, 0x3CB4C8, ItemComb.Voltage.HV), + ALMANDINE(76, "almandine", true, Materials.Almandine, 85, 0xC60000, 0x8B8B8B, ItemComb.Voltage.LV), + + // Radioactive Line + URANIUM(77, "uranium", true, Materials.Uranium, 50, 0x19AF19, 0x169E16, ItemComb.Voltage.IV), + PLUTONIUM(78, "plutonium", true, Materials.Plutonium, 10, 0x240000, 0x570000, ItemComb.Voltage.IV), + NAQUADAH(79, "naquadah", true, Materials.Naquadah, 10, 0x000000, 0x004400, ItemComb.Voltage.IV), + NAQUADRIA(80, "naquadria", true, Materials.Naquadria, 5, 0x000000, 0x002400, ItemComb.Voltage.IV), + DOB(81, "d-o-b", true, Materials._NULL, 50, 0x007700, 0x002400, ItemComb.Voltage.LV), + THORIUM(82, "thorium", true, Materials.Thorium, 75, 0x001E00, 0x005000, ItemComb.Voltage.EV), + LUTETIUM(83, "lutetium", true, Materials.Lutetium, 10, 0xE6FFE6, 0xFFFFFF, ItemComb.Voltage.IV), + AMERICIUM(84, "americium", true, Materials.Americium, 5, 0xE6E6FF, 0xC8C8C8, ItemComb.Voltage.LuV), + NEUTRONIUM(85, "neutronium", true, Materials.Neutronium, 2, 0xFFF0F0, 0xFAFAFA, ItemComb.Voltage.ZPM), + + // Twilight + NAGA(86, "naga", true, Materials._NULL, 100, 0x0D5A0D, 0x28874B, ItemComb.Voltage.MV), + LICH(87, "lich", true, Materials._NULL, 90, 0x5C605E, 0xC5C5C5, ItemComb.Voltage.HV), + HYDRA(88, "hydra", true, Materials._NULL, 80, 0x872836, 0xB8132C, ItemComb.Voltage.HV), + URGHAST(89, "urghast", true, Materials._NULL, 70, 0x7C0618, 0xA7041C, ItemComb.Voltage.EV), + SNOWQUEEN(90, "snowqueen", true, Materials._NULL, 60, 0x9C0018, 0xD02001, ItemComb.Voltage.EV), + + // Space + SPACE(91, "space", true, Materials._NULL, 100, 0x003366, 0xC0C0C0, ItemComb.Voltage.HV), + METEORICIRON(92, "meteoriciron", true, Materials.MeteoricIron, 100, 0x321928, 0x643250, ItemComb.Voltage.EV), + DESH(93, "desh", true, Materials.Desh, 90, 0x282828, 0x323232, ItemComb.Voltage.IV), + LEDOX(94, "ledox", true, Materials.Ledox, 75, 0x0000CD, 0x0074FF, ItemComb.Voltage.IV), + CALLISTOICE(95, "callistoice", true, Materials.CallistoIce, 75, 0x0074FF, 0x1EB1FF, ItemComb.Voltage.IV), + MYTRYL(96, "mytryl", true, Materials.Mytryl, 65, 0xDAA520, 0xF26404, ItemComb.Voltage.IV), + QUANTIUM(97, "quantium", true, Materials.Quantium, 50, 0x00FF00, 0x00D10B, ItemComb.Voltage.IV), + ORIHARUKON(98, "oriharukon", true, Materials.Oriharukon, 50, 0x228B22, 0x677D68, ItemComb.Voltage.IV), + MYSTERIOUSCRYSTAL(99, "mysteriouscrystal", true, Materials.MysteriousCrystal, 45, 0x3CB371, 0x16856C, + ItemComb.Voltage.LuV), + BLACKPLUTONIUM(100, "blackplutonium", true, Materials.Quantium, 25, 0x000000, 0x323232, ItemComb.Voltage.LuV), + TRINIUM(101, "trinium", true, Materials.Trinium, 25, 0xB0E0E6, 0xC8C8D2, ItemComb.Voltage.ZPM), + + // Planet + MERCURY(102, "mercury", true, Materials._NULL, 65, 0x4A4033, 0xB5A288, ItemComb.Voltage.EV), + VENUS(103, "venus", true, Materials._NULL, 65, 0x120E07, 0x272010, ItemComb.Voltage.EV), + MOON(104, "moon", true, Materials._NULL, 90, 0x373735, 0x7E7E78, ItemComb.Voltage.MV), + MARS(105, "mars", true, Materials._NULL, 80, 0x220D05, 0x3A1505, ItemComb.Voltage.MV), + JUPITER(106, "jupiter", true, Materials._NULL, 75, 0x734B2E, 0xD0CBC4, ItemComb.Voltage.MV), + SATURN(107, "saturn", true, Materials._NULL, 55, 0xD2A472, 0xF8C37B, ItemComb.Voltage.IV), + URANUS(108, "uranus", true, Materials._NULL, 45, 0x75C0C9, 0x84D8EC, ItemComb.Voltage.IV), + NEPTUN(109, "neptun", true, Materials._NULL, 35, 0x334CFF, 0x576DFF, ItemComb.Voltage.IV), + PLUTO(110, "pluto", true, Materials._NULL, 25, 0x34271E, 0x69503D, ItemComb.Voltage.LuV), + HAUMEA(111, "haumea", true, Materials._NULL, 20, 0x1C1413, 0x392B28, ItemComb.Voltage.LuV), + MAKEMAKE(112, "makemake", true, Materials._NULL, 20, 0x301811, 0x120A07, ItemComb.Voltage.LuV), + CENTAURI(113, "centauri", true, Materials._NULL, 15, 0x2F2A14, 0xB06B32, ItemComb.Voltage.ZPM), + TCETI(114, "tceti", true, Materials._NULL, 10, 0x46241A, 0x7B412F, ItemComb.Voltage.ZPM), + BARNARDA(115, "barnarda", true, Materials._NULL, 10, 0x0D5A0D, 0xE6C18D, ItemComb.Voltage.ZPM), + VEGA(116, "vega", true, Materials._NULL, 10, 0x1A2036, 0xB5C0DE, ItemComb.Voltage.ZPM), + + // Infinity + COSMICNEUTRONIUM(117, "cosmicneutronium", true, Materials.CosmicNeutronium, 5, 0x484848, 0x323232, + ItemComb.Voltage.UV), + INFINITYCATALYST(118, "infinitycatalyst", true, Materials.InfinityCatalyst, 2, 0xFFFFFF, 0xFFFFFF, + ItemComb.Voltage.UHV), + INFINITY(119, "infinity", true, Materials.Infinity, 1, 0xFFFFFF, 0xFFFFFF, ItemComb.Voltage.UEV), + + // HEE + ENDDUST(120, "enddust", true, Materials._NULL, 50, 0x003A7D, 0xCC00FA, ItemComb.Voltage.HV), + ECTOPLASMA(121, "ectoplasma", true, Materials._NULL, 35, 0x381C40, 0xDCB0E5, ItemComb.Voltage.EV), + ARCANESHARD(122, "arcaneshard", true, Materials._NULL, 35, 0x333D82, 0x9010AD, ItemComb.Voltage.EV), + STARDUST(123, "stardust", true, Materials._NULL, 60, 0xDCBE13, 0xffff00, ItemComb.Voltage.HV), + DRAGONESSENCE(124, "dragonessence", true, Materials._NULL, 30, 0x911ECE, 0xFFA12B, ItemComb.Voltage.IV), + ENDERMAN(125, "enderman", true, Materials._NULL, 25, 0x6200e7, 0x161616, ItemComb.Voltage.IV), + SILVERFISH(126, "silverfish", true, Materials._NULL, 25, 0x0000000, 0xEE053D, ItemComb.Voltage.EV), + ENDIUM(127, "endium", true, Materials.HeeEndium, 50, 0x2F5A6C, 0xa0ffff, ItemComb.Voltage.HV), + RUNEI(128, "rune1", true, Materials._NULL, 10, 0x0104D9, 0xE31010, ItemComb.Voltage.IV), + RUNEII(129, "rune2", true, Materials._NULL, 10, 0xE31010, 0x0104D9, ItemComb.Voltage.IV), + FIREESSENSE(130, "fireessence", true, Materials._NULL, 30, 0xFFA157, 0xD41238, ItemComb.Voltage.IV), + CRYOLITE(131, "cryolite", true, Materials.Cryolite, 90, 0xBFEFFF, 0x73B9D0, ItemComb.Voltage.LV), + // (NOBLE) GAS LINE + HELIUM(132, "helium", true, Materials.Helium, 90, 0xFFA9FF, 0xFFFFC3, ItemComb.Voltage.HV), + ARGON(133, "argon", true, Materials.Argon, 95, 0x89D9E1, 0x160822, ItemComb.Voltage.MV), + // XENON, NEON and KRYPTON Fluid extractor Recipes are located in GT_MachineRecipeLoader.java + XENON(134, "xenon", true, Materials._NULL, 85, 0x160822, 0x8A97B0, ItemComb.Voltage.IV), + NEON(135, "neon", true, Materials._NULL, 90, 0xFF7200, 0xFFC826, ItemComb.Voltage.IV), + KRYPTON(136, "krypton", true, Materials._NULL, 85, 0x160822, 0x8A97B0, ItemComb.Voltage.IV), + NITROGEN(137, "nitrogen", true, Materials.Nitrogen, 100, 0xA52A2A, 0xFFC832, ItemComb.Voltage.MV), + OXYGEN(138, "oxygen", true, Materials.Oxygen, 100, 0x8F8FFF, 0xFFFFFF, ItemComb.Voltage.MV), + HYDROGEN(139, "hydrogen", true, Materials.Hydrogen, 100, 0xFF1493, 0xFFFFFF, ItemComb.Voltage.MV), + // Those are supposed to be in the organic branch, but that would require shifting all comb IDs and we don't want to + // risk it. + PHOSPHORUS(140, "phosphorus", true, Materials.Phosphorus, 100, 0xC1C1F6, 0xFFC826, ItemComb.Voltage.HV), + MICA(141, "mica", true, Materials.Mica, 100, 0x8A97B0, 0x2F3641, ItemComb.Voltage.HV), + // Seaweed is located in the planet line + SEAWEED(142, "seaweed", true, Materials._NULL, 90, 0x83FF83, 0xCBCBCB, ItemComb.Voltage.UV), + // just Walrus + WALRUS(143, "walrus", true, Materials._NULL, 100, 0xB5CFC9, 0xD6D580, ItemComb.Voltage.LV), + // TC infused Air shards line. Recipes in GT_MachineRecipeLoader.java Lines 1500+ + Nether/Endshard + INFUSEDAER(144, "infusedair", true, Materials._NULL, 100, 0x60602F, 0xFFFF7E, ItemComb.Voltage.LV), + INFUSEDTERRA(145, "infusedterra", true, Materials._NULL, 100, 0x003300, 0x008600, ItemComb.Voltage.LV), + INFUSEDIGNIS(146, "infusedignis", true, Materials._NULL, 100, 0x3B0E00, 0xED3801, ItemComb.Voltage.LV), + INFUSEDAQUA(147, "infusedaqua", true, Materials._NULL, 100, 0x002542, 0x0090FF, ItemComb.Voltage.LV), + INFUSEDORDO(148, "infusedordo", true, Materials._NULL, 100, 0x5C5F62, 0x8A97B0, ItemComb.Voltage.LV), + INFUSEDPERDITIO(149, "infusedperditio", true, Materials._NULL, 100, 0x232129, 0x2E2E41, ItemComb.Voltage.LV), + FLUORINE(150, "fluorine", true, Materials.Fluorine, 100, 0xFF6D00, 0x86AFF0, ItemComb.Voltage.MV), + BEDROCKIUM(151, "bedrockium", true, Materials.Bedrockium, 100, 0xC6C6C6, 0x0C0C0C, ItemComb.Voltage.EV), + NETHERSHARD(152, "nethershard", true, Materials.Netherrack, 100, 0x350211, 0xBE0135, ItemComb.Voltage.HV), + ENDSHARD(153, "endshard", true, Materials.EnderEye, 100, 0x232129, 0x2E2E41, ItemComb.Voltage.HV), + CAELESTISRED(154, "caelestisred", true, Materials._NULL, 100, 0xFF0000, 0xFF00FF, ItemComb.Voltage.LV), + CAELESTISGREEN(155, "caelestisgreen", true, Materials._NULL, 100, 0x00FF00, 0xB233FF, ItemComb.Voltage.LV), + CAELESTISBLUE(156, "caelestisblue", true, Materials._NULL, 100, 0x0000FF, 0xFF99A5, ItemComb.Voltage.LV), + UNKNOWNWATER(157, "unknownwater", true, Materials._NULL, 100, 0x36ABFF, 0x4333A5, ItemComb.Voltage.ZPM), + // ESSENTIA gets a use soon. Dont remove. + ESSENTIA(158, "essentia", true, Materials._NULL, 100, 0xED3601, 0xFF6D50, ItemComb.Voltage.MV), + INDIUM(159, "indium", true, Materials.Indium, 100, 0x8F5D99, 0xFFA9FF, ItemComb.Voltage.ZPM), + BLIZZ(160, "blizz", true, Materials.Blizz, 50, 0xFF99A5, 0x5af7ff, ItemComb.Voltage.MV), + KEVLAR(161, "kevlar", true, Materials._NULL, 50, 0xa2baa3, 0x2d542f, ItemComb.Voltage.MV), + DRACONIC(162, "draconium", true, Materials.Draconium, 50, 0x161616, 0x6200e7, ItemComb.Voltage.MV), + AWAKENEDDRACONIUM(163, "awakeneddraconium", true, Materials.DraconiumAwakened, 50, 0xD41238, 0xFFA157, + ItemComb.Voltage.MV), + PALLADIUM(164, "palladium", true, Materials.Palladium, 50, 0x8B8B8B, 0xF1D9D9, ItemComb.Voltage.MV), + INFUSEDGOLD(165, "infusedgold", true, Materials.InfusedGold, 50, 0x80641E, 0xFFC83C, ItemComb.Voltage.IV), + + // ALWAYS KEEP _NULL AT THE BOTTOM + _NULL(-1, "INVALIDCOMB", false, Materials._NULL, 0, 0, 0); + + public boolean showInList; + public final ItemComb.Voltage voltage; + public final Materials material; + public final int chance; + + private final int id; + private final String localizedName; + private final int[] color; + + CombType(int id, String pName, boolean show, Materials material, int chance, int color1, int color2) { + this(id, pName, show, material, chance, color1, color2, null); + } + + CombType(int id, String pName, boolean show, Materials material, int chance, int color1, int color2, + ItemComb.Voltage voltage) { + if (id < 0 && !"INVALIDCOMB".equals(pName)) throw new IllegalArgumentException(); + this.id = id; + this.voltage = voltage; + this.material = material; + this.chance = chance; + this.showInList = show; + this.color = new int[] { color1, color2 }; + this.localizedName = GT_LanguageManager.addStringLocalization( + "comb." + pName, + pName.substring(0, 1) + .toUpperCase() + pName.substring(1) + + " Comb"); + } + + public void setHidden() { + this.showInList = false; + } + + public String getName() { + + return this.localizedName; + } + + public int[] getColours() { + return color == null || color.length != 2 ? new int[] { 0, 0 } : color; + } + + public int getId() { + return id; + } + + public static CombType valueOf(int id) { + return id < 0 || id >= Companion.VALUES.length ? _NULL : Companion.VALUES[id]; + } + + private static final class Companion { + + private static final CombType[] VALUES; + + static { + int biggestId = Arrays.stream(CombType.values()) + .mapToInt(CombType::getId) + .max() + .getAsInt(); + VALUES = new CombType[biggestId + 1]; + Arrays.fill(VALUES, _NULL); + for (CombType type : CombType.values()) { + if (type != _NULL) VALUES[type.getId()] = type; + } + } + } +} diff --git a/src/main/java/gregtech/common/items/DropType.java b/src/main/java/gregtech/common/items/DropType.java new file mode 100644 index 0000000000..64d42b2eeb --- /dev/null +++ b/src/main/java/gregtech/common/items/DropType.java @@ -0,0 +1,46 @@ +package gregtech.common.items; + +import gregtech.api.enums.Materials; +import gregtech.api.util.GT_LanguageManager; + +public enum DropType { + + OIL("oil", true), + MUTAGEN("small mutagen catalyst", true), + COOLANT("coolant", true), + HOT_COOLANT("hot coolant", true), + HYDRA("hydra blood", true), + SNOW_QUEEN("snowqueen blood", true), + OXYGEN("oxygen", true), + LAPIS("lapis coolant", true), + ENDERGOO("ender goo", true); + + private static final int[][] colours = new int[][] { { 0x19191B, 0x303032 }, { 0xffc100, 0x00ff11 }, + { 0x144F5A, 0x2494A2 }, { 0xC11F1F, 0xEBB9B9 }, { 0x872836, 0xB8132C }, { 0xD02001, 0x9C0018 }, + { 0x003366, 0x0066BB }, { 0x1727b1, 0x008ce3 }, { 0xA005E7, 0x161616 }, }; + public boolean showInList; + public Materials material; + public int chance; + private final String name; + + DropType(String pName, boolean show) { + this.name = pName; + this.showInList = show; + } + + public void setHidden() { + this.showInList = false; + } + + public String getName() { + + return GT_LanguageManager.addStringLocalization( + "drop." + this.name, + this.name.substring(0, 1) + .toUpperCase() + this.name.substring(1) + " Drop"); + } + + public int[] getColours() { + return colours[this.ordinal()]; + } +} diff --git a/src/main/java/gregtech/common/items/GT_AdvancedSensorCard_Item.java b/src/main/java/gregtech/common/items/GT_AdvancedSensorCard_Item.java new file mode 100644 index 0000000000..ae64bea432 --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_AdvancedSensorCard_Item.java @@ -0,0 +1,327 @@ +package gregtech.common.items; + +import static gregtech.api.enums.Mods.GregTech; +import static gregtech.common.covers.GT_Cover_Metrics_Transmitter.CARD_STATE_KEY; +import static gregtech.common.covers.GT_Cover_Metrics_Transmitter.FREQUENCY_LSB_KEY; +import static gregtech.common.covers.GT_Cover_Metrics_Transmitter.FREQUENCY_MSB_KEY; +import static gregtech.common.covers.GT_Cover_Metrics_Transmitter.MACHINE_KEY; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; +import java.util.UUID; +import java.util.function.Predicate; +import java.util.stream.IntStream; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.IIcon; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; + +import org.jetbrains.annotations.NotNull; + +import com.google.common.collect.ImmutableList; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.common.misc.GlobalMetricsCoverDatabase; +import gregtech.common.misc.GlobalMetricsCoverDatabase.State; +import shedar.mods.ic2.nuclearcontrol.api.CardState; +import shedar.mods.ic2.nuclearcontrol.api.ICardWrapper; +import shedar.mods.ic2.nuclearcontrol.api.IPanelDataSource; +import shedar.mods.ic2.nuclearcontrol.api.PanelSetting; +import shedar.mods.ic2.nuclearcontrol.api.PanelString; + +@SuppressWarnings("unused") +public class GT_AdvancedSensorCard_Item extends Item implements IPanelDataSource { + + public static final UUID CARD_TYPE_ID = UUID.fromString("ff952e84-7608-4c4a-85af-dd6e1aa27fc7"); + + // This has obfuscated formatting, so no need to localize it. + private static final String SELF_DESTRUCTED_OUTPUT = EnumChatFormatting.OBFUSCATED + "critical error" + + EnumChatFormatting.RESET; + + private static final ImmutableList<String> DECONSTRUCTED_OUTPUT = ImmutableList.of( + StatCollector.translateToLocal("gt.item.adv_sensor_card.error.deconstructed.1"), + StatCollector.translateToLocal("gt.item.adv_sensor_card.error.deconstructed.2")); + + private static final String NO_DATA_FOUND = StatCollector.translateToLocal("gt.item.adv_sensor_card.error.no_data"); + + private static final String MACHINE_NAME_KEY = "client_machine_name"; + private static final String OUTPUT_ENTRY_KEY = "client_entry_%d"; + private static final String OUTPUT_ENTRY_LENGTH_KEY = "client_entry_length"; + + private int payloadSize = 0; + + @SideOnly(Side.CLIENT) + private IIcon normalIcon; + @SideOnly(Side.CLIENT) + private IIcon selfDestructedIcon; + + @SuppressWarnings("unused") + public GT_AdvancedSensorCard_Item() { + super(); + + GameRegistry.registerItem(this, "gt.advancedsensorcard", GregTech.ID); + setUnlocalizedName("gt.advancedsensorcard"); + setMaxStackSize(1); + setNoRepair(); + } + + @Override + public void addInformation(final ItemStack itemStack, final EntityPlayer player, final List<String> tooltip, + final boolean p_77624_4_) { + super.addInformation(itemStack, player, tooltip, p_77624_4_); + + final Optional<State> cardState = getCardState(itemStack); + if (cardState.isPresent()) { + final State state = cardState.get(); + + if (state == State.SELF_DESTRUCTED) { + tooltip.add(StatCollector.translateToLocal("gt.item.adv_sensor_card.tooltip.fried.1")); + tooltip.add(StatCollector.translateToLocal("gt.item.adv_sensor_card.tooltip.fried.2")); + tooltip.add(StatCollector.translateToLocal("gt.item.adv_sensor_card.tooltip.fried.3")); + } else { + getMachineName(itemStack).ifPresent( + machineName -> tooltip.add( + StatCollector + .translateToLocalFormatted("gt.item.adv_sensor_card.tooltip.machine", machineName))); + getUUID(itemStack).ifPresent( + uuid -> tooltip.add( + StatCollector + .translateToLocalFormatted("gt.item.adv_sensor_card.tooltip.frequency", uuid.toString()))); + } + } else { + tooltip.add(StatCollector.translateToLocal("gt.item.adv_sensor_card.tooltip.recipe_hint")); + } + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item aItem, CreativeTabs aCreativeTab, List<ItemStack> aOutputSubItems) {} + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(final IIconRegister aIconRegister) { + super.registerIcons(aIconRegister); + itemIcon = aIconRegister.registerIcon(GregTech.ID + ":gt.advancedsensorcard"); + normalIcon = itemIcon; + selfDestructedIcon = aIconRegister.registerIcon(GregTech.ID + ":gt.advancedsensorcardburned"); + } + + @Override + @SideOnly(Side.CLIENT) + public IIcon getIcon(final ItemStack stack, final int renderPass) { + return getIconIndex(stack); + } + + @Override + public IIcon getIconIndex(final ItemStack itemStack) { + return getCardState(itemStack).filter(Predicate.isEqual(State.SELF_DESTRUCTED)) + .map(ignored -> selfDestructedIcon) + .orElse(normalIcon); + } + + @Override + public CardState update(TileEntity tileEntity, ICardWrapper card, int maxRange) { + return update(tileEntity.getWorldObj(), card, maxRange); + } + + @Override + public CardState update(World world, ICardWrapper card, int maxRange) { + final Optional<GlobalMetricsCoverDatabase.Data> optionalData = getDataFromDatabase(card); + + optionalData.ifPresent(data -> { + final State machineState = data.getState(); + reconcileSelfDestructedCard(card.getItemStack(), machineState); + card.setInt(CARD_STATE_KEY, machineState.getType()); + + getMachineName(card.getItemStack()) + .ifPresent(name -> card.setString(MACHINE_NAME_KEY, machineState == State.SELF_DESTRUCTED ? "" : name)); + + final ImmutableList.Builder<String> builder = ImmutableList.builder(); + switch (machineState) { + case SELF_DESTRUCTED -> builder.add(SELF_DESTRUCTED_OUTPUT); + case HOST_DECONSTRUCTED -> builder.addAll(DECONSTRUCTED_OUTPUT); + case OPERATIONAL -> { + data.getCoordinates() + .ifPresent( + coordinates -> builder.add( + StatCollector.translateToLocalFormatted( + "gt.item.adv_sensor_card.dimension", + coordinates.getDimension()), + StatCollector.translateToLocalFormatted( + "gt.item.adv_sensor_card.coords", + coordinates.getLocalizedCoordinates()))); + + data.getPayload() + .ifPresent(builder::addAll); + } + default -> builder.add(NO_DATA_FOUND); + } + + final List<String> payload = builder.build(); + card.setInt(OUTPUT_ENTRY_LENGTH_KEY, payload.size()); + for (int i = 0; i < payload.size(); i++) { + card.setString(String.format(OUTPUT_ENTRY_KEY, i), payload.get(i)); + } + }); + + return CardState.OK; + } + + @Override + public List<PanelString> getStringData(final int displaySettings, final ICardWrapper card, + final boolean showLabels) { + final List<PanelString> returned = new ArrayList<>(); + final String machineName = card.getString(MACHINE_NAME_KEY); + final int bitmaskOffset; + + payloadSize = card.getInt(OUTPUT_ENTRY_LENGTH_KEY); + + if (!machineName.isEmpty() && (displaySettings & 1) != 0) { + returned.add(panelString(machineName, true)); + payloadSize += 1; + bitmaskOffset = 1; + } else { + bitmaskOffset = 0; + } + + // Not reusing payloadSize here because it can be conditionally mutated. + IntStream.range(0, card.getInt(OUTPUT_ENTRY_LENGTH_KEY)) + .forEach(i -> { + if ((displaySettings & 1 << (i + bitmaskOffset)) != 0) { + returned.add(panelString(card.getString(String.format(OUTPUT_ENTRY_KEY, i)))); + } + }); + + return returned; + } + + @Override + public List<PanelSetting> getSettingsList() { + return payloadSize == 0 ? ImmutableList.of() + : ImmutableList.copyOf( + IntStream.range(0, Math.min(payloadSize, 31)) + .mapToObj(i -> new PanelSetting(String.valueOf(i + 1), 1 << i, getCardType())) + .iterator()); + } + + @Override + public UUID getCardType() { + return CARD_TYPE_ID; + } + + @Override + public void onUpdate(ItemStack stack, World worldIn, Entity entityIn, int slot, boolean isHeld) { + super.onUpdate(stack, worldIn, entityIn, slot, isHeld); + // At the time of this comment's writing, there are 52 matches of the regex: + // /% \d+0 \)?\s*== 0/ in the code base, indicating an over-reliance on events happening on either the 10th or + // 20th tick. Let's tick on something slightly off of that. A prime number will do nicely. + if ((worldIn.getWorldTime() % 20) == 13) { + getDataFromDatabase(stack).ifPresent(data -> { + reconcileSelfDestructedCard(stack, data.getState()); + if (!stack.hasTagCompound()) { + stack.setTagCompound(new NBTTagCompound()); + } + + stack.getTagCompound() + .setInteger( + CARD_STATE_KEY, + data.getState() + .getType()); + }); + } + } + + private void reconcileSelfDestructedCard(ItemStack stack, State newState) { + getUUID(stack).ifPresent(uuid -> getCardState(stack).ifPresent(oldState -> { + if (newState == State.SELF_DESTRUCTED && oldState != State.SELF_DESTRUCTED) { + GlobalMetricsCoverDatabase.clearSelfDestructedFrequency(uuid); + } + })); + + } + + @NotNull + private Optional<State> getCardState(ICardWrapper card) { + return getCardState(card.getItemStack()); + } + + @NotNull + private Optional<State> getCardState(ItemStack itemStack) { + if (itemStack.hasTagCompound() && itemStack.getTagCompound() + .hasKey(CARD_STATE_KEY)) { + return State.find( + itemStack.getTagCompound() + .getInteger(CARD_STATE_KEY)); + } + + return Optional.empty(); + } + + @NotNull + private Optional<UUID> getUUID(ItemStack stack) { + if (stack.hasTagCompound()) { + NBTTagCompound nbt = stack.getTagCompound(); + if (nbt.hasKey(FREQUENCY_LSB_KEY) && nbt.hasKey(FREQUENCY_MSB_KEY)) { + return Optional.of(new UUID(nbt.getLong(FREQUENCY_MSB_KEY), nbt.getLong(FREQUENCY_LSB_KEY))); + } + } + + return Optional.empty(); + } + + @NotNull + private Optional<String> getMachineName(ItemStack stack) { + if (stack.hasTagCompound() && stack.getTagCompound() + .hasKey(MACHINE_KEY)) { + try { + final ItemStack machine = ItemStack.loadItemStackFromNBT( + stack.getTagCompound() + .getCompoundTag(MACHINE_KEY)); + if (machine != null) { + return Optional.of(machine.getDisplayName()); + } + } catch (Exception ignored) {} + } + + return Optional.empty(); + } + + @NotNull + private Optional<GlobalMetricsCoverDatabase.Data> getDataFromDatabase(ICardWrapper card) { + return getDataFromDatabase(card.getItemStack()); + } + + @NotNull + private Optional<GlobalMetricsCoverDatabase.Data> getDataFromDatabase(ItemStack stack) { + return getUUID(stack).flatMap(GlobalMetricsCoverDatabase::getData); + } + + @NotNull + private static PanelString panelString(String info) { + return panelString(info, false); + } + + @NotNull + private static PanelString panelString(String info, boolean center) { + final PanelString panelString = new PanelString(); + if (center) { + panelString.textCenter = info; + } else { + panelString.textLeft = info; + } + return panelString; + + } +} diff --git a/src/main/java/gregtech/common/items/GT_DepletetCell_Item.java b/src/main/java/gregtech/common/items/GT_DepletetCell_Item.java new file mode 100644 index 0000000000..df14adc39b --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_DepletetCell_Item.java @@ -0,0 +1,49 @@ +package gregtech.common.items; + +import net.minecraft.item.ItemStack; + +import gregtech.api.items.GT_RadioactiveCellIC_Item; +import ic2.api.reactor.IReactor; + +public class GT_DepletetCell_Item extends GT_RadioactiveCellIC_Item { + + public GT_DepletetCell_Item(String aUnlocalized, String aEnglish, int aRadiation) { + super(aUnlocalized, aEnglish, 1, 1, 0, aRadiation, 0, null, false); + } + + @Override + public void processChamber(IReactor paramIReactor, ItemStack paramItemStack, int paramInt1, int paramInt2, + boolean paramBoolean) {} + + @Override + public boolean acceptUraniumPulse(IReactor paramIReactor, ItemStack paramItemStack1, ItemStack paramItemStack2, + int paramInt1, int paramInt2, int paramInt3, int paramInt4, boolean paramBoolean) { + return false; + } + + @Override + public boolean canStoreHeat(IReactor paramIReactor, ItemStack paramItemStack, int paramInt1, int paramInt2) { + return false; + } + + @Override + public int getMaxHeat(IReactor paramIReactor, ItemStack paramItemStack, int paramInt1, int paramInt2) { + return 0; + } + + @Override + public int getCurrentHeat(IReactor paramIReactor, ItemStack paramItemStack, int paramInt1, int paramInt2) { + return 0; + } + + @Override + public int alterHeat(IReactor paramIReactor, ItemStack paramItemStack, int paramInt1, int paramInt2, + int paramInt3) { + return 0; + } + + @Override + public float influenceExplosion(IReactor paramIReactor, ItemStack paramItemStack) { + return 0.0F; + } +} diff --git a/src/main/java/gregtech/common/items/GT_FluidDisplayItem.java b/src/main/java/gregtech/common/items/GT_FluidDisplayItem.java new file mode 100644 index 0000000000..850fe21811 --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_FluidDisplayItem.java @@ -0,0 +1,181 @@ +package gregtech.common.items; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.stream.Stream; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.IIcon; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.items.GT_Generic_Item; +import gregtech.api.util.GT_Utility; + +public class GT_FluidDisplayItem extends GT_Generic_Item { + + private static final Map<Fluid, String> sFluidTooltips = new HashMap<>(); + + public GT_FluidDisplayItem() { + super("GregTech_FluidDisplay", "Fluid Display", null); + ItemList.Display_Fluid.set(this); + } + + @Override + protected void addAdditionalToolTips(List<String> aList, ItemStack aStack, EntityPlayer aPlayer) { + if (FluidRegistry.getFluid(aStack.getItemDamage()) != null) { + String tChemicalFormula = getChemicalFormula( + new FluidStack(FluidRegistry.getFluid(aStack.getItemDamage()), 1)); + if (!tChemicalFormula.isEmpty()) + aList.add(EnumChatFormatting.YELLOW + tChemicalFormula + EnumChatFormatting.RESET); + } + NBTTagCompound aNBT = aStack.getTagCompound(); + if (GT_Values.D1 || Minecraft.getMinecraft().gameSettings.advancedItemTooltips) { + Fluid tFluid = FluidRegistry.getFluid(aStack.getItemDamage()); + if (tFluid != null) { + aList.add("Registry: " + tFluid.getName()); + } + } + if (aNBT != null) { + long tToolTipAmount = aNBT.getLong("mFluidDisplayAmount"); + if (tToolTipAmount > 0L) { + aList.add( + EnumChatFormatting.BLUE + "Amount: " + + GT_Utility.formatNumbers(tToolTipAmount) + + " L" + + EnumChatFormatting.GRAY); + } + aList.add( + EnumChatFormatting.RED + "Temperature: " + + GT_Utility.formatNumbers(aNBT.getLong("mFluidDisplayHeat")) + + " K" + + EnumChatFormatting.GRAY); + aList.add( + EnumChatFormatting.GREEN + + String.format(transItem("018", "State: %s"), aNBT.getBoolean("mFluidState") ? "Gas" : "Liquid") + + EnumChatFormatting.GRAY); + } + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aIconRegister) {} + + @Override + public IIcon getIconFromDamage(int aMetaData) { + return Stream.of(FluidRegistry.getFluid(aMetaData), FluidRegistry.WATER) + .filter(Objects::nonNull) + .map(Fluid::getStillIcon) + .filter(Objects::nonNull) + .findFirst() + .orElseThrow(IllegalStateException::new); + } + + @Override + @SideOnly(Side.CLIENT) + public int getColorFromItemStack(ItemStack aStack, int aRenderPass) { + Fluid tFluid = FluidRegistry.getFluid(aStack.getItemDamage()); + return tFluid == null ? 16777215 : tFluid.getColor(); + } + + @Override + public int getSpriteNumber() { + return 0; + } + + @Override + public String getUnlocalizedName(ItemStack aStack) { + if (aStack != null) { + return GT_Utility.getFluidName(FluidRegistry.getFluid(aStack.getItemDamage()), false); + } + return ""; + } + + @Override + public String getItemStackDisplayName(ItemStack aStack) { + if (aStack != null) { + return GT_Utility.getFluidName(FluidRegistry.getFluid(aStack.getItemDamage()), true); + } + return ""; + } + + @SideOnly(Side.CLIENT) + public static String getChemicalFormula(FluidStack aRealFluid) { + return sFluidTooltips.computeIfAbsent(aRealFluid.getFluid(), fluid -> { + for (ItemStack tContainer : GT_Utility.getContainersFromFluid(aRealFluid)) { + if (isCell(tContainer)) { + Materials tMaterial = getMaterialFromCell(tContainer); + if (!tMaterial.equals(Materials._NULL)) { + if (tMaterial.mChemicalFormula.equals("?")) { + return ""; + } else { + return tMaterial.mChemicalFormula; + } + } else { + // For GT++ Fluid Display + // GT++ didn't register a Material in GT, so I have too find the Chemical Formula in its cell's + // tooltip + List<String> tTooltip = tContainer.getTooltip(null, true); + for (String tInfo : tTooltip) { + if (!tInfo.contains(" ") && !tInfo.contains(":") && tTooltip.indexOf(tInfo) != 0) { + return tInfo; + } + } + } + } + } + return ""; + }); + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item aItem, CreativeTabs aTab, List<ItemStack> aList) { + if (GT_Values.D1) { + int i = 0; + for (int j = FluidRegistry.getMaxID(); i < j; i++) { + ItemStack tStack = GT_Utility.getFluidDisplayStack(FluidRegistry.getFluid(i)); + if (tStack != null) { + aList.add(tStack); + } + } + } + } + + public static boolean isCell(ItemStack tItemStack) { + for (int tOreDict : OreDictionary.getOreIDs(tItemStack)) { + String tOreDictName = OreDictionary.getOreName(tOreDict); + if (tOreDictName.startsWith("cell")) return true; + } + return false; + } + + public static Materials getMaterialFromCell(ItemStack tItemStack) { + for (int tOreDict : OreDictionary.getOreIDs(tItemStack)) { + String tOreDictName = OreDictionary.getOreName(tOreDict); + if (tOreDictName.startsWith("cell")) { + return Materials.getRealMaterial( + tOreDictName.replace("cell", "") + .replace("Molten", "") + .replace("Plasma", "")); + } + } + return Materials._NULL; + } +} diff --git a/src/main/java/gregtech/common/items/GT_IntegratedCircuit_Item.java b/src/main/java/gregtech/common/items/GT_IntegratedCircuit_Item.java new file mode 100644 index 0000000000..0dc5000e7a --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_IntegratedCircuit_Item.java @@ -0,0 +1,328 @@ +package gregtech.common.items; + +import static gregtech.GT_Mod.GT_FML_LOGGER; +import static gregtech.api.enums.Mods.GregTech; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.function.BiFunction; +import java.util.function.Predicate; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.ChatComponentTranslation; +import net.minecraft.util.IIcon; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraftforge.common.util.Constants; +import net.minecraftforge.common.util.FakePlayer; + +import org.apache.commons.lang3.tuple.Pair; + +import com.gtnewhorizons.modularui.api.UIInfos; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +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.OrePrefixes; +import gregtech.api.interfaces.INetworkUpdatableItem; +import gregtech.api.items.GT_Generic_Item; +import gregtech.api.net.GT_Packet_UpdateItem; +import gregtech.api.objects.XSTR; +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_Utility; +import gregtech.common.gui.modularui.uifactory.SelectItemUIFactory; + +public class GT_IntegratedCircuit_Item extends GT_Generic_Item implements INetworkUpdatableItem { + + private static final String aTextEmptyRow = " "; + private static final List<ItemStack> ALL_VARIANTS = new ArrayList<>(); + protected final IIcon[] mIconDamage = new IIcon[25]; + + public GT_IntegratedCircuit_Item() { + super("integrated_circuit", "Programmed Circuit", ""); + setHasSubtypes(true); + setMaxDamage(0); + + ItemList.Circuit_Integrated.set(this); + + ALL_VARIANTS.add(new ItemStack(this, 0, 0)); + for (int i = 1; i <= 24; i++) { + ItemStack aStack = new ItemStack(this, 0, i); + GregTech_API.registerConfigurationCircuit(aStack, 1); + ALL_VARIANTS.add(aStack); + } + + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 0L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { OrePrefixes.circuit.get(Materials.Basic) }); + long bits = GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE; + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 1L), + bits, + new Object[] { "d ", " P ", aTextEmptyRow, 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 2L), + bits, + new Object[] { " d ", " P ", aTextEmptyRow, 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 3L), + bits, + new Object[] { " d", " P ", aTextEmptyRow, 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 4L), + bits, + new Object[] { aTextEmptyRow, " Pd", aTextEmptyRow, 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 5L), + bits, + new Object[] { aTextEmptyRow, " P ", " d", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 6L), + bits, + new Object[] { aTextEmptyRow, " P ", " d ", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 7L), + bits, + new Object[] { aTextEmptyRow, " P ", "d ", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 8L), + bits, + new Object[] { aTextEmptyRow, "dP ", aTextEmptyRow, 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 9L), + bits, + new Object[] { "P d", aTextEmptyRow, aTextEmptyRow, 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 10L), + bits, + new Object[] { "P ", " d", aTextEmptyRow, 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 11L), + bits, + new Object[] { "P ", aTextEmptyRow, " d", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 12L), + bits, + new Object[] { "P ", aTextEmptyRow, " d ", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 13L), + bits, + new Object[] { " P", aTextEmptyRow, " d", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 14L), + bits, + new Object[] { " P", aTextEmptyRow, " d ", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 15L), + bits, + new Object[] { " P", aTextEmptyRow, "d ", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 16L), + bits, + new Object[] { " P", "d ", aTextEmptyRow, 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 17L), + bits, + new Object[] { aTextEmptyRow, aTextEmptyRow, "d P", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 18L), + bits, + new Object[] { aTextEmptyRow, "d ", " P", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 19L), + bits, + new Object[] { "d ", aTextEmptyRow, " P", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 20L), + bits, + new Object[] { " d ", aTextEmptyRow, " P", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 21L), + bits, + new Object[] { "d ", aTextEmptyRow, "P ", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 22L), + bits, + new Object[] { " d ", aTextEmptyRow, "P ", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 23L), + bits, + new Object[] { " d", aTextEmptyRow, "P ", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Circuit_Integrated.getWithDamage(1L, 24L), + bits, + new Object[] { aTextEmptyRow, " d", "P ", 'P', ItemList.Circuit_Integrated.getWildcard(1L) }); + } + + private static String getModeString(int aMetaData) { + return switch ((byte) (aMetaData >>> 8)) { + case 0 -> "=="; + case 1 -> "<="; + case 2 -> ">="; + case 3 -> "<"; + case 4 -> ">"; + default -> ""; + }; + } + + private static String getConfigurationString(int aMetaData) { + return getModeString(aMetaData) + " " + (byte) (aMetaData & 0xFF); + } + + @Override + public void addAdditionalToolTips(List<String> aList, ItemStack aStack, EntityPlayer aPlayer) { + super.addAdditionalToolTips(aList, aStack, aPlayer); + aList.add( + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".configuration", "Configuration: ") + + getConfigurationString(getDamage(aStack))); + aList.add( + GT_LanguageManager + .addStringLocalization(getUnlocalizedName() + ".tooltip.0", "Right click to reconfigure")); + aList.add( + GT_LanguageManager.addStringLocalization( + getUnlocalizedName() + ".tooltip.1", + "Needs a screwdriver or circuit programming tool")); + } + + @Override + public String getUnlocalizedName(ItemStack aStack) { + return getUnlocalizedName(); + } + + @Override + @SideOnly(Side.CLIENT) + public final void getSubItems(Item aItem, CreativeTabs aCreativeTab, List<ItemStack> aList) { + aList.add(new ItemStack(this, 1, 0)); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aIconRegister) { + super.registerIcons(aIconRegister); + for (int i = 0; i < mIconDamage.length; i++) { + mIconDamage[i] = aIconRegister + .registerIcon(GregTech.getResourcePath(GT_Config.troll ? "troll" : getUnlocalizedName() + "/" + i)); + } + if (GregTech_API.sPostloadFinished) { + GT_Log.out.println("GT_Mod: Starting Item Icon Load Phase"); + GT_FML_LOGGER.info("GT_Mod: Starting Item Icon Load Phase"); + GregTech_API.sItemIcons = aIconRegister; + try { + for (Runnable tRunnable : GregTech_API.sGTItemIconload) { + tRunnable.run(); + } + } catch (Throwable e) { + e.printStackTrace(GT_Log.err); + } + GT_Log.out.println("GT_Mod: Finished Item Icon Load Phase"); + GT_FML_LOGGER.info("GT_Mod: Finished Item Icon Load Phase"); + } + } + + @Override + public IIcon getIconFromDamage(int aMetaData) { + byte circuitMode = ((byte) (aMetaData & 0xFF)); // Mask out the MSB Comparison Mode Bits. See: getModeString + return mIconDamage[circuitMode < mIconDamage.length ? circuitMode : 0]; + } + + @Override + public boolean receive(ItemStack stack, EntityPlayerMP player, NBTTagCompound tag) { + int meta = tag.hasKey("meta", Constants.NBT.TAG_BYTE) ? tag.getByte("meta") : -1; + if (meta < 0 || meta > 24) return true; + + if (!player.capabilities.isCreativeMode) { + Pair<Integer, BiFunction<ItemStack, EntityPlayerMP, ItemStack>> toolIndex = findConfiguratorInInv(player); + if (toolIndex == null) return true; + + ItemStack[] mainInventory = player.inventory.mainInventory; + mainInventory[toolIndex.getKey()] = toolIndex.getValue() + .apply(mainInventory[toolIndex.getKey()], player); + } + stack.setItemDamage(meta); + + return true; + } + + @Override + public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) { + // nothing on server side or fake player + if (player instanceof FakePlayer || !world.isRemote) return stack; + // check if any screwdriver + ItemStack configuratorStack; + if (player.capabilities.isCreativeMode) { + configuratorStack = null; + } else { + Pair<Integer, ?> configurator = findConfiguratorInInv(player); + if (configurator == null) { + int count; + try { + count = Integer + .parseInt(StatCollector.translateToLocal("GT5U.item.programmed_circuit.no_screwdriver.count")); + } catch (NumberFormatException e) { + player.addChatComponentMessage( + new ChatComponentText( + "Error in translation GT5U.item.programmed_circuit.no_screwdriver.count: " + + e.getMessage())); + count = 1; + } + player.addChatComponentMessage( + new ChatComponentTranslation( + "GT5U.item.programmed_circuit.no_screwdriver." + XSTR.XSTR_INSTANCE.nextInt(count))); + return stack; + } + configuratorStack = player.inventory.mainInventory[configurator.getKey()]; + } + openSelectorGui(configuratorStack, stack.getItemDamage(), player); + return stack; + } + + private void openSelectorGui(ItemStack configurator, int meta, EntityPlayer player) { + UIInfos.openClientUI( + player, + buildContext -> new SelectItemUIFactory( + StatCollector.translateToLocal("GT5U.item.programmed_circuit.select.header"), + configurator, + GT_IntegratedCircuit_Item::onConfigured, + ALL_VARIANTS, + meta, + true).createWindow(buildContext)); + } + + private static void onConfigured(ItemStack stack) { + NBTTagCompound tag = new NBTTagCompound(); + tag.setByte("meta", (byte) stack.getItemDamage()); + GT_Values.NW.sendToServer(new GT_Packet_UpdateItem(tag)); + } + + private static Pair<Integer, BiFunction<ItemStack, EntityPlayerMP, ItemStack>> findConfiguratorInInv( + EntityPlayer player) { + ItemStack[] mainInventory = player.inventory.mainInventory; + for (int j = 0, mainInventoryLength = mainInventory.length; j < mainInventoryLength; j++) { + ItemStack toolStack = mainInventory[j]; + + if (!GT_Utility.isStackValid(toolStack)) continue; + + for (Map.Entry<Predicate<ItemStack>, BiFunction<ItemStack, EntityPlayerMP, ItemStack>> p : GregTech_API.sCircuitProgrammerList + .entrySet()) + if (p.getKey() + .test(toolStack)) return Pair.of(j, p.getValue()); + } + return null; + } +} diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java new file mode 100644 index 0000000000..ae1d2568f7 --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java @@ -0,0 +1,4627 @@ +package gregtech.common.items; + +import static gregtech.api.enums.Mods.GalacticraftMars; +import static gregtech.api.enums.Textures.BlockIcons.COVER_WOOD_PLATE; +import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASINGS; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ACTIVITYDETECTOR; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ACTIVITYDETECTOR_GLOW; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ARM; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_CONTROLLER; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_CONVEYOR; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_CRAFTING; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_DRAIN; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ENERGYDETECTOR; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FLUIDDETECTOR; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FLUID_STORAGE_MONITOR0; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ITEMDETECTOR; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_MAINTENANCE_DETECTOR; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_PUMP; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_REDSTONE_RECEIVER; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_REDSTONE_TRANSMITTER; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_SCREEN; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_SCREEN_GLOW; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_SHUTTER; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_VALVE; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL_8V; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL_EV; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL_HV; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL_IV; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL_LV; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL_LuV; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL_MV; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL_UV; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL_ZPM; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.cannerRecipes; +import static gregtech.api.recipe.RecipeMaps.compressorRecipes; +import static gregtech.api.recipe.RecipeMaps.packagerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.client.GT_TooltipHandler.Tier.ERV; +import static gregtech.client.GT_TooltipHandler.Tier.EV; +import static gregtech.client.GT_TooltipHandler.Tier.HV; +import static gregtech.client.GT_TooltipHandler.Tier.IV; +import static gregtech.client.GT_TooltipHandler.Tier.LV; +import static gregtech.client.GT_TooltipHandler.Tier.LuV; +import static gregtech.client.GT_TooltipHandler.Tier.MAX; +import static gregtech.client.GT_TooltipHandler.Tier.MV; +import static gregtech.client.GT_TooltipHandler.Tier.ULV; +import static gregtech.client.GT_TooltipHandler.Tier.UMV; +import static gregtech.client.GT_TooltipHandler.Tier.UV; +import static gregtech.client.GT_TooltipHandler.Tier.UXV; +import static gregtech.client.GT_TooltipHandler.Tier.ZPM; +import static gregtech.client.GT_TooltipHandler.registerTieredTooltip; + +import java.util.Collection; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import net.minecraft.block.Block; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.EnumAction; +import net.minecraft.item.ItemStack; +import net.minecraft.potion.Potion; +import net.minecraft.util.MathHelper; + +import gregtech.api.GregTech_API; +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.OreDictNames; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TC_Aspects; +import gregtech.api.enums.TierEU; +import gregtech.api.interfaces.IItemBehaviour; +import gregtech.api.interfaces.ITexture; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.items.GT_MetaGenerated_Item_X32; +import gregtech.api.objects.ItemData; +import gregtech.api.objects.MaterialStack; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_FoodStat; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gregtech.common.covers.GT_Cover_Arm; +import gregtech.common.covers.GT_Cover_ControlsWork; +import gregtech.common.covers.GT_Cover_Conveyor; +import gregtech.common.covers.GT_Cover_Crafting; +import gregtech.common.covers.GT_Cover_DoesWork; +import gregtech.common.covers.GT_Cover_Drain; +import gregtech.common.covers.GT_Cover_EUMeter; +import gregtech.common.covers.GT_Cover_FluidLimiter; +import gregtech.common.covers.GT_Cover_FluidRegulator; +import gregtech.common.covers.GT_Cover_FluidStorageMonitor; +import gregtech.common.covers.GT_Cover_Fluidfilter; +import gregtech.common.covers.GT_Cover_ItemFilter; +import gregtech.common.covers.GT_Cover_ItemMeter; +import gregtech.common.covers.GT_Cover_LiquidMeter; +import gregtech.common.covers.GT_Cover_NeedMaintainance; +import gregtech.common.covers.GT_Cover_PlayerDetector; +import gregtech.common.covers.GT_Cover_Pump; +import gregtech.common.covers.GT_Cover_RedstoneReceiverExternal; +import gregtech.common.covers.GT_Cover_RedstoneReceiverInternal; +import gregtech.common.covers.GT_Cover_RedstoneTransmitterExternal; +import gregtech.common.covers.GT_Cover_RedstoneTransmitterInternal; +import gregtech.common.covers.GT_Cover_Screen; +import gregtech.common.covers.GT_Cover_Shutter; +import gregtech.common.covers.GT_Cover_SolarPanel; +import gregtech.common.covers.GT_Cover_SteamRegulator; +import gregtech.common.covers.GT_Cover_SteamValve; +import gregtech.common.items.behaviors.Behaviour_Arrow_Potion; +import gregtech.common.items.behaviors.Behaviour_Cover_Tool; +import gregtech.common.items.behaviors.Behaviour_DataOrb; +import gregtech.common.items.behaviors.Behaviour_DataStick; +import gregtech.common.items.behaviors.Behaviour_Lighter; +import gregtech.common.items.behaviors.Behaviour_PrintedPages; +import gregtech.common.items.behaviors.Behaviour_Scanner; +import gregtech.common.items.behaviors.Behaviour_SensorKit; +import gregtech.common.items.behaviors.Behaviour_Sonictron; +import gregtech.common.items.behaviors.Behaviour_Spray_Color; +import gregtech.common.items.behaviors.Behaviour_Spray_Color_Remover; +import gregtech.common.items.behaviors.Behaviour_WrittenBook; + +public class GT_MetaGenerated_Item_01 extends GT_MetaGenerated_Item_X32 { + + public static GT_MetaGenerated_Item_01 INSTANCE; + private final String mToolTipPurify = GT_LanguageManager + .addStringLocalization("metaitem.01.tooltip.purify", "Throw into Cauldron to get clean Dust"); + private static final String aTextArrow = " A"; + private static final String aTextStick = " S "; + private static final String aTextFeather = "F "; + private static final String aTextEmptyRow = " "; + private static final String aTextShape = " P "; + private static final String PartCoverText = " L/t ("; + private static final String PartCoverText2 = " L/s) as Cover"; + private static final String PartNotCoverText = "Cannot be used as a Cover"; + private static final String RAText = "Grabs from and inserts into specific slots"; + private static final String FRText1 = "Configurable up to "; + private static final String FRText2 = " L/sec (as Cover)/n Rightclick/Screwdriver-rightclick/Shift-screwdriver-rightclick/n to adjust the pump speed by 1/16/256 L/sec per click"; + + public GT_MetaGenerated_Item_01() { + super( + "metaitem.01", + OrePrefixes.dustTiny, + OrePrefixes.dustSmall, + OrePrefixes.dust, + OrePrefixes.dustImpure, + OrePrefixes.dustPure, + OrePrefixes.crushed, + OrePrefixes.crushedPurified, + OrePrefixes.crushedCentrifuged, + OrePrefixes.gem, + OrePrefixes.nugget, + null, + OrePrefixes.ingot, + OrePrefixes.ingotHot, + OrePrefixes.ingotDouble, + OrePrefixes.ingotTriple, + OrePrefixes.ingotQuadruple, + OrePrefixes.ingotQuintuple, + OrePrefixes.plate, + OrePrefixes.plateDouble, + OrePrefixes.plateTriple, + OrePrefixes.plateQuadruple, + OrePrefixes.plateQuintuple, + OrePrefixes.plateDense, + OrePrefixes.stick, + OrePrefixes.lens, + OrePrefixes.round, + OrePrefixes.bolt, + OrePrefixes.screw, + OrePrefixes.ring, + OrePrefixes.foil, + OrePrefixes.cell, + OrePrefixes.cellPlasma); + INSTANCE = this; + + int tLastID = 0; + + setBurnValue(17000 + Materials.Wood.mMetaItemSubID, 1600); + GT_OreDictUnificator.addToBlacklist(new ItemStack(this, 1, 17000 + Materials.Wood.mMetaItemSubID)); + + // Compressor recipe + { + GT_Values.RA.stdBuilder() + .itemInputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 8L)) + .itemOutputs(new ItemStack(this, 1, 17000 + Materials.Wood.mMetaItemSubID)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + } + + GregTech_API.registerCover( + new ItemStack(this, 1, 17000 + Materials.Wood.mMetaItemSubID), + TextureFactory.of(COVER_WOOD_PLATE), + null); + + ItemStack tStack = new ItemStack(this, 1, 17000 + Materials.Wood.mMetaItemSubID); + tStack.setStackDisplayName("The holy Planks of Sengir"); + GT_Utility.ItemNBT.addEnchantment(tStack, Enchantment.smite, 10); + GT_ModHandler.addCraftingRecipe( + tStack, + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { "XXX", "XDX", "XXX", 'X', OrePrefixes.gem.get(Materials.NetherStar), 'D', + new ItemStack(Blocks.dragon_egg, 1, 32767) }); + + ItemList.Credit_Greg_Copper.set(addItem(tLastID = 0, "Copper GT Credit", "0.125 Credits")); + ItemList.Credit_Greg_Cupronickel.set( + addItem(tLastID = 1, "Cupronickel GT Credit", "1 Credit", new ItemData(Materials.Cupronickel, 907200L))); + ItemList.Credit_Greg_Silver.set( + addItem( + tLastID = 2, + "Silver GT Credit", + "8 Credits", + new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 1L))); + ItemList.Credit_Greg_Gold.set(addItem(tLastID = 3, "Gold GT Credit", "64 Credits")); + ItemList.Credit_Greg_Platinum.set(addItem(tLastID = 4, "Platinum GT Credit", "512 Credits")); + ItemList.Credit_Greg_Osmium.set(addItem(tLastID = 5, "Osmium GT Credit", "4,096 Credits")); + ItemList.Credit_Greg_Naquadah.set(addItem(tLastID = 6, "Naquadah GT Credit", "32,768 Credits")); + ItemList.Credit_Greg_Neutronium.set(addItem(tLastID = 7, "Neutronium GT Credit", "262,144 Credits")); + ItemList.Coin_Gold_Ancient.set( + addItem( + tLastID = 8, + "Ancient Gold Coin", + "Found in ancient Ruins", + new ItemData(Materials.Gold, 907200L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 8L))); + ItemList.Coin_Doge.set( + addItem( + tLastID = 9, + "Doge Coin", + "wow much coin how money so crypto plz mine v rich very currency wow", + new ItemData(Materials.Brass, 907200L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 1L))); + ItemList.Coin_Chocolate.set( + addItem( + tLastID = 10, + "Chocolate Coin", + "Wrapped in Gold", + new ItemData(Materials.Gold, OrePrefixes.foil.mMaterialAmount), + new GT_FoodStat( + 1, + 0.1F, + EnumAction.eat, + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Gold, 1L), + true, + false, + false, + Potion.moveSpeed.id, + 200, + 1, + 100))); + ItemList.Credit_Copper.set(addItem(tLastID = 11, "Industrial Copper Credit", "0.125 Credits")); + + ItemList.Credit_Silver.set( + addItem( + tLastID = 13, + "Industrial Silver Credit", + "8 Credits", + new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 1L))); + ItemList.Credit_Gold.set(addItem(tLastID = 14, "Industrial Gold Credit", "64 Credits")); + ItemList.Credit_Platinum.set(addItem(tLastID = 15, "Industrial Platinum Credit", "512 Credits")); + ItemList.Credit_Osmium.set(addItem(tLastID = 16, "Industrial Osmium Credit", "4096 Credits")); + + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Coin_Chocolate.get(1L), + new Object[] { OrePrefixes.dust.get(Materials.Cocoa), OrePrefixes.dust.get(Materials.Milk), + OrePrefixes.dust.get(Materials.Sugar), OrePrefixes.foil.get(Materials.Gold) }); + + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Copper.get(8L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Iron }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Iron.get(8L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Silver }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Silver.get(8L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Gold }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Gold.get(8L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Platinum }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Platinum.get(8L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Osmium }); + + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Iron.get(1L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Copper, ItemList.Credit_Copper, ItemList.Credit_Copper, + ItemList.Credit_Copper, ItemList.Credit_Copper, ItemList.Credit_Copper, ItemList.Credit_Copper, + ItemList.Credit_Copper }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Silver.get(1L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Iron, ItemList.Credit_Iron, ItemList.Credit_Iron, ItemList.Credit_Iron, + ItemList.Credit_Iron, ItemList.Credit_Iron, ItemList.Credit_Iron, ItemList.Credit_Iron }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Gold.get(1L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Silver, ItemList.Credit_Silver, ItemList.Credit_Silver, + ItemList.Credit_Silver, ItemList.Credit_Silver, ItemList.Credit_Silver, ItemList.Credit_Silver, + ItemList.Credit_Silver }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Platinum.get(1L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Gold, ItemList.Credit_Gold, ItemList.Credit_Gold, ItemList.Credit_Gold, + ItemList.Credit_Gold, ItemList.Credit_Gold, ItemList.Credit_Gold, ItemList.Credit_Gold }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Osmium.get(1L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Platinum, ItemList.Credit_Platinum, ItemList.Credit_Platinum, + ItemList.Credit_Platinum, ItemList.Credit_Platinum, ItemList.Credit_Platinum, ItemList.Credit_Platinum, + ItemList.Credit_Platinum }); + + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Copper.get(8L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Cupronickel }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Cupronickel.get(8L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Silver }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Silver.get(8L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Gold }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Gold.get(8L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Platinum }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Platinum.get(8L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Osmium }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Osmium.get(8L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Naquadah }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Naquadah.get(8L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Neutronium }); + + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Cupronickel.get(1L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Copper, ItemList.Credit_Greg_Copper, ItemList.Credit_Greg_Copper, + ItemList.Credit_Greg_Copper, ItemList.Credit_Greg_Copper, ItemList.Credit_Greg_Copper, + ItemList.Credit_Greg_Copper, ItemList.Credit_Greg_Copper }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Silver.get(1L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Cupronickel, ItemList.Credit_Greg_Cupronickel, + ItemList.Credit_Greg_Cupronickel, ItemList.Credit_Greg_Cupronickel, ItemList.Credit_Greg_Cupronickel, + ItemList.Credit_Greg_Cupronickel, ItemList.Credit_Greg_Cupronickel, ItemList.Credit_Greg_Cupronickel }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Gold.get(1L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Silver, ItemList.Credit_Greg_Silver, ItemList.Credit_Greg_Silver, + ItemList.Credit_Greg_Silver, ItemList.Credit_Greg_Silver, ItemList.Credit_Greg_Silver, + ItemList.Credit_Greg_Silver, ItemList.Credit_Greg_Silver }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Platinum.get(1L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Gold, ItemList.Credit_Greg_Gold, ItemList.Credit_Greg_Gold, + ItemList.Credit_Greg_Gold, ItemList.Credit_Greg_Gold, ItemList.Credit_Greg_Gold, + ItemList.Credit_Greg_Gold, ItemList.Credit_Greg_Gold }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Osmium.get(1L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Platinum, ItemList.Credit_Greg_Platinum, ItemList.Credit_Greg_Platinum, + ItemList.Credit_Greg_Platinum, ItemList.Credit_Greg_Platinum, ItemList.Credit_Greg_Platinum, + ItemList.Credit_Greg_Platinum, ItemList.Credit_Greg_Platinum }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Naquadah.get(1L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Osmium, ItemList.Credit_Greg_Osmium, ItemList.Credit_Greg_Osmium, + ItemList.Credit_Greg_Osmium, ItemList.Credit_Greg_Osmium, ItemList.Credit_Greg_Osmium, + ItemList.Credit_Greg_Osmium, ItemList.Credit_Greg_Osmium }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Credit_Greg_Neutronium.get(1L), + GT_ModHandler.RecipeBits.KEEPNBT | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Credit_Greg_Naquadah, ItemList.Credit_Greg_Naquadah, ItemList.Credit_Greg_Naquadah, + ItemList.Credit_Greg_Naquadah, ItemList.Credit_Greg_Naquadah, ItemList.Credit_Greg_Naquadah, + ItemList.Credit_Greg_Naquadah, ItemList.Credit_Greg_Naquadah }); + + ItemList.Component_Minecart_Wheels_Iron.set( + addItem( + tLastID = 100, + "Iron Minecart Wheels", + "To get things rolling", + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 2L))); + ItemList.Component_Minecart_Wheels_Steel.set( + addItem( + tLastID = 101, + "Steel Minecart Wheels", + "To get things rolling", + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 2L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Component_Minecart_Wheels_Iron.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { " h ", "RSR", " w ", 'R', OrePrefixes.ring.get(Materials.AnyIron), 'S', + OrePrefixes.stick.get(Materials.AnyIron) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Component_Minecart_Wheels_Steel.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { " h ", "RSR", " w ", 'R', OrePrefixes.ring.get(Materials.Steel), 'S', + OrePrefixes.stick.get(Materials.Steel) }); + + ItemList.CompressedFireclay.set(addItem(tLastID = 110, "Compressed Fireclay", "Brick-shaped")); + ItemList.Firebrick.set(addItem(tLastID = 111, "Firebrick", "Heat resistant")); + + ItemList.Arrow_Head_Glass_Emtpy.set( + addItem( + tLastID = 200, + "Empty Glass Arrow Head", + "Fill with Potions before use", + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L))); + ItemList.Arrow_Head_Glass_Poison.set( + addItem( + tLastID = 201, + "Poison Glass Arrow Head", + "Glass Arrow filled with Poison", + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Head_Glass_Poison_Long.set( + addItem( + tLastID = 202, + "Poison Glass Arrow Head", + "Glass Arrow filled with stretched Poison", + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Head_Glass_Poison_Strong.set( + addItem( + tLastID = 203, + "Poison Glass Arrow Head", + "Glass Arrow filled with strong Poison", + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Head_Glass_Slowness.set( + addItem( + tLastID = 204, + "Slowness Glass Arrow Head", + "Glass Arrow filled with Laming Brew", + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Head_Glass_Slowness_Long.set( + addItem( + tLastID = 205, + "Slowness Glass Arrow Head", + "Glass Arrow filled with stretched Laming Brew", + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Head_Glass_Weakness.set( + addItem( + tLastID = 206, + "Weakness Glass Arrow Head", + "Glass Arrow filled with Weakening Brew", + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Head_Glass_Weakness_Long.set( + addItem( + tLastID = 207, + "Weakness Glass Arrow Head", + "Glass Arrow filled with stretched Weakening Brew", + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Head_Glass_Holy_Water.set( + addItem( + tLastID = 208, + "Holy Water Glass Arrow Head", + "Glass Arrow filled with Holy Water", + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AURAM, 1L))); + + ItemList.Arrow_Wooden_Glass_Emtpy.set( + addItem( + tLastID = 225, + "Regular Glass Vial Arrow", + "Empty Glass Arrow", + new Behaviour_Arrow_Potion(1.0F, 6.0F), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L))); + ItemList.Arrow_Wooden_Glass_Poison.set( + addItem( + tLastID = 226, + "Regular Poison Arrow", + "Glass Arrow filled with Poison", + new Behaviour_Arrow_Potion(1.0F, 6.0F, Potion.poison.id, 450, 0, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Wooden_Glass_Poison_Long.set( + addItem( + tLastID = 227, + "Regular Poison Arrow", + "Glass Arrow filled with stretched Poison", + new Behaviour_Arrow_Potion(1.0F, 6.0F, Potion.poison.id, 900, 0, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Wooden_Glass_Poison_Strong.set( + addItem( + tLastID = 228, + "Regular Poison Arrow", + "Glass Arrow filled with strong Poison", + new Behaviour_Arrow_Potion(1.0F, 6.0F, Potion.poison.id, 450, 1, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Wooden_Glass_Slowness.set( + addItem( + tLastID = 229, + "Regular Slowness Arrow", + "Glass Arrow filled with Laming Brew", + new Behaviour_Arrow_Potion(1.0F, 6.0F, Potion.moveSlowdown.id, 900, 0, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Wooden_Glass_Slowness_Long.set( + addItem( + tLastID = 230, + "Regular Slowness Arrow", + "Glass Arrow filled with stretched Laming Brew", + new Behaviour_Arrow_Potion(1.0F, 6.0F, Potion.moveSlowdown.id, 1800, 0, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Wooden_Glass_Weakness.set( + addItem( + tLastID = 231, + "Regular Weakness Arrow", + "Glass Arrow filled with Weakening Brew", + new Behaviour_Arrow_Potion(1.0F, 6.0F, Potion.weakness.id, 900, 0, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Wooden_Glass_Weakness_Long.set( + addItem( + tLastID = 232, + "Regular Weakness Arrow", + "Glass Arrow filled with stretched Weakening Brew", + new Behaviour_Arrow_Potion(1.0F, 6.0F, Potion.weakness.id, 1800, 0, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Wooden_Glass_Holy_Water.set( + addItem( + tLastID = 233, + "Regular Holy Water Arrow", + "Glass Arrow filled with Holy Water", + new Behaviour_Arrow_Potion(1.0F, 6.0F, Enchantment.smite, 10), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AURAM, 1L))); + + ItemList.Arrow_Plastic_Glass_Emtpy.set( + addItem( + tLastID = 250, + "Light Glass Vial Arrow", + "Empty Glass Arrow", + new Behaviour_Arrow_Potion(1.5F, 6.0F), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L))); + ItemList.Arrow_Plastic_Glass_Poison.set( + addItem( + tLastID = 251, + "Light Poison Arrow", + "Glass Arrow filled with Poison", + new Behaviour_Arrow_Potion(1.5F, 6.0F, Potion.poison.id, 450, 0, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Plastic_Glass_Poison_Long.set( + addItem( + tLastID = 252, + "Light Poison Arrow", + "Glass Arrow filled with stretched Poison", + new Behaviour_Arrow_Potion(1.5F, 6.0F, Potion.poison.id, 900, 0, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Plastic_Glass_Poison_Strong.set( + addItem( + tLastID = 253, + "Light Poison Arrow", + "Glass Arrow filled with strong Poison", + new Behaviour_Arrow_Potion(1.5F, 6.0F, Potion.poison.id, 450, 1, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Plastic_Glass_Slowness.set( + addItem( + tLastID = 254, + "Light Slowness Arrow", + "Glass Arrow filled with Laming Brew", + new Behaviour_Arrow_Potion(1.5F, 6.0F, Potion.moveSlowdown.id, 900, 0, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Plastic_Glass_Slowness_Long.set( + addItem( + tLastID = 255, + "Light Slowness Arrow", + "Glass Arrow filled with stretched Laming Brew", + new Behaviour_Arrow_Potion(1.5F, 6.0F, Potion.moveSlowdown.id, 1800, 0, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Plastic_Glass_Weakness.set( + addItem( + tLastID = 256, + "Light Weakness Arrow", + "Glass Arrow filled with Weakening Brew", + new Behaviour_Arrow_Potion(1.5F, 6.0F, Potion.weakness.id, 900, 0, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Plastic_Glass_Weakness_Long.set( + addItem( + tLastID = 257, + "Light Weakness Arrow", + "Glass Arrow filled with stretched Weakening Brew", + new Behaviour_Arrow_Potion(1.5F, 6.0F, Potion.weakness.id, 1800, 0, 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L))); + ItemList.Arrow_Plastic_Glass_Holy_Water.set( + addItem( + tLastID = 258, + "Light Holy Water Arrow", + "Glass Arrow filled with Holy Water", + new Behaviour_Arrow_Potion(1.5F, 6.0F, Enchantment.smite, 10), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AURAM, 1L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Wooden_Glass_Emtpy.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Emtpy, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Wood) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Wooden_Glass_Poison.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Poison, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Wood) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Wooden_Glass_Poison_Long.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Poison_Long, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Wood) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Wooden_Glass_Poison_Strong.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Poison_Strong, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Wood) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Wooden_Glass_Slowness.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Slowness, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Wood) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Wooden_Glass_Slowness_Long.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Slowness_Long, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Wood) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Wooden_Glass_Weakness.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Weakness, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Wood) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Wooden_Glass_Weakness_Long.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Weakness_Long, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Wood) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Wooden_Glass_Holy_Water.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Holy_Water, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Wood) }); + + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Plastic_Glass_Emtpy.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Emtpy, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Plastic) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Plastic_Glass_Poison.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Poison, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Plastic) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Plastic_Glass_Poison_Long.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Poison_Long, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Plastic) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Plastic_Glass_Poison_Strong.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Poison_Strong, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Plastic) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Plastic_Glass_Slowness.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Slowness, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Plastic) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Plastic_Glass_Slowness_Long.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Slowness_Long, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Plastic) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Plastic_Glass_Weakness.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Weakness, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Plastic) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Plastic_Glass_Weakness_Long.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Weakness_Long, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Plastic) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Arrow_Plastic_Glass_Holy_Water.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { aTextArrow, aTextStick, aTextFeather, 'A', ItemList.Arrow_Head_Glass_Holy_Water, 'F', + OreDictNames.craftingFeather, 'S', OrePrefixes.stick.get(Materials.Plastic) }); + + ItemList.Shape_Empty.set( + addItem( + tLastID = 300, + "Empty Shape Plate", + "Raw Plate to make Molds and Extruder Shapes", + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 4L))); + + ItemList.Shape_Mold_Plate.set(addItem(tLastID = 301, "Mold (Plate)", "Mold for making Plates")); + ItemList.Shape_Mold_Casing.set(addItem(tLastID = 302, "Mold (Casing)", "Mold for making Item Casings")); + ItemList.Shape_Mold_Gear.set(addItem(tLastID = 303, "Mold (Gear)", "Mold for making Gears")); + ItemList.Shape_Mold_Credit + .set(addItem(tLastID = 304, "Mold (Coinage)", "Secure Mold for making Coins (Don't lose it!)")); + ItemList.Shape_Mold_Bottle.set(addItem(tLastID = 305, "Mold (Bottle)", "Mold for making Bottles")); + ItemList.Shape_Mold_Ingot.set(addItem(tLastID = 306, "Mold (Ingot)", "Mold for making Ingots")); + ItemList.Shape_Mold_Ball.set(addItem(tLastID = 307, "Mold (Ball)", "Mold for making Balls")); + ItemList.Shape_Mold_Block.set(addItem(tLastID = 308, "Mold (Block)", "Mold for making Blocks")); + ItemList.Shape_Mold_Nugget.set(addItem(tLastID = 309, "Mold (Nuggets)", "Mold for making Nuggets")); + ItemList.Shape_Mold_Bun.set(addItem(tLastID = 310, "Mold (Buns)", "Mold for shaping Buns")); + ItemList.Shape_Mold_Bread.set(addItem(tLastID = 311, "Mold (Bread)", "Mold for shaping Breads")); + ItemList.Shape_Mold_Baguette.set(addItem(tLastID = 312, "Mold (Baguette)", "Mold for shaping Baguettes")); + ItemList.Shape_Mold_Cylinder.set(addItem(tLastID = 313, "Mold (Cylinder)", "Mold for shaping Cylinders")); + ItemList.Shape_Mold_Anvil.set(addItem(tLastID = 314, "Mold (Anvil)", "Mold for shaping Anvils")); + ItemList.Shape_Mold_Name + .set(addItem(tLastID = 315, "Mold (Name)", "Mold for naming Items (rename Mold with Anvil)")); + ItemList.Shape_Mold_Arrow.set(addItem(tLastID = 316, "Mold (Arrow Head)", "Mold for making Arrow Heads")); + ItemList.Shape_Mold_Gear_Small.set(addItem(tLastID = 317, "Mold (Small Gear)", "Mold for making small Gears")); + ItemList.Shape_Mold_Rod.set(addItem(tLastID = 318, "Mold (Rod)", "Mold for making Rods")); + ItemList.Shape_Mold_Bolt.set(addItem(tLastID = 319, "Mold (Bolt)", "Mold for making Bolts")); + ItemList.Shape_Mold_Round.set(addItem(tLastID = 320, "Mold (Round)", "Mold for making Rounds")); + ItemList.Shape_Mold_Screw.set(addItem(tLastID = 321, "Mold (Screw)", "Mold for making Screws")); + ItemList.Shape_Mold_Ring.set(addItem(tLastID = 322, "Mold (Ring)", "Mold for making Rings")); + ItemList.Shape_Mold_Rod_Long.set(addItem(tLastID = 323, "Mold (Long Rod)", "Mold for making Long Rods")); + ItemList.Shape_Mold_Rotor.set(addItem(tLastID = 324, "Mold (Rotor)", "Mold for making a Rotor")); + ItemList.Shape_Mold_Turbine_Blade + .set(addItem(tLastID = 325, "Mold (Turbine Blade)", "Mold for making a Turbine Blade")); + ItemList.Shape_Mold_Pipe_Tiny.set(addItem(tLastID = 326, "Mold (Tiny Pipe)", "Mold for making tiny Pipes")); + ItemList.Shape_Mold_Pipe_Small.set(addItem(tLastID = 327, "Mold (Small Pipe)", "Mold for making small Pipes")); + ItemList.Shape_Mold_Pipe_Medium.set(addItem(tLastID = 328, "Mold (Normal Pipe)", "Mold for making Pipes")); + ItemList.Shape_Mold_Pipe_Large.set(addItem(tLastID = 329, "Mold (Large Pipe)", "Mold for making large Pipes")); + ItemList.Shape_Mold_Pipe_Huge + .set(addItem(tLastID = 330, "Mold (Huge Pipe)", "Mold for making full Block Pipes")); + ItemList.Shape_Mold_ToolHeadDrill + .set(addItem(tLastID = 331, "Mold (Drill Head)", "Mold for making Drill Heads")); + GT_ModHandler.removeRecipe( + new ItemStack(Blocks.glass), + null, + new ItemStack(Blocks.glass), + null, + new ItemStack(Blocks.glass)); + + ItemList.Shape_Extruder_Plate + .set(addItem(tLastID = 350, "Extruder Shape (Plate)", "Extruder Shape for making Plates")); + ItemList.Shape_Extruder_Rod + .set(addItem(tLastID = 351, "Extruder Shape (Rod)", "Extruder Shape for making Rods")); + ItemList.Shape_Extruder_Bolt + .set(addItem(tLastID = 352, "Extruder Shape (Bolt)", "Extruder Shape for making Bolts")); + ItemList.Shape_Extruder_Ring + .set(addItem(tLastID = 353, "Extruder Shape (Ring)", "Extruder Shape for making Rings")); + ItemList.Shape_Extruder_Cell + .set(addItem(tLastID = 354, "Extruder Shape (Cell)", "Extruder Shape for making Cells")); + ItemList.Shape_Extruder_Ingot.set( + addItem(tLastID = 355, "Extruder Shape (Ingot)", "Extruder Shape for, wait, can't we just use a Furnace?")); + ItemList.Shape_Extruder_Wire + .set(addItem(tLastID = 356, "Extruder Shape (Wire)", "Extruder Shape for making Wires")); + ItemList.Shape_Extruder_Casing + .set(addItem(tLastID = 357, "Extruder Shape (Casing)", "Extruder Shape for making Item Casings")); + ItemList.Shape_Extruder_Pipe_Tiny + .set(addItem(tLastID = 358, "Extruder Shape (Tiny Pipe)", "Extruder Shape for making tiny Pipes")); + ItemList.Shape_Extruder_Pipe_Small + .set(addItem(tLastID = 359, "Extruder Shape (Small Pipe)", "Extruder Shape for making small Pipes")); + ItemList.Shape_Extruder_Pipe_Medium + .set(addItem(tLastID = 360, "Extruder Shape (Normal Pipe)", "Extruder Shape for making Pipes")); + ItemList.Shape_Extruder_Pipe_Large + .set(addItem(tLastID = 361, "Extruder Shape (Large Pipe)", "Extruder Shape for making large Pipes")); + ItemList.Shape_Extruder_Pipe_Huge + .set(addItem(tLastID = 362, "Extruder Shape (Huge Pipe)", "Extruder Shape for making full Block Pipes")); + ItemList.Shape_Extruder_Block + .set(addItem(tLastID = 363, "Extruder Shape (Block)", "Extruder Shape for making Blocks")); + ItemList.Shape_Extruder_Sword + .set(addItem(tLastID = 364, "Extruder Shape (Sword Blade)", "Extruder Shape for making Swords")); + ItemList.Shape_Extruder_Pickaxe + .set(addItem(tLastID = 365, "Extruder Shape (Pickaxe Head)", "Extruder Shape for making Pickaxes")); + ItemList.Shape_Extruder_Shovel + .set(addItem(tLastID = 366, "Extruder Shape (Shovel Head)", "Extruder Shape for making Shovels")); + ItemList.Shape_Extruder_Axe + .set(addItem(tLastID = 367, "Extruder Shape (Axe Head)", "Extruder Shape for making Axes")); + ItemList.Shape_Extruder_Hoe + .set(addItem(tLastID = 368, "Extruder Shape (Hoe Head)", "Extruder Shape for making Hoes")); + ItemList.Shape_Extruder_Hammer + .set(addItem(tLastID = 369, "Extruder Shape (Hammer Head)", "Extruder Shape for making Hammers")); + ItemList.Shape_Extruder_File + .set(addItem(tLastID = 370, "Extruder Shape (File Head)", "Extruder Shape for making Files")); + ItemList.Shape_Extruder_Saw + .set(addItem(tLastID = 371, "Extruder Shape (Saw Blade)", "Extruder Shape for making Saws")); + ItemList.Shape_Extruder_Gear + .set(addItem(tLastID = 372, "Extruder Shape (Gear)", "Extruder Shape for making Gears")); + ItemList.Shape_Extruder_Bottle + .set(addItem(tLastID = 373, "Extruder Shape (Bottle)", "Extruder Shape for making Bottles")); + ItemList.Shape_Extruder_Rotor + .set(addItem(tLastID = 374, "Extruder Shape (Rotor)", "Extruder Shape for a Rotor")); + ItemList.Shape_Extruder_Small_Gear + .set(addItem(tLastID = 375, "Extruder Shape (Small Gear)", "Extruder Shape for a Small Gear")); + ItemList.Shape_Extruder_Turbine_Blade + .set(addItem(tLastID = 376, "Extruder Shape (Turbine Blade)", "Extruder Shape for a Turbine Blade")); + ItemList.Shape_Extruder_ToolHeadDrill + .set(addItem(tLastID = 377, "Extruder Shape (Drill Head)", "Extruder Shape for a Drill Head")); + + ItemList.Shape_Slicer_Flat.set(addItem(tLastID = 398, "Slicer Blade (Flat)", "Slicer Blade for cutting Flat")); + ItemList.Shape_Slicer_Stripes + .set(addItem(tLastID = 399, "Slicer Blade (Stripes)", "Slicer Blade for cutting Stripes")); + + GT_ModHandler.addCraftingRecipe( + ItemList.Shape_Slicer_Flat.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "hXS", aTextShape, "fXd", 'P', ItemList.Shape_Extruder_Block, 'X', + OrePrefixes.plate.get(Materials.StainlessSteel), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Shape_Slicer_Stripes.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "hXS", "XPX", "fXd", 'P', ItemList.Shape_Extruder_Block, 'X', + OrePrefixes.plate.get(Materials.StainlessSteel), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel) }); + + ItemList.Fuel_Can_Plastic_Empty.set( + addItem( + tLastID = 400, + "Empty Plastic Fuel Can", + "Used to store Fuels", + new ItemData(Materials.Plastic, OrePrefixes.plate.mMaterialAmount * 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 1L))); + ItemList.Fuel_Can_Plastic_Filled.set( + addItem( + tLastID = 401, + "Plastic Fuel Can", + "Burns well in Diesel Generators", + new ItemData(Materials.Plastic, OrePrefixes.plate.mMaterialAmount * 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 1L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Fuel_Can_Plastic_Empty.get(7L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " PP", "P P", "PPP", 'P', OrePrefixes.plate.get(Materials.Plastic) }); + + ItemList.Spray_Empty.set( + addItem( + tLastID = 402, + "Empty Spray Can", + "Used for making Sprays", + new ItemData( + Materials.Tin, + OrePrefixes.plate.mMaterialAmount * 2L, + Materials.Redstone, + OrePrefixes.dust.mMaterialAmount), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 1L))); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 1L), + GT_OreDictUnificator.get(OrePrefixes.cell, Materials.Empty, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Spray_Empty.get(1L)) + .duration(40 * SECONDS) + .eut(1) + .addTo(assemblerRecipes); + + ItemList.Crate_Empty.set( + addItem( + tLastID = 403, + "Empty Crate", + "To Package lots of Material", + new ItemData(Materials.Wood, 3628800L, Materials.Iron, OrePrefixes.screw.mMaterialAmount), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 2L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Crate_Empty.get(4L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { "SWS", "WdW", "SWS", 'W', OrePrefixes.plank.get(Materials.Wood), 'S', + OrePrefixes.screw.get(Materials.AnyIron) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Crate_Empty.get(4L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { "SWS", "WdW", "SWS", 'W', OrePrefixes.plank.get(Materials.Wood), 'S', + OrePrefixes.screw.get(Materials.Steel) }); + + ItemList.ThermosCan_Empty.set( + addItem( + tLastID = 404, + "Empty Thermos Can", + "Keeping hot things hot and cold things cold", + new ItemData( + Materials.Aluminium, + OrePrefixes.plateDouble.mMaterialAmount * 1L + 2L * OrePrefixes.ring.mMaterialAmount), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.GELUM, 1L))); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Aluminium, 1L), + GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Aluminium, 2L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.ThermosCan_Empty.get(1L)) + .duration(40 * SECONDS) + .eut(1) + .addTo(assemblerRecipes); + + ItemList.Large_Fluid_Cell_Steel.set( + addItem( + tLastID = 405, + "Large Steel Fluid Cell", + "", + new ItemData( + Materials.Steel, + OrePrefixes.plateDouble.mMaterialAmount * 4L, + new MaterialStack(Materials.Bronze, OrePrefixes.ring.mMaterialAmount * 4L)), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 2L))); + setFluidContainerStats(32000 + tLastID, 8000L, 64L); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Steel, 4L), + GT_OreDictUnificator.get(OrePrefixes.ring, Materials.AnyBronze, 4L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Large_Fluid_Cell_Steel.get(1L)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + + ItemList.Large_Fluid_Cell_TungstenSteel.set( + addItem( + tLastID = 406, + "Large Tungstensteel Fluid Cell", + "", + new ItemData( + Materials.TungstenSteel, + OrePrefixes.plateDouble.mMaterialAmount * 4L, + new MaterialStack(Materials.Platinum, OrePrefixes.ring.mMaterialAmount * 4L)), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 9L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 7L))); + setFluidContainerStats(32000 + tLastID, 512000L, 32L); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.TungstenSteel, 4L), + GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Platinum, 4L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Large_Fluid_Cell_TungstenSteel.get(1L)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + + ItemList.Large_Fluid_Cell_Aluminium.set( + addItem( + tLastID = 407, + "Large Aluminium Fluid Cell", + "", + new ItemData( + Materials.Aluminium, + OrePrefixes.plateDouble.mMaterialAmount * 4L, + new MaterialStack(Materials.Silver, OrePrefixes.ring.mMaterialAmount * 4L)), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 5L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 3L))); + setFluidContainerStats(32000 + tLastID, 32000L, 64L); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Aluminium, 4L), + GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Silver, 4L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Large_Fluid_Cell_Aluminium.get(1L)) + .duration(10 * SECONDS) + .eut(64) + .addTo(assemblerRecipes); + + ItemList.Large_Fluid_Cell_StainlessSteel.set( + addItem( + tLastID = 408, + "Large Stainless Steel Fluid Cell", + "", + new ItemData( + Materials.StainlessSteel, + OrePrefixes.plateDouble.mMaterialAmount * 4L, + new MaterialStack(Materials.Electrum, OrePrefixes.ring.mMaterialAmount * 4L)), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 6L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 4L))); + setFluidContainerStats(32000 + tLastID, 64000L, 64L); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.StainlessSteel, 4L), + GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Electrum, 4L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Large_Fluid_Cell_StainlessSteel.get(1L)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + + ItemList.Large_Fluid_Cell_Titanium.set( + addItem( + tLastID = 409, + "Large Titanium Fluid Cell", + "", + new ItemData( + Materials.Titanium, + OrePrefixes.plateDouble.mMaterialAmount * 4L, + new MaterialStack(Materials.RoseGold, OrePrefixes.ring.mMaterialAmount * 4L)), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 7L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 5L))); + setFluidContainerStats(32000 + tLastID, 128000L, 64L); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Titanium, 4L), + GT_OreDictUnificator.get(OrePrefixes.ring, Materials.RoseGold, 4L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Large_Fluid_Cell_Titanium.get(1L)) + .duration(10 * SECONDS) + .eut(256) + .addTo(assemblerRecipes); + + ItemList.Large_Fluid_Cell_Chrome.set( + addItem( + tLastID = 410, + "Large Chrome Fluid Cell", + "", + new ItemData( + Materials.Chrome, + OrePrefixes.plateDouble.mMaterialAmount * 4L, + new MaterialStack(Materials.Palladium, OrePrefixes.ring.mMaterialAmount * 4L)), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 6L))); + setFluidContainerStats(32000 + tLastID, 2048000L, 8L); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Chrome, 4L), + GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Palladium, 4L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Large_Fluid_Cell_Chrome.get(1L)) + .duration(10 * SECONDS) + .eut(1024) + .addTo(assemblerRecipes); + + ItemList.Large_Fluid_Cell_Iridium.set( + addItem( + tLastID = 411, + "Large Iridium Fluid Cell", + "", + new ItemData( + Materials.Iridium, + OrePrefixes.plateDouble.mMaterialAmount * 4L, + new MaterialStack(Materials.Naquadah, OrePrefixes.ring.mMaterialAmount * 4L)), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 10L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 8L))); + setFluidContainerStats(32000 + tLastID, 8192000L, 2L); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Iridium, 4L), + GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Naquadah, 4L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Large_Fluid_Cell_Iridium.get(1L)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + + ItemList.Large_Fluid_Cell_Osmium.set( + addItem( + tLastID = 412, + "Large Osmium Fluid Cell", + "", + new ItemData( + Materials.Osmium, + OrePrefixes.plateDouble.mMaterialAmount * 4L, + new MaterialStack(Materials.ElectrumFlux, OrePrefixes.ring.mMaterialAmount * 4L)), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 11L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 9L))); + setFluidContainerStats(32000 + tLastID, 32768000L, 1L); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Osmium, 4L), + GT_OreDictUnificator.get(OrePrefixes.ring, Materials.ElectrumFlux, 4L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Large_Fluid_Cell_Osmium.get(1L)) + .duration(10 * SECONDS) + .eut(4096) + .addTo(assemblerRecipes); + + ItemList.Large_Fluid_Cell_Neutronium.set( + addItem( + tLastID = 413, + "Large Neutronium Fluid Cell", + "", + new ItemData( + Materials.Neutronium, + OrePrefixes.plateDouble.mMaterialAmount * 4L, + new MaterialStack(Materials.Draconium, OrePrefixes.ring.mMaterialAmount * 4L)), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 12L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 10L))); + setFluidContainerStats(32000 + tLastID, 131072000L, 1L); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Neutronium, 4L), + GT_OreDictUnificator.get(OrePrefixes.ring, Materials.Draconium, 4L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Large_Fluid_Cell_Neutronium.get(1L)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + for (byte i = 0; i < 16; i = (byte) (i + 1)) { + ItemList.SPRAY_CAN_DYES[i].set( + addItem( + tLastID = 430 + 2 * i, + "Spray Can (" + Dyes.get(i).mName + ")", + "Full", + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 4L))); + ItemList.SPRAY_CAN_DYES_USED[i].set( + addItem( + tLastID + 1, + "Spray Can (" + Dyes.get(i).mName + ")", + "Used", + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 3L), + SubTag.INVISIBLE)); + IItemBehaviour<GT_MetaBase_Item> tBehaviour = new Behaviour_Spray_Color( + ItemList.Spray_Empty.get(1L), + ItemList.SPRAY_CAN_DYES_USED[i].get(1L), + ItemList.SPRAY_CAN_DYES[i].get(1L), + 512L, + i); + addItemBehavior(32000 + tLastID, tBehaviour); + addItemBehavior(32001 + tLastID, tBehaviour); + } + + ItemList.Spray_Color_Remover.set( + addItem( + tLastID = 465, + "Spray Can Solvent", + "Full", + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERDITIO, 8L))); + ItemList.Spray_Color_Used_Remover.set( + addItem( + tLastID = 466, + "Spray Can Solvent", + "Used", + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 3L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERDITIO, 6L), + SubTag.INVISIBLE)); + IItemBehaviour<GT_MetaBase_Item> tBehaviour = new Behaviour_Spray_Color_Remover( + ItemList.Spray_Empty.get(1L), + ItemList.Spray_Color_Used_Remover.get(1L), + ItemList.Spray_Color_Remover.get(1L), + 1024L); + addItemBehavior(32000 + 465, tBehaviour); + addItemBehavior(32000 + 466, tBehaviour); + + ItemList.Spray_Color_Remover_Empty.set( + addItem( + tLastID = 467, + "Empty Spray Can Solvent Cannister", + "Used for making Spray Can Solvent", + new ItemData( + Materials.Aluminium, + OrePrefixes.plateDouble.mMaterialAmount * 4L, + Materials.Redstone, + OrePrefixes.dust.mMaterialAmount), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 1L))); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 1L), + ItemList.Large_Fluid_Cell_Aluminium.get(1), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Spray_Color_Remover_Empty.get(1L)) + .duration(40 * SECONDS) + .eut(1) + .addTo(assemblerRecipes); + + ItemList.Tool_Matches.set( + addItem( + tLastID = 471, + "Match", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L))); + ItemList.Tool_MatchBox_Used.set( + addItem( + tLastID = 472, + "Match Box", + "This is not a Car", + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L), + SubTag.INVISIBLE)); + ItemList.Tool_MatchBox_Full.set( + addItem( + tLastID = 473, + "Match Box (Full)", + "This is not a Car", + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 2L))); + + tBehaviour = new Behaviour_Lighter(null, ItemList.Tool_Matches.get(1L), ItemList.Tool_Matches.get(1L), 1L); + addItemBehavior(32471, tBehaviour); + tBehaviour = new Behaviour_Lighter( + null, + ItemList.Tool_MatchBox_Used.get(1L), + ItemList.Tool_MatchBox_Full.get(1L), + 16L); + addItemBehavior(32472, tBehaviour); + addItemBehavior(32473, tBehaviour); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.bolt, Materials.Wood, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Phosphorus, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Tool_Matches.get(1L)) + .duration(16 * TICKS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.bolt, Materials.Wood, 1L), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.TricalciumPhosphate, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Tool_Matches.get(1L)) + .duration(16 * TICKS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.bolt, Materials.Wood, 4L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Phosphorus, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Tool_Matches.get(4L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.bolt, Materials.Wood, 4L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.TricalciumPhosphate, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Tool_Matches.get(4L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Tool_Matches.get(16L), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Paper, 1L)) + .itemOutputs(ItemList.Tool_MatchBox_Full.get(1L)) + .duration(3 * SECONDS + 4 * TICKS) + .eut(16) + .addTo(packagerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Tool_MatchBox_Full.get(1L)) + .itemOutputs(ItemList.Tool_Matches.get(16L)) + .duration(1 * SECONDS + 12 * TICKS) + .eut(16) + .addTo(packagerRecipes); + + ItemList.Tool_Lighter_Invar_Empty.set( + addItem( + tLastID = 474, + "Lighter (Empty)", + "", + new ItemData(Materials.Invar, OrePrefixes.plate.mMaterialAmount * 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L))); + ItemList.Tool_Lighter_Invar_Used.set( + addItem( + tLastID = 475, + "Lighter", + "", + new ItemData(Materials.Invar, OrePrefixes.plate.mMaterialAmount * 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L), + SubTag.INVISIBLE)); + ItemList.Tool_Lighter_Invar_Full.set( + addItem( + tLastID = 476, + "Lighter (Full)", + "", + new ItemData(Materials.Invar, OrePrefixes.plate.mMaterialAmount * 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 2L))); + + tBehaviour = new Behaviour_Lighter( + ItemList.Tool_Lighter_Invar_Empty.get(1L), + ItemList.Tool_Lighter_Invar_Used.get(1L), + ItemList.Tool_Lighter_Invar_Full.get(1L), + 100L); + addItemBehavior(32475, tBehaviour); + addItemBehavior(32476, tBehaviour); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Invar, 2L), + new ItemStack(Items.flint, 1), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Tool_Lighter_Invar_Empty.get(1L)) + .duration(12 * SECONDS + 16 * TICKS) + .eut(16) + .addTo(assemblerRecipes); + + ItemList.Tool_Lighter_Platinum_Empty.set( + addItem( + tLastID = 477, + "Platinum Lighter (Empty)", + "A known Prank Master is engraved on it", + new ItemData(Materials.Platinum, OrePrefixes.plate.mMaterialAmount * 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.NEBRISUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L))); + ItemList.Tool_Lighter_Platinum_Used.set( + addItem( + tLastID = 478, + "Platinum Lighter", + "A known Prank Master is engraved on it", + new ItemData(Materials.Platinum, OrePrefixes.plate.mMaterialAmount * 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.NEBRISUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L), + SubTag.INVISIBLE)); + ItemList.Tool_Lighter_Platinum_Full.set( + addItem( + tLastID = 479, + "Platinum Lighter (Full)", + "A known Prank Master is engraved on it", + new ItemData(Materials.Platinum, OrePrefixes.plate.mMaterialAmount * 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.NEBRISUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 2L))); + + tBehaviour = new Behaviour_Lighter( + ItemList.Tool_Lighter_Platinum_Empty.get(1L), + ItemList.Tool_Lighter_Platinum_Used.get(1L), + ItemList.Tool_Lighter_Platinum_Full.get(1L), + 1000L); + addItemBehavior(32478, tBehaviour); + addItemBehavior(32479, tBehaviour); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Platinum, 2L), + new ItemStack(Items.flint, 1), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Tool_Lighter_Platinum_Empty.get(1L)) + .duration(12 * SECONDS + 16 * TICKS) + .eut(256) + .addTo(assemblerRecipes); + + if (GalacticraftMars.isModLoaded()) { + ItemList.Ingot_Heavy1 + .set(addItem(tLastID = 462, "Heavy Duty Alloy Ingot T1", "Used to make Heavy Duty Plates T1")); + ItemList.Ingot_Heavy2 + .set(addItem(tLastID = 463, "Heavy Duty Alloy Ingot T2", "Used to make Heavy Duty Plates T2")); + ItemList.Ingot_Heavy3 + .set(addItem(tLastID = 464, "Heavy Duty Alloy Ingot T3", "Used to make Heavy Duty Plates T3")); + + } + ItemList.Ingot_IridiumAlloy.set( + addItem( + tLastID = 480, + "Iridium Alloy Ingot", + "Used to make Iridium Plates", + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 4L))); + + ItemList.Paper_Printed_Pages.set( + addItem( + tLastID = 481, + "Printed Pages", + "Used to make written Books", + new ItemData(Materials.Paper, 10886400L), + new Behaviour_PrintedPages(), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 2L))); + ItemList.Paper_Magic_Empty.set( + addItem( + tLastID = 482, + "Magic Paper", + "", + SubTag.INVISIBLE, + new ItemData(Materials.Paper, 3628800L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PRAECANTATIO, 1L))); + ItemList.Paper_Magic_Page.set( + addItem( + tLastID = 483, + "Enchanted Page", + "", + SubTag.INVISIBLE, + new ItemData(Materials.Paper, 3628800L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PRAECANTATIO, 2L))); + ItemList.Paper_Magic_Pages.set( + addItem( + tLastID = 484, + "Enchanted Pages", + "", + SubTag.INVISIBLE, + new ItemData(Materials.Paper, 10886400L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PRAECANTATIO, 4L))); + ItemList.Paper_Punch_Card_Empty.set( + addItem( + tLastID = 485, + "Punch Card", + "", + SubTag.INVISIBLE, + new ItemData(Materials.Paper, 7257600L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 1L))); + ItemList.Paper_Punch_Card_Encoded.set( + addItem( + tLastID = 486, + "Punched Card", + "", + SubTag.INVISIBLE, + new ItemData(Materials.Paper, 7257600L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 2L))); + ItemList.Book_Written_01.set( + addItem( + tLastID = 487, + "Book", + "", + new ItemData(Materials.Paper, 10886400L), + "bookWritten", + OreDictNames.craftingBook, + new Behaviour_WrittenBook(), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 2L))); + ItemList.Book_Written_02.set( + addItem( + tLastID = 488, + "Book", + "", + new ItemData(Materials.Paper, 10886400L), + "bookWritten", + OreDictNames.craftingBook, + new Behaviour_WrittenBook(), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 2L))); + ItemList.Book_Written_03.set( + addItem( + tLastID = 489, + "Book", + "", + new ItemData(Materials.Paper, 10886400L), + "bookWritten", + OreDictNames.craftingBook, + new Behaviour_WrittenBook(), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 2L))); + + ItemList.Schematic.set( + addItem( + tLastID = 490, + "Schematic", + "EMPTY", + new ItemData(Materials.Steel, 7257600L), + new TC_Aspects.TC_AspectStack(TC_Aspects.STRONTIO, 1L))); + ItemList.Schematic_Crafting.set( + addItem( + tLastID = 491, + "Schematic (Crafting)", + "Crafts the Programmed Recipe", + new ItemData(Materials.Steel, 7257600L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 1L))); + ItemList.Schematic_1by1.set( + addItem( + tLastID = 495, + "Schematic (1x1)", + "Crafts 1 Items as 1x1 (use in Packager)", + new ItemData(Materials.Steel, 7257600L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 1L))); + ItemList.Schematic_2by2.set( + addItem( + tLastID = 496, + "Schematic (2x2)", + "Crafts 4 Items as 2x2 (use in Packager)", + new ItemData(Materials.Steel, 7257600L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 1L))); + ItemList.Schematic_3by3.set( + addItem( + tLastID = 497, + "Schematic (3x3)", + "Crafts 9 Items as 3x3 (use in Packager)", + new ItemData(Materials.Steel, 7257600L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 1L))); + ItemList.Schematic_Dust.set( + addItem( + tLastID = 498, + "Schematic (Dusts)", + "Combines Dusts (use in Packager)", + new ItemData(Materials.Steel, 7257600L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 1L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Schematic_1by1.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { "d ", aTextShape, aTextEmptyRow, 'P', ItemList.Schematic }); + GT_ModHandler.addCraftingRecipe( + ItemList.Schematic_2by2.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " d ", aTextShape, aTextEmptyRow, 'P', ItemList.Schematic }); + GT_ModHandler.addCraftingRecipe( + ItemList.Schematic_3by3.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " d", aTextShape, aTextEmptyRow, 'P', ItemList.Schematic }); + GT_ModHandler.addCraftingRecipe( + ItemList.Schematic_Dust.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { aTextEmptyRow, aTextShape, " d", 'P', ItemList.Schematic }); + + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Schematic.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Schematic_Crafting }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Schematic.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Schematic_1by1 }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Schematic.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Schematic_2by2 }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Schematic.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Schematic_3by3 }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Schematic.get(1L), + GT_ModHandler.RecipeBits.BUFFERED | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Schematic_Dust }); + + ItemList.Battery_Hull_LV.set( + addItem( + 500, + "Small Battery Hull", + "An empty LV Battery Hull", + new ItemData(Materials.BatteryAlloy, OrePrefixes.plate.mMaterialAmount * 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L))); + ItemList.Battery_Hull_MV.set( + addItem( + 501, + "Medium Battery Hull", + "An empty MV Battery Hull", + new ItemData(Materials.BatteryAlloy, OrePrefixes.plate.mMaterialAmount * 3L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L))); + ItemList.Battery_Hull_HV.set( + addItem( + 502, + "Large Battery Hull", + "An empty HV Battery Hull", + new ItemData(Materials.BatteryAlloy, OrePrefixes.plate.mMaterialAmount * 9L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 1L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Battery_Hull_LV.get(1L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { "Cf ", "Ph ", "Ps ", 'P', OrePrefixes.plate.get(Materials.BatteryAlloy), 'C', + OreDictNames.craftingWireTin }); + // GT_ModHandler.addCraftingRecipe(ItemList.Battery_Hull_MV.get(1L), GT_ModHandler.RecipeBits.NOT_REMOVABLE, new + // Object[]{"C C", "PPP", "PPP", 'P', OrePrefixes.plate.get(Materials.BatteryAlloy), 'C', + // OreDictNames.craftingWireCopper}); + + // ULV Batteries + ItemList.Battery_RE_ULV_Tantalum.set( + addItem( + tLastID = 499, + "Tantalum Capacitor", + "Reusable", + "batteryULV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L))); + setElectricStats(32000 + tLastID, 1000L, GT_Values.V[0], 0L, -3L, false); + registerTieredTooltip(ItemList.Battery_RE_ULV_Tantalum.get(1), ULV); + + // LV Batteries + ItemList.Battery_SU_LV_SulfuricAcid.set( + addItem( + tLastID = 510, + "Small Acid Battery", + "Single Use", + "batteryLV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 2L))); + setElectricStats(32000 + tLastID, 18000L, GT_Values.V[1], 1L, -2L, true); + registerTieredTooltip(ItemList.Battery_SU_LV_SulfuricAcid.get(1), LV); + + ItemList.Battery_SU_LV_Mercury.set( + addItem( + tLastID = 511, + "Small Mercury Battery", + "Single Use", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 2L))); + setElectricStats(32000 + tLastID, 32000L, GT_Values.V[1], 1L, -2L, true); + registerTieredTooltip(ItemList.Battery_SU_LV_Mercury.get(1), LV); + + ItemList.Battery_RE_LV_Cadmium.set( + addItem( + tLastID = 517, + "Small Cadmium Battery", + "Reusable", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L), + "batteryLV")); + setElectricStats(32000 + tLastID, 75000L, GT_Values.V[1], 1L, -3L, true); + registerTieredTooltip(ItemList.Battery_RE_LV_Cadmium.get(1), LV); + + ItemList.Battery_RE_LV_Lithium.set( + addItem( + tLastID = 518, + "Small Lithium Battery", + "Reusable", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L), + "batteryLV")); + setElectricStats(32000 + tLastID, 100000L, GT_Values.V[1], 1L, -3L, true); + registerTieredTooltip(ItemList.Battery_RE_LV_Lithium.get(1), LV); + + ItemList.Battery_RE_LV_Sodium.set( + addItem( + tLastID = 519, + "Small Sodium Battery", + "Reusable", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L), + "batteryLV")); + setElectricStats(32000 + tLastID, 50000L, GT_Values.V[1], 1L, -3L, true); + registerTieredTooltip(ItemList.Battery_RE_LV_Sodium.get(1), LV); + + // MV Batteries + ItemList.Battery_SU_MV_SulfuricAcid.set( + addItem( + tLastID = 520, + "Medium Acid Battery", + "Single Use", + "batteryMV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 4L))); + setElectricStats(32000 + tLastID, 72000L, GT_Values.V[2], 2L, -2L, true); + registerTieredTooltip(ItemList.Battery_SU_MV_SulfuricAcid.get(1), MV); + + ItemList.Battery_SU_MV_Mercury.set( + addItem( + tLastID = 521, + "Medium Mercury Battery", + "Single Use", + "batteryMV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 4L))); + setElectricStats(32000 + tLastID, 128000L, GT_Values.V[2], 2L, -2L, true); + registerTieredTooltip(ItemList.Battery_SU_MV_Mercury.get(1), MV); + + ItemList.Battery_RE_MV_Cadmium.set( + addItem( + tLastID = 527, + "Medium Cadmium Battery", + "Reusable", + "batteryMV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 2L))); + setElectricStats(32000 + tLastID, 300000L, GT_Values.V[2], 2L, -3L, true); + registerTieredTooltip(ItemList.Battery_RE_MV_Cadmium.get(1), MV); + + ItemList.Battery_RE_MV_Lithium.set( + addItem( + tLastID = 528, + "Medium Lithium Battery", + "Reusable", + "batteryMV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 2L))); + setElectricStats(32000 + tLastID, 400000L, GT_Values.V[2], 2L, -3L, true); + registerTieredTooltip(ItemList.Battery_RE_MV_Lithium.get(1), MV); + + ItemList.Battery_RE_MV_Sodium.set( + addItem( + tLastID = 529, + "Medium Sodium Battery", + "Reusable", + "batteryMV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 2L))); + setElectricStats(32000 + tLastID, 200000L, GT_Values.V[2], 2L, -3L, true); + registerTieredTooltip(ItemList.Battery_RE_MV_Sodium.get(1), MV); + + // HV Batteries + ItemList.Battery_SU_HV_SulfuricAcid.set( + addItem( + tLastID = 530, + "Large Acid Battery", + "Single Use", + "batteryHV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 8L))); + setElectricStats(32000 + tLastID, 288000L, GT_Values.V[3], 3L, -2L, true); + registerTieredTooltip(ItemList.Battery_SU_HV_SulfuricAcid.get(1), HV); + + ItemList.Battery_SU_HV_Mercury.set( + addItem( + tLastID = 531, + "Large Mercury Battery", + "Single Use", + "batteryHV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 8L))); + setElectricStats(32000 + tLastID, 512000L, GT_Values.V[3], 3L, -2L, true); + registerTieredTooltip(ItemList.Battery_SU_HV_Mercury.get(1), HV); + + ItemList.Battery_RE_HV_Cadmium.set( + addItem( + tLastID = 537, + "Large Cadmium Battery", + "Reusable", + "batteryHV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 4L))); + setElectricStats(32000 + tLastID, 1200000L, GT_Values.V[3], 3L, -3L, true); + registerTieredTooltip(ItemList.Battery_RE_HV_Cadmium.get(1), HV); + + ItemList.Battery_RE_HV_Lithium.set( + addItem( + tLastID = 538, + "Large Lithium Battery", + "Reusable", + "batteryHV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 4L))); + setElectricStats(32000 + tLastID, 1600000L, GT_Values.V[3], 3L, -3L, true); + registerTieredTooltip(ItemList.Battery_RE_HV_Lithium.get(1), HV); + + ItemList.Battery_RE_HV_Sodium.set( + addItem( + tLastID = 539, + "Large Sodium Battery", + "Reusable", + "batteryHV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 4L))); + setElectricStats(32000 + tLastID, 800000L, GT_Values.V[3], 3L, -3L, true); + registerTieredTooltip(ItemList.Battery_RE_HV_Sodium.get(1), HV); + + GT_ModHandler + .addExtractionRecipe(ItemList.Battery_SU_LV_SulfuricAcid.get(1L), ItemList.Battery_Hull_LV.get(1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Battery_SU_LV_Mercury.get(1L), ItemList.Battery_Hull_LV.get(1L)); + GT_ModHandler + .addExtractionRecipe(ItemList.Battery_SU_MV_SulfuricAcid.get(1L), ItemList.Battery_Hull_MV.get(1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Battery_SU_MV_Mercury.get(1L), ItemList.Battery_Hull_MV.get(1L)); + GT_ModHandler + .addExtractionRecipe(ItemList.Battery_SU_HV_SulfuricAcid.get(1L), ItemList.Battery_Hull_HV.get(1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Battery_SU_HV_Mercury.get(1L), ItemList.Battery_Hull_HV.get(1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Battery_RE_LV_Cadmium.get(1L), ItemList.Battery_Hull_LV.get(1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Battery_RE_LV_Lithium.get(1L), ItemList.Battery_Hull_LV.get(1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Battery_RE_LV_Sodium.get(1L), ItemList.Battery_Hull_LV.get(1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Battery_RE_MV_Cadmium.get(1L), ItemList.Battery_Hull_MV.get(1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Battery_RE_MV_Lithium.get(1L), ItemList.Battery_Hull_MV.get(1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Battery_RE_MV_Sodium.get(1L), ItemList.Battery_Hull_MV.get(1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Battery_RE_HV_Cadmium.get(1L), ItemList.Battery_Hull_HV.get(1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Battery_RE_HV_Lithium.get(1L), ItemList.Battery_Hull_HV.get(1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Battery_RE_HV_Sodium.get(1L), ItemList.Battery_Hull_HV.get(1L)); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cadmium, 2L), + ItemList.Battery_Hull_LV.get(1L)) + .itemOutputs(ItemList.Battery_RE_LV_Cadmium.get(1L)) + .duration(5 * SECONDS) + .eut(2) + .addTo(cannerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lithium, 2L), + ItemList.Battery_Hull_LV.get(1L)) + .itemOutputs(ItemList.Battery_RE_LV_Lithium.get(1L)) + .duration(5 * SECONDS) + .eut(2) + .addTo(cannerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 2L), + ItemList.Battery_Hull_LV.get(1L)) + .itemOutputs(ItemList.Battery_RE_LV_Sodium.get(1L)) + .duration(5 * SECONDS) + .eut(2) + .addTo(cannerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cadmium, 8L), + ItemList.Battery_Hull_MV.get(1L)) + .itemOutputs(ItemList.Battery_RE_MV_Cadmium.get(1L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(cannerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lithium, 8L), + ItemList.Battery_Hull_MV.get(1L)) + .itemOutputs(ItemList.Battery_RE_MV_Lithium.get(1L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(cannerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 8L), + ItemList.Battery_Hull_MV.get(1L)) + .itemOutputs(ItemList.Battery_RE_MV_Sodium.get(1L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(cannerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cadmium, 32L), + ItemList.Battery_Hull_HV.get(1L)) + .itemOutputs(ItemList.Battery_RE_HV_Cadmium.get(1L)) + .duration(1 * MINUTES + 20 * SECONDS) + .eut(2) + .addTo(cannerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lithium, 32L), + ItemList.Battery_Hull_HV.get(1L)) + .itemOutputs(ItemList.Battery_RE_HV_Lithium.get(1L)) + .duration(1 * MINUTES + 20 * SECONDS) + .eut(2) + .addTo(cannerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Sodium, 32L), + ItemList.Battery_Hull_HV.get(1L)) + .itemOutputs(ItemList.Battery_RE_HV_Sodium.get(1L)) + .duration(1 * MINUTES + 20 * SECONDS) + .eut(2) + .addTo(cannerRecipes); + + // IV Battery + ItemList.Energy_LapotronicOrb.set( + addItem( + tLastID = 597, + "Lapotronic Energy Orb", + "Reusable battery", + "batteryIV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 16L), + OrePrefixes.battery.get(Materials.Ultimate))); + setElectricStats(32000 + tLastID, 100000000L, GT_Values.V[5], 5L, -3L, true); + registerTieredTooltip(ItemList.Energy_LapotronicOrb.get(1), IV); + + // ZPM Module + ItemList.ZPM.set( + addItem( + tLastID = 598, + "Zero Point Module", + "Single use battery", + "batteryZPM", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 64L))); + setElectricStats(32000 + tLastID, 2000000000000L, GT_Values.V[7], 7L, -2L, true); + registerTieredTooltip(ItemList.ZPM.get(1), ZPM); + + // LuV Lapotron orb cluster battery + ItemList.Energy_LapotronicOrb2.set( + addItem( + tLastID = 599, + "Lapotronic Energy Orb Cluster", + "Reusable battery", + "batteryLuV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 16L), + OrePrefixes.battery.get(Materials.Ultimate))); + setElectricStats(32000 + tLastID, 1000000000L, GT_Values.V[6], 6L, -3L, true); + registerTieredTooltip(ItemList.Energy_LapotronicOrb2.get(1), LuV); + + // UV Battery + ItemList.ZPM2.set( + addItem( + tLastID = 605, + "Ultimate Battery", + "Fill this to win minecraft", + "batteryUV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 64L))); + setElectricStats(32000 + tLastID, Long.MAX_VALUE, GT_Values.V[8], 8L, -3L, true); + registerTieredTooltip(ItemList.ZPM2.get(1), UV); + + // UMV Battery + ItemList.ZPM3.set( + addItem( + tLastID = 609, + "Really Ultimate Battery", + "Fill this to be way older", + "batteryUMV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 64L))); + setElectricStats(32000 + tLastID, Long.MAX_VALUE, GT_Values.V[12], 12L, -3L, true); + registerTieredTooltip(ItemList.ZPM3.get(1), UMV); + + // UXV Battery + ItemList.ZPM4.set( + addItem( + tLastID = 594, + "Extremely Ultimate Battery", + "Fill this to be older", + "batteryUXV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 64L))); + setElectricStats(32000 + tLastID, Long.MAX_VALUE, GT_Values.V[13], 13L, -3L, true); + registerTieredTooltip(ItemList.ZPM4.get(1), UXV); + + // MAX Battery + ItemList.ZPM5.set( + addItem( + tLastID = 145, + "Insanely Ultimate Battery", + "Fill this for fun", + "batteryMAX", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 64L))); + setElectricStats(32000 + tLastID, Long.MAX_VALUE, GT_Values.V[14], 14L, -3L, true); + registerTieredTooltip(ItemList.ZPM5.get(1), MAX); + + // ERROR Battery + ItemList.ZPM6.set( + addItem( + tLastID = 146, + "Mega Ultimate Battery", + "Fill the capacitor to reach enlightenment", + "batteryERV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 64L))); + setElectricStats(32000 + tLastID, Long.MAX_VALUE, GT_Values.V[15], 15L, -3L, true); + registerTieredTooltip(ItemList.ZPM6.get(1), ERV); + + // ZPM Cluster + ItemList.Energy_Module.set( + addItem( + tLastID = 736, + "Energy Module", + "Reusable battery", + "batteryZPM", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 16L), + OrePrefixes.battery.get(Materials.Ultimate))); + setElectricStats(32000 + tLastID, 10000000000L, GT_Values.V[7], 7L, -3L, true); + registerTieredTooltip(ItemList.Energy_Module.get(1), ZPM); + + // UV Cluster + ItemList.Energy_Cluster.set( + addItem( + tLastID = 737, + "Energy Cluster", + "Reusable battery", + "batteryUV", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 64L))); + setElectricStats(32000 + tLastID, 100000000000L, GT_Values.V[8], 8L, -3L, true); + registerTieredTooltip(ItemList.Energy_Cluster.get(1), UV); + + // UIV, UMV, UXV and MAX component textures backported from gregicality. + ItemList.Electric_Motor_LV.set( + addItem( + 600, + "Electric Motor (LV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 1L))); + ItemList.Electric_Motor_MV.set( + addItem( + 601, + "Electric Motor (MV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 2L))); + ItemList.Electric_Motor_HV.set( + addItem( + 602, + "Electric Motor (HV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 4L))); + ItemList.Electric_Motor_EV.set( + addItem( + 603, + "Electric Motor (EV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 8L))); + ItemList.Electric_Motor_IV.set( + addItem( + 604, + "Electric Motor (IV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 16L))); + ItemList.Electric_Motor_LuV.set( + addItem( + 606, + "Electric Motor (LuV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 32L))); + ItemList.Electric_Motor_ZPM.set( + addItem( + 607, + "Electric Motor (ZPM)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 64L))); + ItemList.Electric_Motor_UV.set( + addItem( + 608, + "Electric Motor (UV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 128L))); + ItemList.Electric_Motor_UHV.set( + addItem( + 596, + "Electric Motor (UHV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 256L))); + ItemList.Electric_Motor_UEV.set( + addItem( + 595, + "Electric Motor (UEV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L))); + ItemList.Electric_Motor_UIV.set( + addItem( + 17, + "Electric Motor (UIV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L))); + ItemList.Electric_Motor_UMV.set( + addItem( + 18, + "Electric Motor (UMV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L))); + ItemList.Electric_Motor_UXV.set( + addItem( + 19, + "Electric Motor (UXV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L))); + ItemList.Electric_Motor_MAX.set( + addItem( + 20, + "Electric Motor (MAX)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Motor_LV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "CWR", "WIW", "RWC", 'I', OrePrefixes.stick.get(Materials.IronMagnetic), 'R', + OrePrefixes.stick.get(Materials.AnyIron), 'W', OrePrefixes.wireGt01.get(Materials.AnyCopper), 'C', + OrePrefixes.cableGt01.get(Materials.Tin) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Motor_LV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "CWR", "WIW", "RWC", 'I', OrePrefixes.stick.get(Materials.SteelMagnetic), 'R', + OrePrefixes.stick.get(Materials.Steel), 'W', OrePrefixes.wireGt01.get(Materials.AnyCopper), 'C', + OrePrefixes.cableGt01.get(Materials.Tin) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Motor_MV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "CWR", "WIW", "RWC", 'I', OrePrefixes.stick.get(Materials.SteelMagnetic), 'R', + OrePrefixes.stick.get(Materials.Aluminium), 'W', OrePrefixes.wireGt02.get(Materials.Cupronickel), 'C', + OrePrefixes.cableGt01.get(Materials.AnyCopper) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Motor_HV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "CWR", "WIW", "RWC", 'I', OrePrefixes.stick.get(Materials.SteelMagnetic), 'R', + OrePrefixes.stick.get(Materials.StainlessSteel), 'W', OrePrefixes.wireGt04.get(Materials.Electrum), 'C', + OrePrefixes.cableGt02.get(Materials.Silver) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Motor_EV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "CWR", "WIW", "RWC", 'I', OrePrefixes.stick.get(Materials.NeodymiumMagnetic), 'R', + OrePrefixes.stick.get(Materials.Titanium), 'W', OrePrefixes.wireGt04.get(Materials.BlackSteel), 'C', + OrePrefixes.cableGt02.get(Materials.Aluminium) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Motor_IV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "CWR", "WIW", "RWC", 'I', OrePrefixes.stick.get(Materials.NeodymiumMagnetic), 'R', + OrePrefixes.stick.get(Materials.TungstenSteel), 'W', OrePrefixes.wireGt04.get(Materials.Graphene), 'C', + OrePrefixes.cableGt02.get(Materials.Tungsten) }); + + ItemList.Tesseract.set( + addItem( + 415, + "Raw Tesseract", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 1L))); + ItemList.GigaChad.set( + addItem( + 416, + "Giga Chad Token", + "You are worthy", + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 1000L))); + ItemList.EnergisedTesseract.set( + addItem( + 417, + "Energised Tesseract", + "Higher dimensional engineering", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 10L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 1L))); + + ItemList.Electric_Piston_LV.set( + addItem( + 640, + "Electric Piston (LV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 1L))); + ItemList.Electric_Piston_MV.set( + addItem( + 641, + "Electric Piston (MV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 2L))); + ItemList.Electric_Piston_HV.set( + addItem( + 642, + "Electric Piston (HV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 4L))); + ItemList.Electric_Piston_EV.set( + addItem( + 643, + "Electric Piston (EV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 8L))); + ItemList.Electric_Piston_IV.set( + addItem( + 644, + "Electric Piston (IV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 16L))); + ItemList.Electric_Piston_LuV.set( + addItem( + 645, + "Electric Piston (LuV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 32L))); + ItemList.Electric_Piston_ZPM.set( + addItem( + 646, + "Electric Piston (ZPM)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 64L))); + ItemList.Electric_Piston_UV.set( + addItem( + 647, + "Electric Piston (UV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 128L))); + ItemList.Electric_Piston_UHV.set( + addItem( + 648, + "Electric Piston (UHV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 256L))); + ItemList.Electric_Piston_UEV.set( + addItem( + 649, + "Electric Piston (UEV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L))); + ItemList.Electric_Piston_UIV.set( + addItem( + 21, + "Electric Piston (UIV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L))); + ItemList.Electric_Piston_UMV.set( + addItem( + 22, + "Electric Piston (UMV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L))); + ItemList.Electric_Piston_UXV.set( + addItem( + 23, + "Electric Piston (UXV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L))); + ItemList.Electric_Piston_MAX.set( + addItem( + 24, + "Electric Piston (MAX)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Piston_LV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "PPP", "CSS", "CMG", 'P', OrePrefixes.plate.get(Materials.Steel), 'S', + OrePrefixes.stick.get(Materials.Steel), 'G', OrePrefixes.gearGtSmall.get(Materials.Steel), 'M', + ItemList.Electric_Motor_LV, 'C', OrePrefixes.cableGt01.get(Materials.Tin) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Piston_MV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "PPP", "CSS", "CMG", 'P', OrePrefixes.plate.get(Materials.Aluminium), 'S', + OrePrefixes.stick.get(Materials.Aluminium), 'G', OrePrefixes.gearGtSmall.get(Materials.Aluminium), 'M', + ItemList.Electric_Motor_MV, 'C', OrePrefixes.cableGt01.get(Materials.AnyCopper) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Piston_HV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "PPP", "CSS", "CMG", 'P', OrePrefixes.plate.get(Materials.StainlessSteel), 'S', + OrePrefixes.stick.get(Materials.StainlessSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.StainlessSteel), 'M', ItemList.Electric_Motor_HV, 'C', + OrePrefixes.cableGt01.get(Materials.Gold) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Piston_EV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "PPP", "CSS", "CMG", 'P', OrePrefixes.plate.get(Materials.Titanium), 'S', + OrePrefixes.stick.get(Materials.Titanium), 'G', OrePrefixes.gearGtSmall.get(Materials.Titanium), 'M', + ItemList.Electric_Motor_EV, 'C', OrePrefixes.cableGt01.get(Materials.Aluminium) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Piston_IV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "PPP", "CSS", "CMG", 'P', OrePrefixes.plate.get(Materials.TungstenSteel), 'S', + OrePrefixes.stick.get(Materials.TungstenSteel), 'G', + OrePrefixes.gearGtSmall.get(Materials.TungstenSteel), 'M', ItemList.Electric_Motor_IV, 'C', + OrePrefixes.cableGt01.get(Materials.Tungsten) }); + + ItemList.Electric_Pump_LV.set( + addItem( + 610, + "Electric Pump (LV)", + GT_Utility.formatNumbers(32) + PartCoverText + GT_Utility.formatNumbers(32 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L))); + ItemList.Electric_Pump_MV.set( + addItem( + 611, + "Electric Pump (MV)", + GT_Utility.formatNumbers(128) + PartCoverText + GT_Utility.formatNumbers(128 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 2L))); + ItemList.Electric_Pump_HV.set( + addItem( + 612, + "Electric Pump (HV)", + GT_Utility.formatNumbers(512) + PartCoverText + GT_Utility.formatNumbers(512 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 4L))); + ItemList.Electric_Pump_EV.set( + addItem( + 613, + "Electric Pump (EV)", + GT_Utility.formatNumbers(2048) + PartCoverText + GT_Utility.formatNumbers(2048 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 8L))); + ItemList.Electric_Pump_IV.set( + addItem( + 614, + "Electric Pump (IV)", + GT_Utility.formatNumbers(8192) + PartCoverText + GT_Utility.formatNumbers(8192 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 16L))); + ItemList.Electric_Pump_LuV.set( + addItem( + 615, + "Electric Pump (LuV)", + GT_Utility.formatNumbers(32768) + PartCoverText + GT_Utility.formatNumbers(32768 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 32L))); + ItemList.Electric_Pump_ZPM.set( + addItem( + 616, + "Electric Pump (ZPM)", + GT_Utility.formatNumbers(131072) + PartCoverText + + GT_Utility.formatNumbers(131072 * 20) + + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 64L))); + ItemList.Electric_Pump_UV.set( + addItem( + 617, + "Electric Pump (UV)", + GT_Utility.formatNumbers(524288) + PartCoverText + + GT_Utility.formatNumbers(524288 * 20) + + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 128L))); + ItemList.Electric_Pump_UHV.set( + addItem( + 618, + "Electric Pump (UHV)", + GT_Utility.formatNumbers(1048576) + PartCoverText + + GT_Utility.formatNumbers(1048576 * 20) + + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 256L))); + ItemList.Electric_Pump_UEV.set( + addItem( + 619, + "Electric Pump (UEV)", + GT_Utility.formatNumbers(2097152) + PartCoverText + + GT_Utility.formatNumbers(2097152 * 20) + + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 512L))); + ItemList.Electric_Pump_UIV.set( + addItem( + 25, + "Electric Pump (UIV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 512L))); + ItemList.Electric_Pump_UMV.set( + addItem( + 26, + "Electric Pump (UMV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 512L))); + ItemList.Electric_Pump_UXV.set( + addItem( + 27, + "Electric Pump (UXV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 512L))); + ItemList.Electric_Pump_MAX.set( + addItem( + 28, + "Electric Pump (MAX)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 512L))); + + GregTech_API.registerCover( + ItemList.Electric_Pump_LV.get(1L), + TextureFactory.of(MACHINE_CASINGS[1][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_Pump(32, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.Electric_Pump_MV.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_Pump(128, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.Electric_Pump_HV.get(1L), + TextureFactory.of(MACHINE_CASINGS[3][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_Pump(512, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.Electric_Pump_EV.get(1L), + TextureFactory.of(MACHINE_CASINGS[4][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_Pump(2048, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.Electric_Pump_IV.get(1L), + TextureFactory.of(MACHINE_CASINGS[5][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_Pump(8192, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.Electric_Pump_LuV.get(1L), + TextureFactory.of(MACHINE_CASINGS[6][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_Pump(32768, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.Electric_Pump_ZPM.get(1L), + TextureFactory.of(MACHINE_CASINGS[7][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_Pump(131072, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.Electric_Pump_UV.get(1L), + TextureFactory.of(MACHINE_CASINGS[8][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_Pump(524288, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.Electric_Pump_UHV.get(1L), + TextureFactory.of(MACHINE_CASINGS[9][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_Pump(1048576, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.Electric_Pump_UEV.get(1L), + TextureFactory.of(MACHINE_CASINGS[10][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_Pump(2097152, TextureFactory.of(OVERLAY_PUMP))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Pump_LV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "SXO", "dPw", "OMW", 'M', ItemList.Electric_Motor_LV, 'O', + OrePrefixes.ring.get(Materials.AnyRubber), 'X', OrePrefixes.rotor.get(Materials.Tin), 'S', + OrePrefixes.screw.get(Materials.Tin), 'W', OrePrefixes.cableGt01.get(Materials.Tin), 'P', + OrePrefixes.pipeMedium.get(Materials.Bronze) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Pump_MV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "SXO", "dPw", "OMW", 'M', ItemList.Electric_Motor_MV, 'O', + OrePrefixes.ring.get(Materials.AnyRubber), 'X', OrePrefixes.rotor.get(Materials.Bronze), 'S', + OrePrefixes.screw.get(Materials.Bronze), 'W', OrePrefixes.cableGt01.get(Materials.AnyCopper), 'P', + OrePrefixes.pipeMedium.get(Materials.Steel) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Pump_HV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "SXO", "dPw", "OMW", 'M', ItemList.Electric_Motor_HV, 'O', + OrePrefixes.ring.get(Materials.AnyRubber), 'X', OrePrefixes.rotor.get(Materials.Steel), 'S', + OrePrefixes.screw.get(Materials.Steel), 'W', OrePrefixes.cableGt01.get(Materials.Gold), 'P', + OrePrefixes.pipeMedium.get(Materials.StainlessSteel) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Pump_EV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "SXO", "dPw", "OMW", 'M', ItemList.Electric_Motor_EV, 'O', + OrePrefixes.ring.get(Materials.AnyRubber), 'X', OrePrefixes.rotor.get(Materials.StainlessSteel), 'S', + OrePrefixes.screw.get(Materials.StainlessSteel), 'W', OrePrefixes.cableGt01.get(Materials.Aluminium), + 'P', OrePrefixes.pipeMedium.get(Materials.Titanium) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Electric_Pump_IV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "SXO", "dPw", "OMW", 'M', ItemList.Electric_Motor_IV, 'O', + OrePrefixes.ring.get(Materials.AnySyntheticRubber), 'X', OrePrefixes.rotor.get(Materials.TungstenSteel), + 'S', OrePrefixes.screw.get(Materials.TungstenSteel), 'W', OrePrefixes.cableGt01.get(Materials.Tungsten), + 'P', OrePrefixes.pipeMedium.get(Materials.TungstenSteel) }); + + ItemList.Steam_Valve_LV.set( + addItem( + 620, + "Steam Valve (LV)", + GT_Utility.formatNumbers(1024) + PartCoverText + GT_Utility.formatNumbers(1024 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L))); + ItemList.Steam_Valve_MV.set( + addItem( + 621, + "Steam Valve (MV)", + GT_Utility.formatNumbers(2048) + PartCoverText + GT_Utility.formatNumbers(2048 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 2L))); + ItemList.Steam_Valve_HV.set( + addItem( + 622, + "Steam Valve (HV)", + GT_Utility.formatNumbers(4096) + PartCoverText + GT_Utility.formatNumbers(4096 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 4L))); + ItemList.Steam_Valve_EV.set( + addItem( + 623, + "Steam Valve (EV)", + GT_Utility.formatNumbers(8192) + PartCoverText + GT_Utility.formatNumbers(8192 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 8L))); + ItemList.Steam_Valve_IV.set( + addItem( + 624, + "Steam Valve (IV)", + GT_Utility.formatNumbers(16384) + PartCoverText + GT_Utility.formatNumbers(16384 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 16L))); + + GregTech_API.registerCover( + ItemList.Steam_Valve_LV.get(1L), + TextureFactory.of(MACHINE_CASINGS[1][0], TextureFactory.of(OVERLAY_VALVE)), + new GT_Cover_SteamValve(1024, TextureFactory.of(OVERLAY_VALVE))); + GregTech_API.registerCover( + ItemList.Steam_Valve_MV.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_VALVE)), + new GT_Cover_SteamValve(2048, TextureFactory.of(OVERLAY_VALVE))); + GregTech_API.registerCover( + ItemList.Steam_Valve_HV.get(1L), + TextureFactory.of(MACHINE_CASINGS[3][0], TextureFactory.of(OVERLAY_VALVE)), + new GT_Cover_SteamValve(4096, TextureFactory.of(OVERLAY_VALVE))); + GregTech_API.registerCover( + ItemList.Steam_Valve_EV.get(1L), + TextureFactory.of(MACHINE_CASINGS[4][0], TextureFactory.of(OVERLAY_VALVE)), + new GT_Cover_SteamValve(8192, TextureFactory.of(OVERLAY_VALVE))); + GregTech_API.registerCover( + ItemList.Steam_Valve_IV.get(1L), + TextureFactory.of(MACHINE_CASINGS[5][0], TextureFactory.of(OVERLAY_VALVE)), + new GT_Cover_SteamValve(16384, TextureFactory.of(OVERLAY_VALVE))); + + ItemList.FluidRegulator_LV + .set(addItem(tLastID = 660, "Fluid Regulator (LV)", FRText1 + GT_Utility.formatNumbers(640) + FRText2)); + ItemList.FluidRegulator_MV + .set(addItem(tLastID = 661, "Fluid Regulator (MV)", FRText1 + GT_Utility.formatNumbers(2560) + FRText2)); + ItemList.FluidRegulator_HV + .set(addItem(tLastID = 662, "Fluid Regulator (HV)", FRText1 + GT_Utility.formatNumbers(10240) + FRText2)); + ItemList.FluidRegulator_EV + .set(addItem(tLastID = 663, "Fluid Regulator (EV)", FRText1 + GT_Utility.formatNumbers(40960) + FRText2)); + ItemList.FluidRegulator_IV + .set(addItem(tLastID = 664, "Fluid Regulator (IV)", FRText1 + GT_Utility.formatNumbers(163840) + FRText2)); + ItemList.FluidRegulator_LuV + .set(addItem(tLastID = 665, "Fluid Regulator (LuV)", FRText1 + GT_Utility.formatNumbers(655360) + FRText2)); + ItemList.FluidRegulator_ZPM.set( + addItem(tLastID = 666, "Fluid Regulator (ZPM)", FRText1 + GT_Utility.formatNumbers(2621440) + FRText2)); + ItemList.FluidRegulator_UV.set( + addItem(tLastID = 667, "Fluid Regulator (UV)", FRText1 + GT_Utility.formatNumbers(10485760) + FRText2)); + + GregTech_API.registerCover( + ItemList.FluidRegulator_LV.get(1L), + TextureFactory.of(MACHINE_CASINGS[1][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_FluidRegulator(32, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.FluidRegulator_MV.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_FluidRegulator(128, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.FluidRegulator_HV.get(1L), + TextureFactory.of(MACHINE_CASINGS[3][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_FluidRegulator(512, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.FluidRegulator_EV.get(1L), + TextureFactory.of(MACHINE_CASINGS[4][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_FluidRegulator(2048, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.FluidRegulator_IV.get(1L), + TextureFactory.of(MACHINE_CASINGS[5][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_FluidRegulator(8192, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.FluidRegulator_LuV.get(1L), + TextureFactory.of(MACHINE_CASINGS[6][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_FluidRegulator(32768, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.FluidRegulator_ZPM.get(1L), + TextureFactory.of(MACHINE_CASINGS[7][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_FluidRegulator(131072, TextureFactory.of(OVERLAY_PUMP))); + GregTech_API.registerCover( + ItemList.FluidRegulator_UV.get(1L), + TextureFactory.of(MACHINE_CASINGS[8][0], TextureFactory.of(OVERLAY_PUMP)), + new GT_Cover_FluidRegulator(524288, TextureFactory.of(OVERLAY_PUMP))); + + ItemList.FluidFilter + .set(addItem(669, "Fluid Filter Cover", "Set with Fluid Container to only accept one Fluid Type")); + GregTech_API.registerCover( + ItemList.FluidFilter.get(1L), + TextureFactory.of(MACHINE_CASINGS[1][0], TextureFactory.of(OVERLAY_SHUTTER)), + new GT_Cover_Fluidfilter(TextureFactory.of(OVERLAY_SHUTTER))); + ItemList.ItemFilter_Export.set( + addItem( + 270, + "Item Filter Cover (Export)", + "Right click with an item to set filter (Only supports Export Mode)")); + GregTech_API.registerCover( + ItemList.ItemFilter_Export.get(1L), + TextureFactory.of(MACHINE_CASINGS[5][0], TextureFactory.of(OVERLAY_CONVEYOR)), + new GT_Cover_ItemFilter(true, TextureFactory.of(OVERLAY_CONVEYOR))); + ItemList.ItemFilter_Import.set( + addItem( + 271, + "Item Filter Cover (Import)", + "Right click with an item to set filter (Only supports Import Mode)")); + GregTech_API.registerCover( + ItemList.ItemFilter_Import.get(1L), + TextureFactory.of(MACHINE_CASINGS[5][0], TextureFactory.of(OVERLAY_CONVEYOR)), + new GT_Cover_ItemFilter(false, TextureFactory.of(OVERLAY_CONVEYOR))); + ItemList.Cover_FluidLimiter + .set(addItem(272, "Fluid Limiter Cover", "Limits fluid input depending on fill level")); + GregTech_API.registerCover( + ItemList.Cover_FluidLimiter.get(1L), + TextureFactory.of(MACHINE_CASINGS[1][0], TextureFactory.of(OVERLAY_SHUTTER)), + new GT_Cover_FluidLimiter(TextureFactory.of(OVERLAY_SHUTTER))); + + ItemList.Conveyor_Module_LV.set( + addItem( + 630, + "Conveyor Module (LV)", + "1 stack every 20 secs (as Cover)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 1L))); + ItemList.Conveyor_Module_MV.set( + addItem( + 631, + "Conveyor Module (MV)", + "1 stack every 5 secs (as Cover)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 2L))); + ItemList.Conveyor_Module_HV.set( + addItem( + 632, + "Conveyor Module (HV)", + "1 stack every 1 sec (as Cover)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 4L))); + ItemList.Conveyor_Module_EV.set( + addItem( + 633, + "Conveyor Module (EV)", + "1 stack every 1/5 sec (as Cover)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 8L))); + ItemList.Conveyor_Module_IV.set( + addItem( + 634, + "Conveyor Module (IV)", + "1 stack every 1/20 sec (as Cover)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 16L))); + ItemList.Conveyor_Module_LuV.set( + addItem( + 635, + "Conveyor Module (LuV)", + "2 stacks every 1/20 sec (as Cover)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 32L))); + ItemList.Conveyor_Module_ZPM.set( + addItem( + 636, + "Conveyor Module (ZPM)", + "4 stacks every 1/20 sec (as Cover)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 64L))); + ItemList.Conveyor_Module_UV.set( + addItem( + 637, + "Conveyor Module (UV)", + "8 stacks every 1/20 sec (as Cover)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 128L))); + ItemList.Conveyor_Module_UHV.set( + addItem( + 638, + "Conveyor Module (UHV)", + "16 stacks every 1/20 sec (as Cover)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 256L))); + ItemList.Conveyor_Module_UEV.set( + addItem( + 639, + "Conveyor Module (UEV)", + "32 stacks every 1/20 sec (as Cover)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 512L))); + ItemList.Conveyor_Module_UIV.set( + addItem( + 29, + "Conveyor Module (UIV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 512L))); + ItemList.Conveyor_Module_UMV.set( + addItem( + 30, + "Conveyor Module (UMV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 512L))); + ItemList.Conveyor_Module_UXV.set( + addItem( + 31, + "Conveyor Module (UXV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 512L))); + ItemList.Conveyor_Module_MAX.set( + addItem( + 32, + "Conveyor Module (MAX)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 512L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Conveyor_Module_LV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "RRR", "MCM", "RRR", 'M', ItemList.Electric_Motor_LV, 'C', + OrePrefixes.cableGt01.get(Materials.Tin), 'R', OrePrefixes.plate.get(Materials.AnyRubber) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Conveyor_Module_MV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "RRR", "MCM", "RRR", 'M', ItemList.Electric_Motor_MV, 'C', + OrePrefixes.cableGt01.get(Materials.AnyCopper), 'R', OrePrefixes.plate.get(Materials.AnyRubber) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Conveyor_Module_HV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "RRR", "MCM", "RRR", 'M', ItemList.Electric_Motor_HV, 'C', + OrePrefixes.cableGt01.get(Materials.Gold), 'R', OrePrefixes.plate.get(Materials.AnyRubber) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Conveyor_Module_EV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "RRR", "MCM", "RRR", 'M', ItemList.Electric_Motor_EV, 'C', + OrePrefixes.cableGt01.get(Materials.Aluminium), 'R', OrePrefixes.plate.get(Materials.AnyRubber) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Conveyor_Module_IV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "RRR", "MCM", "RRR", 'M', ItemList.Electric_Motor_IV, 'C', + OrePrefixes.cableGt01.get(Materials.Tungsten), 'R', + OrePrefixes.plate.get(Materials.AnySyntheticRubber) }); + + GregTech_API.registerCover( + ItemList.Conveyor_Module_LV.get(1L), + TextureFactory.of(MACHINE_CASINGS[1][0], TextureFactory.of(OVERLAY_CONVEYOR)), + new GT_Cover_Conveyor(400, 1, TextureFactory.of(OVERLAY_CONVEYOR))); + GregTech_API.registerCover( + ItemList.Conveyor_Module_MV.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_CONVEYOR)), + new GT_Cover_Conveyor(100, 1, TextureFactory.of(OVERLAY_CONVEYOR))); + GregTech_API.registerCover( + ItemList.Conveyor_Module_HV.get(1L), + TextureFactory.of(MACHINE_CASINGS[3][0], TextureFactory.of(OVERLAY_CONVEYOR)), + new GT_Cover_Conveyor(20, 1, TextureFactory.of(OVERLAY_CONVEYOR))); + GregTech_API.registerCover( + ItemList.Conveyor_Module_EV.get(1L), + TextureFactory.of(MACHINE_CASINGS[4][0], TextureFactory.of(OVERLAY_CONVEYOR)), + new GT_Cover_Conveyor(4, 1, TextureFactory.of(OVERLAY_CONVEYOR))); + GregTech_API.registerCover( + ItemList.Conveyor_Module_IV.get(1L), + TextureFactory.of(MACHINE_CASINGS[5][0], TextureFactory.of(OVERLAY_CONVEYOR)), + new GT_Cover_Conveyor(1, 1, TextureFactory.of(OVERLAY_CONVEYOR))); + GregTech_API.registerCover( + ItemList.Conveyor_Module_LuV.get(1L), + TextureFactory.of(MACHINE_CASINGS[6][0], TextureFactory.of(OVERLAY_CONVEYOR)), + new GT_Cover_Conveyor(1, 2, TextureFactory.of(OVERLAY_CONVEYOR))); + GregTech_API.registerCover( + ItemList.Conveyor_Module_ZPM.get(1L), + TextureFactory.of(MACHINE_CASINGS[7][0], TextureFactory.of(OVERLAY_CONVEYOR)), + new GT_Cover_Conveyor(1, 4, TextureFactory.of(OVERLAY_CONVEYOR))); + GregTech_API.registerCover( + ItemList.Conveyor_Module_UV.get(1L), + TextureFactory.of(MACHINE_CASINGS[8][0], TextureFactory.of(OVERLAY_CONVEYOR)), + new GT_Cover_Conveyor(1, 8, TextureFactory.of(OVERLAY_CONVEYOR))); + GregTech_API.registerCover( + ItemList.Conveyor_Module_UHV.get(1L), + TextureFactory.of(MACHINE_CASINGS[9][0], TextureFactory.of(OVERLAY_CONVEYOR)), + new GT_Cover_Conveyor(1, 16, TextureFactory.of(OVERLAY_CONVEYOR))); + GregTech_API.registerCover( + ItemList.Conveyor_Module_UEV.get(1L), + TextureFactory.of(MACHINE_CASINGS[10][0], TextureFactory.of(OVERLAY_CONVEYOR)), + new GT_Cover_Conveyor(1, 32, TextureFactory.of(OVERLAY_CONVEYOR))); + + ItemList.Robot_Arm_LV.set( + addItem( + 650, + "Robot Arm (LV)", + "1 stack every 20 secs (as Cover)/n " + RAText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 1L))); + ItemList.Robot_Arm_MV.set( + addItem( + 651, + "Robot Arm (MV)", + "1 stack every 5 secs (as Cover)/n " + RAText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 2L))); + ItemList.Robot_Arm_HV.set( + addItem( + 652, + "Robot Arm (HV)", + "1 stack every 1 sec (as Cover)/n " + RAText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 4L))); + ItemList.Robot_Arm_EV.set( + addItem( + 653, + "Robot Arm (EV)", + "1 stack every 1/5 sec (as Cover)/n " + RAText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 8L))); + ItemList.Robot_Arm_IV.set( + addItem( + 654, + "Robot Arm (IV)", + "1 stack every 1/20 sec (as Cover)/n " + RAText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 16L))); + ItemList.Robot_Arm_LuV.set( + addItem( + 655, + "Robot Arm (LuV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 32L))); + ItemList.Robot_Arm_ZPM.set( + addItem( + 656, + "Robot Arm (ZPM)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 64L))); + ItemList.Robot_Arm_UV.set( + addItem( + 657, + "Robot Arm (UV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 128L))); + ItemList.Robot_Arm_UHV.set( + addItem( + 658, + "Robot Arm (UHV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 256L))); + ItemList.Robot_Arm_UEV.set( + addItem( + 659, + "Robot Arm (UEV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1024L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 512L))); + ItemList.Robot_Arm_UIV.set( + addItem( + 33, + "Robot Arm (UIV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1024L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 512L))); + ItemList.Robot_Arm_UMV.set( + addItem( + 34, + "Robot Arm (UMV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1024L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 512L))); + ItemList.Robot_Arm_UXV.set( + addItem( + 35, + "Robot Arm (UXV)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1024L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 512L))); + ItemList.Robot_Arm_MAX.set( + addItem( + 36, + "Robot Arm (MAX)", + PartNotCoverText, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1024L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 512L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Robot_Arm_LV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "CCC", "MSM", "PES", 'S', OrePrefixes.stick.get(Materials.Steel), 'M', + ItemList.Electric_Motor_LV, 'P', ItemList.Electric_Piston_LV, 'E', + OrePrefixes.circuit.get(Materials.Basic), 'C', OrePrefixes.cableGt01.get(Materials.Tin) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Robot_Arm_MV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "CCC", "MSM", "PES", 'S', OrePrefixes.stick.get(Materials.Aluminium), 'M', + ItemList.Electric_Motor_MV, 'P', ItemList.Electric_Piston_MV, 'E', + OrePrefixes.circuit.get(Materials.Good), 'C', OrePrefixes.cableGt01.get(Materials.AnyCopper) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Robot_Arm_HV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "CCC", "MSM", "PES", 'S', OrePrefixes.stick.get(Materials.StainlessSteel), 'M', + ItemList.Electric_Motor_HV, 'P', ItemList.Electric_Piston_HV, 'E', + OrePrefixes.circuit.get(Materials.Advanced), 'C', OrePrefixes.cableGt01.get(Materials.Gold) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Robot_Arm_EV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "CCC", "MSM", "PES", 'S', OrePrefixes.stick.get(Materials.Titanium), 'M', + ItemList.Electric_Motor_EV, 'P', ItemList.Electric_Piston_EV, 'E', + OrePrefixes.circuit.get(Materials.Data), 'C', OrePrefixes.cableGt01.get(Materials.Aluminium) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Robot_Arm_IV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "CCC", "MSM", "PES", 'S', OrePrefixes.stick.get(Materials.TungstenSteel), 'M', + ItemList.Electric_Motor_IV, 'P', ItemList.Electric_Piston_IV, 'E', + OrePrefixes.circuit.get(Materials.Elite), 'C', OrePrefixes.cableGt01.get(Materials.Tungsten) }); + + GregTech_API.registerCover( + ItemList.Robot_Arm_LV.get(1L), + TextureFactory.of(MACHINE_CASINGS[1][0], TextureFactory.of(OVERLAY_ARM)), + new GT_Cover_Arm(400, TextureFactory.of(OVERLAY_ARM))); + GregTech_API.registerCover( + ItemList.Robot_Arm_MV.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_ARM)), + new GT_Cover_Arm(100, TextureFactory.of(OVERLAY_ARM))); + GregTech_API.registerCover( + ItemList.Robot_Arm_HV.get(1L), + TextureFactory.of(MACHINE_CASINGS[3][0], TextureFactory.of(OVERLAY_ARM)), + new GT_Cover_Arm(20, TextureFactory.of(OVERLAY_ARM))); + GregTech_API.registerCover( + ItemList.Robot_Arm_EV.get(1L), + TextureFactory.of(MACHINE_CASINGS[4][0], TextureFactory.of(OVERLAY_ARM)), + new GT_Cover_Arm(4, TextureFactory.of(OVERLAY_ARM))); + GregTech_API.registerCover( + ItemList.Robot_Arm_IV.get(1L), + TextureFactory.of(MACHINE_CASINGS[5][0], TextureFactory.of(OVERLAY_ARM)), + new GT_Cover_Arm(1, TextureFactory.of(OVERLAY_ARM))); + + ItemList.QuantumEye.set(addItem(tLastID = 724, "Quantum Eye", "Improved Ender Eye")); + ItemList.QuantumStar.set(addItem(tLastID = 725, "Quantum Star", "Improved Nether Star")); + ItemList.Gravistar.set(addItem(tLastID = 726, "Gravi Star", "Ultimate Nether Star")); + + ItemList.Emitter_LV.set( + addItem( + 680, + "Emitter (LV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 1L))); + ItemList.Emitter_MV.set( + addItem( + 681, + "Emitter (MV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 2L))); + ItemList.Emitter_HV.set( + addItem( + 682, + "Emitter (HV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 4L))); + ItemList.Emitter_EV.set( + addItem( + 683, + "Emitter (EV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 8L))); + ItemList.Emitter_IV.set( + addItem( + 684, + "Emitter (IV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 16L))); + ItemList.Emitter_LuV.set( + addItem( + 685, + "Emitter (LuV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 32L))); + ItemList.Emitter_ZPM.set( + addItem( + 686, + "Emitter (ZPM)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 64L))); + ItemList.Emitter_UV.set( + addItem( + 687, + "Emitter (UV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 128L))); + ItemList.Emitter_UHV.set( + addItem( + 688, + "Emitter (UHV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 256L))); + ItemList.Emitter_UEV.set( + addItem( + 689, + "Emitter (UEV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 512L))); + ItemList.Emitter_UIV.set( + addItem( + 37, + "Emitter (UIV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 512L))); + ItemList.Emitter_UMV.set( + addItem( + 38, + "Emitter (UMV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 512L))); + ItemList.Emitter_UXV.set( + addItem( + 39, + "Emitter (UXV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 512L))); + ItemList.Emitter_MAX.set( + addItem( + 40, + "Emitter (MAX)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 512L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Emitter_LV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "SSC", "WQS", "CWS", 'Q', OrePrefixes.gem.get(Materials.CertusQuartz), 'S', + OrePrefixes.stick.get(Materials.Brass), 'C', OrePrefixes.circuit.get(Materials.Basic), 'W', + OrePrefixes.cableGt01.get(Materials.Tin) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Emitter_MV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "SSC", "WQS", "CWS", 'Q', OrePrefixes.gem.get(Materials.EnderPearl), 'S', + OrePrefixes.stick.get(Materials.Electrum), 'C', OrePrefixes.circuit.get(Materials.Good), 'W', + OrePrefixes.cableGt01.get(Materials.AnyCopper) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Emitter_HV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "SSC", "WQS", "CWS", 'Q', OrePrefixes.gem.get(Materials.EnderEye), 'S', + OrePrefixes.stick.get(Materials.Chrome), 'C', OrePrefixes.circuit.get(Materials.Advanced), 'W', + OrePrefixes.cableGt01.get(Materials.Gold) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Emitter_EV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "SSC", "WQS", "CWS", 'Q', ItemList.QuantumEye, 'S', + OrePrefixes.stick.get(Materials.Platinum), 'C', OrePrefixes.circuit.get(Materials.Data), 'W', + OrePrefixes.cableGt01.get(Materials.Aluminium) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Emitter_IV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "SSC", "WQS", "CWS", 'Q', ItemList.QuantumStar, 'S', + OrePrefixes.stick.get(Materials.Iridium), 'C', OrePrefixes.circuit.get(Materials.Elite), 'W', + OrePrefixes.cableGt01.get(Materials.Tungsten) }); + + ItemList.Sensor_LV.set( + addItem( + 690, + "Sensor (LV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 1L))); + ItemList.Sensor_MV.set( + addItem( + 691, + "Sensor (MV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L))); + ItemList.Sensor_HV.set( + addItem( + 692, + "Sensor (HV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 4L))); + ItemList.Sensor_EV.set( + addItem( + 693, + "Sensor (EV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 8L))); + ItemList.Sensor_IV.set( + addItem( + 694, + "Sensor (IV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 16L))); + ItemList.Sensor_LuV.set( + addItem( + 695, + "Sensor (LuV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 32L))); + ItemList.Sensor_ZPM.set( + addItem( + 696, + "Sensor (ZPM)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 64L))); + ItemList.Sensor_UV.set( + addItem( + 697, + "Sensor (UV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 128L))); + ItemList.Sensor_UHV.set( + addItem( + 698, + "Sensor (UHV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 256L))); + ItemList.Sensor_UEV.set( + addItem( + 699, + "Sensor (UEV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 512L))); + ItemList.Sensor_UIV.set( + addItem( + 41, + "Sensor (UIV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 512L))); + ItemList.Sensor_UMV.set( + addItem( + 42, + "Sensor (UMV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 512L))); + ItemList.Sensor_UXV.set( + addItem( + 43, + "Sensor (UXV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 512L))); + ItemList.Sensor_MAX.set( + addItem( + 44, + "Sensor (MAX)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 512L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Sensor_LV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "P Q", "PS ", "CPP", 'Q', OrePrefixes.gem.get(Materials.CertusQuartz), 'S', + OrePrefixes.stick.get(Materials.Brass), 'P', OrePrefixes.plate.get(Materials.Steel), 'C', + OrePrefixes.circuit.get(Materials.Basic) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Sensor_MV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "P Q", "PS ", "CPP", 'Q', OrePrefixes.gemFlawless.get(Materials.Emerald), 'S', + OrePrefixes.stick.get(Materials.Electrum), 'P', OrePrefixes.plate.get(Materials.Aluminium), 'C', + OrePrefixes.circuit.get(Materials.Good) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Sensor_HV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "P Q", "PS ", "CPP", 'Q', OrePrefixes.gem.get(Materials.EnderEye), 'S', + OrePrefixes.stick.get(Materials.Chrome), 'P', OrePrefixes.plate.get(Materials.StainlessSteel), 'C', + OrePrefixes.circuit.get(Materials.Advanced) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Sensor_EV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "P Q", "PS ", "CPP", 'Q', ItemList.QuantumEye, 'S', + OrePrefixes.stick.get(Materials.Platinum), 'P', OrePrefixes.plate.get(Materials.Titanium), 'C', + OrePrefixes.circuit.get(Materials.Data) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Sensor_IV.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "P Q", "PS ", "CPP", 'Q', ItemList.QuantumStar, 'S', + OrePrefixes.stick.get(Materials.Iridium), 'P', OrePrefixes.plate.get(Materials.TungstenSteel), 'C', + OrePrefixes.circuit.get(Materials.Elite) }); + + ItemList.Field_Generator_LV.set( + addItem( + 670, + "Field Generator (LV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 1L))); + ItemList.Field_Generator_MV.set( + addItem( + 671, + "Field Generator (MV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 2L))); + ItemList.Field_Generator_HV.set( + addItem( + 672, + "Field Generator (HV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 4L))); + ItemList.Field_Generator_EV.set( + addItem( + 673, + "Field Generator (EV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 8L))); + ItemList.Field_Generator_IV.set( + addItem( + 674, + "Field Generator (IV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 16L))); + ItemList.Field_Generator_LuV.set( + addItem( + 675, + "Field Generator (LuV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 32L))); + ItemList.Field_Generator_ZPM.set( + addItem( + 676, + "Field Generator (ZPM)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 64L))); + ItemList.Field_Generator_UV.set( + addItem( + 677, + "Field Generator (UV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 128L))); + ItemList.Field_Generator_UHV.set( + addItem( + 678, + "Field Generator (UHV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 256L))); + ItemList.Field_Generator_UEV.set( + addItem( + 679, + "Field Generator (UEV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1024L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 512L))); + ItemList.Field_Generator_UIV.set( + addItem( + 45, + "Field Generator (UIV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1024L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 512L))); + ItemList.Field_Generator_UMV.set( + addItem( + 46, + "Field Generator (UMV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1024L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 512L))); + ItemList.Field_Generator_UXV.set( + addItem( + 47, + "Field Generator (UXV)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1024L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 512L))); + ItemList.Field_Generator_MAX.set( + addItem( + 48, + "Field Generator (MAX)", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1024L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 512L))); + + ItemList.StableAdhesive.set( + addItem( + 427, + "Hyper-Stable Self-Healing Adhesive", + "Complete and selective adhesion, even when torn or damaged", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 30L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 20L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LIMUS, 10L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VINCULUM, 5L))); + ItemList.SuperconductorComposite.set( + addItem( + 428, + "Superconductor Rare-Earth Composite", + "Zero resistance to electrical and quantum flow, regardless of temperature", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 50L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 25L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TERRA, 15L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 10L))); + ItemList.NaquadriaSupersolid.set( + addItem( + 429, + "Black Body Naquadria Supersolid", + "Flows like a fluid and reflects nothing, perfect absorption and transfer", + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 100L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 60L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 40L), + new TC_Aspects.TC_AspectStack(TC_Aspects.RADIO, 20L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ALIENIS, 10L))); + + // Circuits ULV - LuV. + ItemList.Circuit_Primitive.set( + addItem( + tLastID = 700, + "Vacuum Tube", + "A very simple Circuit", + OrePrefixes.circuit.get(Materials.Primitive), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Primitive.get(1), ULV); + ItemList.Circuit_Basic.set( + addItem( + tLastID = 701, + "Integrated Logic Circuit", + "A Basic Circuit", + OrePrefixes.circuit.get(Materials.Basic), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Basic.get(1), LV); + ItemList.Circuit_Good.set( + addItem( + tLastID = 702, + "Good Electronic Circuit", + "A Good Circuit", + OrePrefixes.circuit.get(Materials.Good), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Good.get(1), MV); + ItemList.Circuit_Advanced.set( + addItem( + tLastID = 703, + "Processor Assembly", + "An Advanced Circuit", + OrePrefixes.circuit.get(Materials.Advanced), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Advanced.get(1), HV); + ItemList.Circuit_Data.set( + addItem( + tLastID = 704, + "Workstation", + "An Extreme Circuit", + OrePrefixes.circuit.get(Materials.Data), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Data.get(1), EV); + ItemList.Circuit_Elite.set( + addItem( + tLastID = 705, + "Mainframe", + "An Elite Circuit", + OrePrefixes.circuit.get(Materials.Elite), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Elite.get(1), IV); + ItemList.Circuit_Master.set( + addItem( + tLastID = 706, + "Nanoprocessor Mainframe", + "A Master Circuit", + OrePrefixes.circuit.get(Materials.Master), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Master.get(1), LuV); + + // Backwards compatibility. + ItemList.Circuit_Parts_Vacuum_Tube.set(ItemList.Circuit_Primitive.get(1)); + ItemList.Circuit_Computer.set(ItemList.Circuit_Advanced.get(1)); + + ItemList.Tool_DataOrb.set( + addItem( + tLastID = 707, + "Data Orb", + "A High Capacity Data Storage", + SubTag.NO_UNIFICATION, + new Behaviour_DataOrb())); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Tool_DataOrb.get(1L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Tool_DataOrb.get(1L) }); + ItemList.Tool_DataStick.set( + addItem( + tLastID = 708, + "Data Stick", + "A Low Capacity Data Storage", + SubTag.NO_UNIFICATION, + new Behaviour_DataStick())); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Tool_DataStick.get(1L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ItemList.Tool_DataStick.get(1L) }); + ItemList.Tool_Cover_Copy_Paste.set( + addItem( + tLastID = 709, + "Cover Copy/Paste tool", + "Set Cover Massively.", + Behaviour_Cover_Tool.INSTANCE, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 6L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 6L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 6L))); + setElectricStats(32000 + tLastID, 400000L, GT_Values.V[2], 2L, -1L, false); + + ItemList.Circuit_Board_Basic.set(addItem(tLastID = 710, "Coated Circuit Board", "A Basic Board")); + ItemList.Circuit_Board_Coated.set(ItemList.Circuit_Board_Basic.get(1)); + ItemList.Circuit_Board_Advanced.set(addItem(tLastID = 711, "Epoxy Circuit Board", "An Advanced Board")); + ItemList.Circuit_Board_Epoxy.set(ItemList.Circuit_Board_Advanced.get(1)); + ItemList.Circuit_Board_Elite + .set(addItem(tLastID = 712, "Multilayer Fiber-Reinforced Circuit Board", "An Elite Board")); + ItemList.Circuit_Board_Multifiberglass.set(ItemList.Circuit_Board_Elite.get(1)); + ItemList.Circuit_Parts_Crystal_Chip_Elite + .set(addItem(tLastID = 713, "Engraved Crystal Chip", "Needed for Circuits")); + ItemList.Circuit_Parts_Crystal_Chip_Master + .set(addItem(tLastID = 714, "Engraved Lapotron Chip", "Needed for Circuits")); + ItemList.Circuit_Parts_Crystal_Chip_Wetware + .set(addItem(tLastID = 668, "Living Crystal Chip", "Needed for Circuits")); + ItemList.Circuit_Parts_Advanced.set(addItem(tLastID = 715, "Diode", "Basic Electronic Component")); + ItemList.Circuit_Parts_Diode.set(ItemList.Circuit_Parts_Advanced.get(1)); + ItemList.Circuit_Parts_Wiring_Basic.set(addItem(tLastID = 716, "Resistor", "Basic Electronic Component")); + ItemList.Circuit_Parts_Resistor.set(ItemList.Circuit_Parts_Wiring_Basic.get(1)); + ItemList.Circuit_Parts_Wiring_Advanced.set(addItem(tLastID = 717, "Transistor", "Basic Electronic Component")); + ItemList.Circuit_Parts_Transistor.set(ItemList.Circuit_Parts_Wiring_Advanced.get(1)); + ItemList.Circuit_Parts_Wiring_Elite.set(addItem(tLastID = 718, "Capacitor", "Electronic Component")); + ItemList.Circuit_Parts_Capacitor.set(ItemList.Circuit_Parts_Wiring_Elite.get(1)); + ItemList.Empty_Board_Basic.set(addItem(tLastID = 719, "Phenolic Circuit Board", "A Good Board")); + ItemList.Circuit_Board_Phenolic.set(ItemList.Empty_Board_Basic.get(1)); + ItemList.Empty_Board_Elite.set(addItem(tLastID = 720, "Fiber-Reinforced Circuit Board", "An Extreme Board")); + ItemList.Circuit_Board_Fiberglass.set(ItemList.Empty_Board_Elite.get(1)); + + ItemList.Component_Sawblade_Diamond.set( + addItem( + tLastID = 721, + "Diamond Sawblade", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERDITIO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 4L), + OreDictNames.craftingDiamondBlade)); + ItemList.Component_Grinder_Diamond.set( + addItem( + tLastID = 722, + "Diamond Grinding Head", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERDITIO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 6L), + OreDictNames.craftingGrinder)); + ItemList.Component_Grinder_Tungsten.set( + addItem( + tLastID = 723, + "Tungsten Grinding Head", + "", + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERDITIO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 6L), + OreDictNames.craftingGrinder)); + + GT_ModHandler.addCraftingRecipe( + ItemList.Component_Sawblade_Diamond.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { " D ", "DGD", " D ", 'D', OrePrefixes.dustSmall.get(Materials.Diamond), 'G', + OrePrefixes.gearGt.get(Materials.CobaltBrass) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Component_Grinder_Diamond.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "DSD", "SIS", "DSD", 'I', OrePrefixes.gem.get(Materials.Diamond), 'D', + OrePrefixes.dust.get(Materials.Diamond), 'S', OrePrefixes.plateDouble.get(Materials.Steel) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Component_Grinder_Tungsten.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "TST", "SIS", "TST", 'I', OreDictNames.craftingIndustrialDiamond, 'T', + OrePrefixes.plate.get(Materials.Tungsten), 'S', OrePrefixes.plateDouble.get(Materials.Steel) }); + + ItemList.Upgrade_Muffler.set( + addItem( + tLastID = 727, + "Muffler Upgrade", + "Makes Machines silent", + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 2L))); + ItemList.Upgrade_Lock.set( + addItem( + tLastID = 728, + "Lock Upgrade", + "Protects your Machines", + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 4L))); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Aluminium, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Plastic, 2L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Upgrade_Muffler.get(1L)) + .duration(1 * MINUTES + 20 * SECONDS) + .eut(2) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Aluminium, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Upgrade_Muffler.get(1L)) + .duration(1 * MINUTES + 20 * SECONDS) + .eut(2) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Iron, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Plastic, 2L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Upgrade_Muffler.get(1L)) + .duration(1 * MINUTES + 20 * SECONDS) + .eut(2) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Iron, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Upgrade_Muffler.get(1L)) + .duration(1 * MINUTES + 20 * SECONDS) + .eut(2) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.WroughtIron, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Plastic, 2L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Upgrade_Muffler.get(1L)) + .duration(1 * MINUTES + 20 * SECONDS) + .eut(2) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.WroughtIron, 1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 2L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Upgrade_Muffler.get(1L)) + .duration(1 * MINUTES + 20 * SECONDS) + .eut(2) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Aluminium, 1L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Iridium, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Upgrade_Lock.get(1L)) + .duration(5 * MINUTES + 20 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Iron, 1L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Iridium, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Upgrade_Lock.get(1L)) + .duration(5 * MINUTES + 20 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.WroughtIron, 1L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Iridium, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Upgrade_Lock.get(1L)) + .duration(5 * MINUTES + 20 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + + ItemList.Component_Filter.set( + addItem( + tLastID = 729, + "Item Filter", + "", + new ItemData(Materials.Zinc, OrePrefixes.foil.mMaterialAmount * 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 1L), + OreDictNames.craftingFilter)); + + ItemList.Cover_Controller.set( + addItem( + tLastID = 730, + "Machine Controller Cover", + "Turns Machines ON/OFF", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L))); + ItemList.Cover_ActivityDetector.set( + addItem( + tLastID = 731, + "Activity Detector Cover", + "Gives out Activity as Redstone", + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L))); + ItemList.Cover_FluidDetector.set( + addItem( + tLastID = 732, + "Fluid Detector Cover", + "Gives out Fluid Amount as Redstone", + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L))); + ItemList.Cover_ItemDetector.set( + addItem( + tLastID = 733, + "Item Detector Cover", + "Gives out Item Amount as Redstone", + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TERRA, 1L))); + ItemList.Cover_EnergyDetector.set( + addItem( + tLastID = 734, + "Energy Detector Cover", + "Gives out Energy Amount as Redstone", + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L))); + ItemList.Cover_PlayerDetector.set( + addItem( + tLastID = 735, + "Player Detector Cover", + "Gives out close Players as Redstone", + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L))); + ItemList.Cover_FluidStorageMonitor.set( + addItem( + tLastID = 577, + "Fluid Storage Monitor Cover", + "Displays the fluid stored in the Tank", + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L))); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Sensor_EV.get(1L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Titanium, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_PlayerDetector.get(1L)) + .duration(2 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + + GregTech_API.registerCover( + ItemList.Cover_Controller.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_CONTROLLER)), + new GT_Cover_ControlsWork(TextureFactory.of(OVERLAY_CONTROLLER))); + + final ITexture doesWorkCoverTexture = TextureFactory.of( + TextureFactory.of(OVERLAY_ACTIVITYDETECTOR), + TextureFactory.builder() + .addIcon(OVERLAY_ACTIVITYDETECTOR_GLOW) + .glow() + .build()); + GregTech_API.registerCover( + ItemList.Cover_ActivityDetector.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], doesWorkCoverTexture), + new GT_Cover_DoesWork(doesWorkCoverTexture)); + GregTech_API.registerCover( + ItemList.Cover_FluidDetector.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_FLUIDDETECTOR)), + new GT_Cover_LiquidMeter(TextureFactory.of(OVERLAY_FLUIDDETECTOR))); + GregTech_API.registerCover( + ItemList.Cover_ItemDetector.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_ITEMDETECTOR)), + new GT_Cover_ItemMeter(TextureFactory.of(OVERLAY_ITEMDETECTOR))); + GregTech_API.registerCover( + ItemList.Cover_EnergyDetector.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_ENERGYDETECTOR)), + new GT_Cover_EUMeter(TextureFactory.of(OVERLAY_ENERGYDETECTOR))); + + final ITexture playerDectectorCoverTexture = TextureFactory.of( + TextureFactory.of(OVERLAY_ACTIVITYDETECTOR), + TextureFactory.builder() + .addIcon(OVERLAY_ACTIVITYDETECTOR_GLOW) + .glow() + .build()); + GregTech_API.registerCover( + ItemList.Cover_PlayerDetector.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], playerDectectorCoverTexture), + new GT_Cover_PlayerDetector(playerDectectorCoverTexture)); + GregTech_API.registerCover( + ItemList.Cover_FluidStorageMonitor.get(1L), + TextureFactory.of(OVERLAY_FLUID_STORAGE_MONITOR0), + new GT_Cover_FluidStorageMonitor()); + + ItemList.Cover_Screen.set( + addItem( + tLastID = 740, + "Computer Monitor Cover", + "Displays Data and GUI", + new TC_Aspects.TC_AspectStack(TC_Aspects.COGNITIO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUX, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L))); + ItemList.Cover_Crafting.set( + addItem( + tLastID = 744, + "Crafting Table Cover", + "Better than a wooden Workbench", + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 4L))); + ItemList.Cover_Drain.set( + addItem( + tLastID = 745, + "Drain Module Cover", + "Absorbs Fluids and collects Rain", + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 2L))); + + ItemList.Cover_Shutter.set( + addItem( + tLastID = 749, + "Shutter Module Cover", + "Blocks Inventory/Tank Side. Use together with Machine Controller.", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 1L))); + + GT_ModHandler.addCraftingRecipe( + ItemList.Cover_Screen.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "AGA", "RPB", "ALA", 'A', OrePrefixes.plate.get(Materials.Aluminium), 'L', + OrePrefixes.dust.get(Materials.Glowstone), 'R', Dyes.dyeRed, 'G', Dyes.dyeLime, 'B', Dyes.dyeBlue, 'P', + OrePrefixes.plate.get(Materials.Glass) }); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Aluminium, 1L), + ItemList.Cover_Drain.get(1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_Shutter.get(1L)) + .duration(40 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Iron, 1L), + ItemList.Cover_Drain.get(1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_Shutter.get(1L)) + .duration(40 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.WroughtIron, 1L), + ItemList.Cover_Drain.get(1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_Shutter.get(1L)) + .duration(40 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Aluminium, 2L), + new ItemStack(Blocks.iron_bars, 2), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_Drain.get(1L)) + .duration(40 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Iron, 2L), + new ItemStack(Blocks.iron_bars, 2), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_Drain.get(1L)) + .duration(40 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.WroughtIron, 2L), + new ItemStack(Blocks.iron_bars, 2), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_Drain.get(1L)) + .duration(40 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Aluminium, 1L), + new ItemStack(Blocks.crafting_table, 1), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_Crafting.get(1L)) + .duration(40 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Iron, 1L), + new ItemStack(Blocks.crafting_table, 1), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_Crafting.get(1L)) + .duration(40 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.WroughtIron, 1L), + new ItemStack(Blocks.crafting_table, 1), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_Crafting.get(1L)) + .duration(40 * SECONDS) + .eut(16) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Cover_Shutter.get(1L), + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Basic, 1), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.FluidFilter.get(1L)) + .duration(40 * SECONDS) + .eut(4) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Cover_Screen.get(1L), + ItemList.Cover_FluidDetector.get(1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_FluidStorageMonitor.get(1L)) + .duration(40 * SECONDS) + .eut(4) + .addTo(assemblerRecipes); + + final ITexture screenCoverTexture = TextureFactory.of( + TextureFactory.of(OVERLAY_SCREEN), + TextureFactory.builder() + .addIcon(OVERLAY_SCREEN_GLOW) + .glow() + .build()); + GregTech_API.registerCover( + ItemList.Cover_Screen.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], screenCoverTexture), + new GT_Cover_Screen(screenCoverTexture)); + GregTech_API.registerCover( + ItemList.Cover_Crafting.get(1L), + TextureFactory.of(MACHINE_CASINGS[1][0], TextureFactory.of(OVERLAY_CRAFTING)), + new GT_Cover_Crafting(TextureFactory.of(OVERLAY_CRAFTING))); + GregTech_API.registerCover( + ItemList.Cover_Drain.get(1L), + TextureFactory.of(MACHINE_CASINGS[0][0], TextureFactory.of(OVERLAY_DRAIN)), + new GT_Cover_Drain(TextureFactory.of(OVERLAY_DRAIN))); + GregTech_API.registerCover( + ItemList.Cover_Shutter.get(1L), + TextureFactory.of(MACHINE_CASINGS[1][0], TextureFactory.of(OVERLAY_SHUTTER)), + new GT_Cover_Shutter(TextureFactory.of(OVERLAY_SHUTTER))); + + ItemList.Cover_SolarPanel.set( + addItem( + tLastID = 750, + "Solar Panel", + "May the Sun be with you (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 1L))); + ItemList.Cover_SolarPanel_8V.set( + addItem( + tLastID = 751, + "Solar Panel (8V)", + "8 Volt Solar Panel (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 2L))); + ItemList.Cover_SolarPanel_LV.set( + addItem( + tLastID = 752, + "Solar Panel (LV)", + "Low Voltage Solar Panel (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 4L))); + ItemList.Cover_SolarPanel_MV.set( + addItem( + tLastID = 753, + "Solar Panel (MV)", + "Medium Voltage Solar Panel (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 8L))); + ItemList.Cover_SolarPanel_HV.set( + addItem( + tLastID = 754, + "Solar Panel (HV)", + "High Voltage Solar Panel (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 16L))); + ItemList.Cover_SolarPanel_EV.set( + addItem( + tLastID = 755, + "Solar Panel (EV)", + "Extreme Solar Panel (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 32L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 32L))); + ItemList.Cover_SolarPanel_IV.set( + addItem( + tLastID = 756, + "Solar Panel (IV)", + "Insane Solar Panel (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 64L))); + ItemList.Cover_SolarPanel_LuV.set( + addItem( + tLastID = 757, + "Solar Panel (LuV)", + "Ludicrous Solar Panel (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 64L))); + ItemList.Cover_SolarPanel_ZPM.set( + addItem( + tLastID = 758, + "Solar Panel (ZPM)", + "ZPM Voltage Solar Panel (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 64L))); + ItemList.Cover_SolarPanel_UV.set( + addItem( + tLastID = 759, + "Solar Panel (UV)", + "Ultimate Solar Panel (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 64L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 64L))); + + GregTech_API.registerCover( + ItemList.Cover_SolarPanel.get(1L), + TextureFactory.of(SOLARPANEL), + new GT_Cover_SolarPanel(1)); + GregTech_API.registerCover( + ItemList.Cover_SolarPanel_8V.get(1L), + TextureFactory.of(SOLARPANEL_8V), + new GT_Cover_SolarPanel(8)); + GregTech_API.registerCover( + ItemList.Cover_SolarPanel_LV.get(1L), + TextureFactory.of(SOLARPANEL_LV), + new GT_Cover_SolarPanel(32)); + GregTech_API.registerCover( + ItemList.Cover_SolarPanel_MV.get(1L), + TextureFactory.of(SOLARPANEL_MV), + new GT_Cover_SolarPanel(128)); + GregTech_API.registerCover( + ItemList.Cover_SolarPanel_HV.get(1L), + TextureFactory.of(SOLARPANEL_HV), + new GT_Cover_SolarPanel(512)); + GregTech_API.registerCover( + ItemList.Cover_SolarPanel_EV.get(1L), + TextureFactory.of(SOLARPANEL_EV), + new GT_Cover_SolarPanel(2048)); + GregTech_API.registerCover( + ItemList.Cover_SolarPanel_IV.get(1L), + TextureFactory.of(SOLARPANEL_IV), + new GT_Cover_SolarPanel(8192)); + GregTech_API.registerCover( + ItemList.Cover_SolarPanel_LuV.get(1L), + TextureFactory.of(SOLARPANEL_LuV), + new GT_Cover_SolarPanel(32768)); + GregTech_API.registerCover( + ItemList.Cover_SolarPanel_ZPM.get(1L), + TextureFactory.of(SOLARPANEL_ZPM), + new GT_Cover_SolarPanel(131072)); + GregTech_API.registerCover( + ItemList.Cover_SolarPanel_UV.get(1L), + TextureFactory.of(SOLARPANEL_UV), + new GT_Cover_SolarPanel(524288)); + + ItemList.Tool_Sonictron.set( + addItem( + tLastID = 760, + "Sonictron", + "Bring your Music with you", + Behaviour_Sonictron.INSTANCE, + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 4L))); + ItemList.Tool_Cheat.set( + addItem( + tLastID = 761, + "Debug Scanner", + "Also an Infinite Energy Source", + Behaviour_Scanner.INSTANCE, + new TC_Aspects.TC_AspectStack(TC_Aspects.NEBRISUM, 64L))); + setElectricStats(32000 + tLastID, -2000000000L, 1000000000L, -1L, -3L, false); + ItemList.Tool_Scanner.set( + addItem( + tLastID = 762, + "Portable Scanner", + "Tricorder", + Behaviour_Scanner.INSTANCE, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 6L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 6L))); + setElectricStats(32000 + tLastID, 400000L, GT_Values.V[2], 2L, -1L, false); + GT_ModHandler.addCraftingRecipe( + ItemList.Tool_Scanner.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.NOT_REMOVABLE + | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "EPR", "CSC", "PBP", 'C', OrePrefixes.circuit.get(Materials.Advanced), 'P', + OrePrefixes.plate.get(Materials.Aluminium), 'E', ItemList.Emitter_MV, 'R', ItemList.Sensor_MV, 'S', + ItemList.Cover_Screen, 'B', ItemList.Battery_RE_MV_Lithium }); + ItemList.NC_SensorKit.set(addItem(tLastID = 763, "GregTech Sensor Kit", "", new Behaviour_SensorKit())); + ItemList.Duct_Tape.set( + addItem( + tLastID = 764, + "BrainTech Aerospace Advanced Reinforced Duct Tape FAL-84", + "If you can't fix it with this, use more of it!", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + OreDictNames.craftingDuctTape)); + ItemList.McGuffium_239.set( + addItem( + tLastID = 765, + "Mc Guffium 239", + "42% better than Phlebotnium", + new TC_Aspects.TC_AspectStack(TC_Aspects.ALIENIS, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SPIRITUS, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AURAM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITIUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.RADIO, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MAGNETO, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.NEBRISUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.STRONTIO, 8L))); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Sensor_LV.get(1L), ItemList.Emitter_LV.get(1L), GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.NC_SensorKit.get(1L)) + .duration(1 * MINUTES + 20 * SECONDS) + .eut(2) + .addTo(assemblerRecipes); + + ItemList.Cover_RedstoneTransmitterExternal.set( + addItem( + tLastID = 741, + "Redstone Transmitter (External)", + "Transfers Redstone signals wireless", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L))); + ItemList.Cover_RedstoneTransmitterInternal.set( + addItem( + tLastID = 742, + "Redstone Transmitter (Internal)", + "Transfers Redstone signals wireless", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L))); + ItemList.Cover_RedstoneReceiverExternal.set( + addItem( + tLastID = 746, + "Redstone Receiver (External)", + "Transfers Redstone signals wireless", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L))); + ItemList.Cover_RedstoneReceiverInternal.set( + addItem( + tLastID = 747, + "Redstone Receiver (Internal)", + "Transfers Redstone signals wireless", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L))); + + GregTech_API.registerCover( + ItemList.Cover_RedstoneTransmitterExternal.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_REDSTONE_TRANSMITTER)), + new GT_Cover_RedstoneTransmitterExternal(TextureFactory.of(OVERLAY_REDSTONE_TRANSMITTER))); + GregTech_API.registerCover( + ItemList.Cover_RedstoneTransmitterInternal.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_REDSTONE_TRANSMITTER)), + new GT_Cover_RedstoneTransmitterInternal(TextureFactory.of(OVERLAY_REDSTONE_TRANSMITTER))); + GregTech_API.registerCover( + ItemList.Cover_RedstoneReceiverExternal.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_REDSTONE_RECEIVER)), + new GT_Cover_RedstoneReceiverExternal(TextureFactory.of(OVERLAY_REDSTONE_RECEIVER))); + GregTech_API.registerCover( + ItemList.Cover_RedstoneReceiverInternal.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_REDSTONE_RECEIVER)), + new GT_Cover_RedstoneReceiverInternal(TextureFactory.of(OVERLAY_REDSTONE_RECEIVER))); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Emitter_EV.get(1L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.StainlessSteel, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_RedstoneTransmitterExternal.get(1L)) + .duration(2 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Sensor_EV.get(1L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.StainlessSteel, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_RedstoneReceiverExternal.get(1L)) + .duration(2 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Cover_RedstoneTransmitterInternal.get(1L), + new Object[] { ItemList.Cover_RedstoneTransmitterExternal.get(1L) }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Cover_RedstoneReceiverInternal.get(1L), + new Object[] { ItemList.Cover_RedstoneReceiverExternal.get(1L) }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Cover_RedstoneTransmitterExternal.get(1L), + new Object[] { ItemList.Cover_RedstoneTransmitterInternal.get(1L) }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Cover_RedstoneReceiverExternal.get(1L), + new Object[] { ItemList.Cover_RedstoneReceiverInternal.get(1L) }); + + ItemList.Cover_NeedsMaintainance.set( + addItem( + tLastID = 748, + "Needs Maintenance Cover", + "Attach to Multiblock Controller. Emits Redstone Signal if needs Maintenance", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L))); + GregTech_API.registerCover( + ItemList.Cover_NeedsMaintainance.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_MAINTENANCE_DETECTOR)), + new GT_Cover_NeedMaintainance(TextureFactory.of(OVERLAY_MAINTENANCE_DETECTOR))); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Emitter_MV.get(1L), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Aluminium, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_NeedsMaintainance.get(1L)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + + GT_ModHandler.addCraftingRecipe( + ItemList.ItemFilter_Export.get(1L), + new Object[] { "SPS", "dIC", "SPS", 'P', OrePrefixes.plate.get(Materials.Tin), 'S', + OrePrefixes.screw.get(Materials.Iron), 'I', ItemList.Component_Filter, 'C', + ItemList.Conveyor_Module_LV }); + GT_ModHandler.addCraftingRecipe( + ItemList.ItemFilter_Import.get(1L), + new Object[] { "SPS", "CId", "SPS", 'P', OrePrefixes.plate.get(Materials.Tin), 'S', + OrePrefixes.screw.get(Materials.Iron), 'I', ItemList.Component_Filter, 'C', + ItemList.Conveyor_Module_LV }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.ItemFilter_Export.get(1L), + new Object[] { ItemList.ItemFilter_Import.get(1L) }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.ItemFilter_Import.get(1L), + new Object[] { ItemList.ItemFilter_Export.get(1L) }); + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Tin, 2L), + ItemList.Component_Filter.get(1L), + ItemList.Conveyor_Module_LV.get(1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.ItemFilter_Export.get(1L)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Tin, 2L), + ItemList.Component_Filter.get(1L), + ItemList.Conveyor_Module_LV.get(1L), + GT_Utility.getIntegratedCircuit(2)) + .itemOutputs(ItemList.ItemFilter_Import.get(1L)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(assemblerRecipes); + + GT_ModHandler.addCraftingRecipe( + ItemList.Tool_Cover_Copy_Paste.get(1L), + GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "PSP", "PCP", "PBP", 'P', OrePrefixes.plate.get(Materials.Aluminium), 'S', + ItemList.Tool_DataStick.get(1L), 'C', ItemList.Cover_Screen.get(1L), 'B', + ItemList.Battery_RE_MV_Lithium.get(1L) }); + + ItemList.Steam_Regulator_LV.set( + addItem( + tLastID = 332, + "Steam Regulator (LV)", + GT_Utility.formatNumbers(1024) + PartCoverText + GT_Utility.formatNumbers(1024 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L))); + ItemList.Steam_Regulator_MV.set( + addItem( + tLastID = 333, + "Steam Regulator (MV)", + GT_Utility.formatNumbers(2048) + PartCoverText + GT_Utility.formatNumbers(2048 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 2L))); + ItemList.Steam_Regulator_HV.set( + addItem( + tLastID = 334, + "Steam Regulator (HV)", + GT_Utility.formatNumbers(4096) + PartCoverText + GT_Utility.formatNumbers(4096 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 4L))); + ItemList.Steam_Regulator_EV.set( + addItem( + tLastID = 335, + "Steam Regulator (EV)", + GT_Utility.formatNumbers(8192) + PartCoverText + GT_Utility.formatNumbers(8192 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 8L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 8L))); + ItemList.Steam_Regulator_IV.set( + addItem( + tLastID = 336, + "Steam Regulator (IV)", + GT_Utility.formatNumbers(16384) + PartCoverText + GT_Utility.formatNumbers(16384 * 20) + PartCoverText2, + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 16L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 16L))); + + GregTech_API.registerCover( + ItemList.Steam_Regulator_LV.get(1L), + TextureFactory.of(MACHINE_CASINGS[1][0], TextureFactory.of(OVERLAY_VALVE)), + new GT_Cover_SteamRegulator(1024, TextureFactory.of(OVERLAY_VALVE))); + GregTech_API.registerCover( + ItemList.Steam_Regulator_MV.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_VALVE)), + new GT_Cover_SteamRegulator(2048, TextureFactory.of(OVERLAY_VALVE))); + GregTech_API.registerCover( + ItemList.Steam_Regulator_HV.get(1L), + TextureFactory.of(MACHINE_CASINGS[3][0], TextureFactory.of(OVERLAY_VALVE)), + new GT_Cover_SteamRegulator(4096, TextureFactory.of(OVERLAY_VALVE))); + GregTech_API.registerCover( + ItemList.Steam_Regulator_EV.get(1L), + TextureFactory.of(MACHINE_CASINGS[4][0], TextureFactory.of(OVERLAY_VALVE)), + new GT_Cover_SteamRegulator(8192, TextureFactory.of(OVERLAY_VALVE))); + GregTech_API.registerCover( + ItemList.Steam_Regulator_IV.get(1L), + TextureFactory.of(MACHINE_CASINGS[5][0], TextureFactory.of(OVERLAY_VALVE)), + new GT_Cover_SteamRegulator(16384, TextureFactory.of(OVERLAY_VALVE))); + + } + + private static final Map<Materials, Materials> cauldronRemap = new HashMap<>(); + + public static void registerCauldronCleaningFor(Materials in, Materials out) { + cauldronRemap.put(in, out); + } + + @Override + public boolean onEntityItemUpdate(EntityItem aItemEntity) { + int aDamage = aItemEntity.getEntityItem() + .getItemDamage(); + if ((aDamage < 32000) && (aDamage >= 0) && (!aItemEntity.worldObj.isRemote)) { + Materials aMaterial = GregTech_API.sGeneratedMaterials[(aDamage % 1000)]; + if ((aMaterial != null) && (aMaterial != Materials.Empty) && (aMaterial != Materials._NULL)) { + int tX = MathHelper.floor_double(aItemEntity.posX); + int tY = MathHelper.floor_double(aItemEntity.posY); + int tZ = MathHelper.floor_double(aItemEntity.posZ); + OrePrefixes aPrefix = this.mGeneratedPrefixList[(aDamage / 1000)]; + if ((aPrefix == OrePrefixes.dustImpure) || (aPrefix == OrePrefixes.dustPure)) { + Block tBlock = aItemEntity.worldObj.getBlock(tX, tY, tZ); + byte tMetaData = (byte) aItemEntity.worldObj.getBlockMetadata(tX, tY, tZ); + if ((tBlock == Blocks.cauldron) && (tMetaData > 0)) { + + aMaterial = cauldronRemap.getOrDefault(aMaterial, aMaterial); + + aItemEntity.setEntityItemStack( + GT_OreDictUnificator + .get(OrePrefixes.dust, aMaterial, aItemEntity.getEntityItem().stackSize)); + aItemEntity.worldObj.setBlockMetadataWithNotify(tX, tY, tZ, tMetaData - 1, 3); + return true; + } + } else if (aPrefix == OrePrefixes.crushed) { + Block tBlock = aItemEntity.worldObj.getBlock(tX, tY, tZ); + byte tMetaData = (byte) aItemEntity.worldObj.getBlockMetadata(tX, tY, tZ); + if ((tBlock == Blocks.cauldron) && (tMetaData > 0)) { + aItemEntity.setEntityItemStack( + GT_OreDictUnificator + .get(OrePrefixes.crushedPurified, aMaterial, aItemEntity.getEntityItem().stackSize)); + aItemEntity.worldObj.setBlockMetadataWithNotify(tX, tY, tZ, tMetaData - 1, 3); + return true; + } + } else if (aPrefix == OrePrefixes.dust && aMaterial == Materials.Wheat) { + Block tBlock = aItemEntity.worldObj.getBlock(tX, tY, tZ); + byte tMetaData = (byte) aItemEntity.worldObj.getBlockMetadata(tX, tY, tZ); + if ((tBlock == Blocks.cauldron) && (tMetaData > 0)) { + aItemEntity.setEntityItemStack(ItemList.Food_Dough.get(aItemEntity.getEntityItem().stackSize)); + aItemEntity.worldObj.setBlockMetadataWithNotify(tX, tY, tZ, tMetaData - 1, 3); + return true; + } + } + } + } + return false; + } + + @Override + protected void addAdditionalToolTips(List<String> aList, ItemStack aStack, EntityPlayer aPlayer) { + super.addAdditionalToolTips(aList, aStack, aPlayer); + int aDamage = aStack.getItemDamage(); + if ((aDamage < 32000) && (aDamage >= 0)) { + Materials aMaterial = GregTech_API.sGeneratedMaterials[(aDamage % 1000)]; + if ((aMaterial != null) && (aMaterial != Materials.Empty) && (aMaterial != Materials._NULL)) { + OrePrefixes aPrefix = this.mGeneratedPrefixList[(aDamage / 1000)]; + if ((aPrefix == OrePrefixes.dustImpure) || (aPrefix == OrePrefixes.dustPure)) { + aList.add(this.mToolTipPurify); + } + } + } + } + + public boolean isPlasmaCellUsed(OrePrefixes aPrefix, Materials aMaterial) { + Collection<GT_Recipe> fusionRecipes = RecipeMaps.fusionRecipes.getAllRecipes(); + if (aPrefix == OrePrefixes.cellPlasma && aMaterial.getPlasma(1L) != null) { // Materials has a plasma fluid + for (GT_Recipe recipe : fusionRecipes) { // Loop through fusion recipes + if (recipe.getFluidOutput(0) != null) { // Make sure fluid output can't be null (not sure if possible) + if (recipe.getFluidOutput(0) + .isFluidEqual(aMaterial.getPlasma(1L))) return true; // Fusion recipe + // output matches + // current plasma + // cell fluid + } + } + } + return false; + } + + @Override + public boolean doesShowInCreative(OrePrefixes aPrefix, Materials aMaterial, boolean aDoShowAllItems) { + return (aDoShowAllItems) || (((aPrefix != OrePrefixes.gem) || (!aMaterial.mName.startsWith("Infused"))) + && (aPrefix != OrePrefixes.dustTiny) + && (aPrefix != OrePrefixes.dustSmall) + && (aPrefix != OrePrefixes.dustImpure) + && (aPrefix != OrePrefixes.dustPure) + && (aPrefix != OrePrefixes.crushed) + && (aPrefix != OrePrefixes.crushedPurified) + && (aPrefix != OrePrefixes.crushedCentrifuged) + && (aPrefix != OrePrefixes.ingotHot) + && !(aPrefix == OrePrefixes.cellPlasma && !isPlasmaCellUsed(aPrefix, aMaterial))); + } + + @Override + public ItemStack getContainerItem(ItemStack aStack) { + int aDamage = aStack.getItemDamage(); + if (((aDamage >= 32430) && (aDamage <= 32461)) || (aDamage == 32465 || aDamage == 32466)) { + return ItemList.Spray_Empty.get(1L); + } + if ((aDamage == 32479) || (aDamage == 32476)) { + return new ItemStack(this, 1, aDamage - 2); + } + if (aDamage == 32401) { + return new ItemStack(this, 1, aDamage - 1); + } + return super.getContainerItem(aStack); + } + + @Override + public boolean doesMaterialAllowGeneration(OrePrefixes aPrefix, Materials aMaterial) { + return (super.doesMaterialAllowGeneration(aPrefix, aMaterial)); + } +} diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java new file mode 100644 index 0000000000..875c4e9861 --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java @@ -0,0 +1,2831 @@ +package gregtech.common.items; + +import static gregtech.api.enums.Mods.Forestry; +import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASINGS; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ADVANCED_REDSTONE_RECEIVER; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ADVANCED_REDSTONE_TRANSMITTER; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_WIRELESS_ACTIVITYDETECTOR; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_WIRELESS_FLUID_DETECTOR; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_WIRELESS_ITEM_DETECTOR; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_WIRELESS_MAINTENANCE_DETECTOR; +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.recipe.RecipeMaps.compressorRecipes; +import static gregtech.api.recipe.RecipeMaps.maceratorRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.WILDCARD; + +import net.minecraft.dispenser.IBlockSource; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.enchantment.EnumEnchantmentType; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.projectile.EntityArrow; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.EnumAction; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.potion.Potion; +import net.minecraft.world.World; + +import gregtech.api.GregTech_API; +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.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TC_Aspects; +import gregtech.api.enums.TierEU; +import gregtech.api.items.GT_MetaGenerated_Item_X32; +import gregtech.api.objects.ItemData; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_FoodStat; +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.covers.redstone.GT_Cover_AdvancedRedstoneReceiverExternal; +import gregtech.common.covers.redstone.GT_Cover_AdvancedRedstoneReceiverInternal; +import gregtech.common.covers.redstone.GT_Cover_AdvancedRedstoneTransmitterExternal; +import gregtech.common.covers.redstone.GT_Cover_AdvancedRedstoneTransmitterInternal; +import gregtech.common.covers.redstone.GT_Cover_WirelessDoesWorkDetector; +import gregtech.common.covers.redstone.GT_Cover_WirelessFluidDetector; +import gregtech.common.covers.redstone.GT_Cover_WirelessItemDetector; +import gregtech.common.covers.redstone.GT_Cover_WirelessMaintenanceDetector; +import gregtech.common.items.behaviors.Behaviour_Arrow; +import ic2.api.crops.CropCard; +import ic2.api.crops.Crops; + +public class GT_MetaGenerated_Item_02 extends GT_MetaGenerated_Item_X32 { + + public static GT_MetaGenerated_Item_02 INSTANCE; + private static final String aTextCover = "Usable as Cover"; + + public GT_MetaGenerated_Item_02() { + super( + "metaitem.02", + OrePrefixes.toolHeadSword, + OrePrefixes.toolHeadPickaxe, + OrePrefixes.toolHeadShovel, + OrePrefixes.toolHeadAxe, + OrePrefixes.toolHeadHoe, + OrePrefixes.toolHeadHammer, + OrePrefixes.toolHeadFile, + OrePrefixes.toolHeadSaw, + OrePrefixes.toolHeadDrill, + OrePrefixes.toolHeadChainsaw, + OrePrefixes.toolHeadWrench, + OrePrefixes.toolHeadUniversalSpade, + OrePrefixes.toolHeadSense, + OrePrefixes.toolHeadPlow, + OrePrefixes.toolHeadArrow, + OrePrefixes.toolHeadBuzzSaw, + OrePrefixes.turbineBlade, + null, + OrePrefixes.itemCasing, + OrePrefixes.wireFine, + OrePrefixes.gearGtSmall, + OrePrefixes.rotor, + OrePrefixes.stickLong, + OrePrefixes.springSmall, + OrePrefixes.spring, + OrePrefixes.arrowGtWood, + OrePrefixes.arrowGtPlastic, + OrePrefixes.gemChipped, + OrePrefixes.gemFlawed, + OrePrefixes.gemFlawless, + OrePrefixes.gemExquisite, + OrePrefixes.gearGt); + INSTANCE = this; + + int tLastID = 0; + + ItemList.ThermosCan_Dark_Coffee.set( + addItem( + tLastID = 0, + "Dark Coffee", + "Coffee, dark, without anything else", + new GT_FoodStat( + 2, + 0.2F, + EnumAction.drink, + ItemList.ThermosCan_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.moveSpeed.id, + 400, + 1, + 70, + Potion.digSpeed.id, + 400, + 1, + 70), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.GELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 2L))); + ItemList.ThermosCan_Dark_Cafe_au_lait.set( + addItem( + tLastID = 1, + "Dark Coffee au lait", + "Keeping you awake the whole night", + new GT_FoodStat( + 2, + 0.2F, + EnumAction.drink, + ItemList.ThermosCan_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.moveSpeed.id, + 400, + 2, + 90, + Potion.digSpeed.id, + 400, + 2, + 90), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.GELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 3L))); + ItemList.ThermosCan_Coffee.set( + addItem( + tLastID = 2, + "Coffee", + "Just the regular morning Coffee", + new GT_FoodStat( + 3, + 0.4F, + EnumAction.drink, + ItemList.ThermosCan_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.moveSpeed.id, + 400, + 0, + 50, + Potion.digSpeed.id, + 400, + 0, + 50), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.GELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 1L))); + ItemList.ThermosCan_Cafe_au_lait.set( + addItem( + tLastID = 3, + "Cafe au lait", + "Sweet Coffee", + new GT_FoodStat( + 3, + 0.4F, + EnumAction.drink, + ItemList.ThermosCan_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.moveSpeed.id, + 400, + 1, + 70, + Potion.digSpeed.id, + 400, + 1, + 70), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.GELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 2L))); + ItemList.ThermosCan_Lait_au_cafe.set( + addItem( + tLastID = 4, + "Lait au cafe", + "You want Coffee to your Sugar?", + new GT_FoodStat( + 3, + 0.4F, + EnumAction.drink, + ItemList.ThermosCan_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.moveSpeed.id, + 400, + 2, + 90, + Potion.digSpeed.id, + 400, + 2, + 90), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.GELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MOTUS, 3L))); + ItemList.ThermosCan_Dark_Chocolate_Milk.set( + addItem( + tLastID = 5, + "Dark Chocolate Milk", + "A bit bitter, better add a bit Sugar", + new GT_FoodStat( + 3, + 0.4F, + EnumAction.drink, + ItemList.ThermosCan_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.regeneration.id, + 50, + 1, + 60), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.GELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 1L))); + ItemList.ThermosCan_Chocolate_Milk.set( + addItem( + tLastID = 6, + "Chocolate Milk", + "Sweet Goodness", + new GT_FoodStat( + 3, + 0.4F, + EnumAction.drink, + ItemList.ThermosCan_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.regeneration.id, + 50, + 1, + 90), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.GELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 2L))); + ItemList.ThermosCan_Tea.set( + addItem( + tLastID = 7, + "Tea", + "Keep calm and carry on", + new GT_FoodStat( + 2, + 0.2F, + EnumAction.drink, + ItemList.ThermosCan_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.moveSlowdown.id, + 300, + 0, + 50), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.GELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 2L))); + ItemList.ThermosCan_Sweet_Tea.set( + addItem( + tLastID = 8, + "Sweet Tea", + "How about a Tea Party? In Boston?", + new GT_FoodStat( + 2, + 0.2F, + EnumAction.drink, + ItemList.ThermosCan_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.GELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 2L))); + ItemList.ThermosCan_Ice_Tea.set( + addItem( + tLastID = 9, + "Ice Tea", + "Better than this purple Junk Drink from failed Potions", + new GT_FoodStat( + 2, + 0.2F, + EnumAction.drink, + ItemList.ThermosCan_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.moveSlowdown.id, + 300, + 0, + 50), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.GELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 2L))); + + ItemList.GelledToluene.set(addItem(tLastID = 10, "Gelled Toluene", "Raw Explosive")); + + ItemList.Bottle_Purple_Drink.set( + addItem( + tLastID = 100, + "Purple Drink", + "How about Lemonade. Or some Ice Tea? I got Purple Drink!", + new GT_FoodStat( + 8, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.moveSlowdown.id, + 400, + 1, + 90), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VINCULUM, 1L))); + ItemList.Bottle_Grape_Juice.set( + addItem( + tLastID = 101, + "Grape Juice", + "This has a cleaning effect on your internals.", + new GT_FoodStat( + 4, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.hunger.id, + 400, + 1, + 60), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 1L))); + ItemList.Bottle_Wine.set( + addItem( + tLastID = 102, + "Wine", + "Ordinary", + new GT_FoodStat( + 2, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 400, + 1, + 60, + Potion.heal.id, + 0, + 0, + 60, + Potion.poison.id, + 200, + 1, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 1L))); + ItemList.Bottle_Vinegar.set( + addItem( + tLastID = 103, + "Vinegar", + "Exquisite", + new GT_FoodStat( + 2, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 400, + 1, + 90, + Potion.heal.id, + 0, + 1, + 90, + Potion.poison.id, + 200, + 2, + 10, + Potion.harm.id, + 0, + 2, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 1L))); + ItemList.Bottle_Potato_Juice.set( + addItem( + tLastID = 104, + "Potato Juice", + "Ever seen Potato Juice in stores? No? That has a reason.", + new GT_FoodStat( + 3, + 0.3F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L))); + ItemList.Bottle_Vodka.set( + addItem( + tLastID = 105, + "Vodka", + "Not to confuse with Water", + new GT_FoodStat( + 2, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 500, + 0, + 60, + Potion.damageBoost.id, + 500, + 1, + 60, + Potion.poison.id, + 200, + 1, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L))); + ItemList.Bottle_Leninade.set( + addItem( + tLastID = 106, + "Leninade", + "Let the Communism flow through you!", + new GT_FoodStat( + 2, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 500, + 1, + 90, + Potion.damageBoost.id, + 500, + 2, + 90, + Potion.poison.id, + 200, + 2, + 10, + Potion.harm.id, + 0, + 2, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 2L))); + ItemList.Bottle_Mineral_Water.set( + addItem( + tLastID = 107, + "Mineral Water", + "The best Stuff you can drink to stay healthy", + new GT_FoodStat( + 1, + 0.1F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.regeneration.id, + 100, + 1, + 10), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 1L))); + ItemList.Bottle_Salty_Water.set( + addItem( + tLastID = 108, + "Salty Water", + "Like Sea Water but less dirty", + SubTag.INVISIBLE, + new GT_FoodStat( + 1, + 0.0F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.hunger.id, + 400, + 2, + 95), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TEMPESTAS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Bottle_Reed_Water.set( + addItem( + tLastID = 109, + "Reed Water", + "I guess this tastes better when fermented", + new GT_FoodStat( + 1, + 0.1F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L))); + ItemList.Bottle_Rum.set( + addItem( + tLastID = 110, + "Rum", + "A buddle o' rum", + new GT_FoodStat( + 4, + 0.4F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 300, + 0, + 60, + Potion.damageBoost.id, + 300, + 1, + 60, + Potion.poison.id, + 200, + 1, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 1L))); + ItemList.Bottle_Pirate_Brew.set( + addItem( + tLastID = 111, + "Pirate Brew", + "Set the Sails, we are going to Torrentuga!", + new GT_FoodStat( + 4, + 0.4F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 300, + 1, + 90, + Potion.damageBoost.id, + 300, + 2, + 90, + Potion.poison.id, + 200, + 2, + 10, + Potion.harm.id, + 0, + 2, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 2L))); + ItemList.Bottle_Hops_Juice.set( + addItem( + tLastID = 112, + "Hops Juice", + "Every Beer has a start", + new GT_FoodStat( + 1, + 0.1F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L))); + ItemList.Bottle_Dark_Beer.set( + addItem( + tLastID = 113, + "Dark Beer", + "Dark Beer, for the real Men", + new GT_FoodStat( + 4, + 0.4F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 300, + 1, + 60, + Potion.damageBoost.id, + 300, + 1, + 60, + Potion.poison.id, + 200, + 1, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L))); + ItemList.Bottle_Dragon_Blood.set( + addItem( + tLastID = 114, + "Dragon Blood", + "FUS RO DAH!", + new GT_FoodStat( + 4, + 0.4F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 300, + 2, + 90, + Potion.damageBoost.id, + 300, + 2, + 90, + Potion.poison.id, + 200, + 2, + 10, + Potion.harm.id, + 0, + 2, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 2L))); + ItemList.Bottle_Wheaty_Juice.set( + addItem( + tLastID = 115, + "Wheaty Juice", + "Is this liquefied Bread or what?", + new GT_FoodStat( + 2, + 0.1F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L))); + ItemList.Bottle_Scotch.set( + addItem( + tLastID = 116, + "Scotch", + "Technically this is just a Whisky", + new GT_FoodStat( + 2, + 0.1F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 400, + 0, + 60, + Potion.resistance.id, + 400, + 1, + 60, + Potion.poison.id, + 200, + 1, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 1L))); + ItemList.Bottle_Glen_McKenner.set( + addItem( + tLastID = 117, + "Glen McKenner", + "Don't hand to easily surprised people, they will shatter it.", + new GT_FoodStat( + 2, + 0.1F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 400, + 1, + 90, + Potion.resistance.id, + 400, + 2, + 90, + Potion.poison.id, + 200, + 2, + 10, + Potion.harm.id, + 0, + 2, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 2L))); + ItemList.Bottle_Wheaty_Hops_Juice.set( + addItem( + tLastID = 118, + "Wheaty Hops Juice", + "Also known as 'Duff-Lite'", + new GT_FoodStat( + 1, + 0.1F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 2L))); + ItemList.Bottle_Beer.set( + addItem( + tLastID = 119, + "Beer", + "Good old Beer", + new GT_FoodStat( + 6, + 0.4F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 400, + 0, + 60, + Potion.digSpeed.id, + 400, + 2, + 60, + Potion.poison.id, + 100, + 0, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERFODIO, 1L))); + ItemList.Bottle_Chilly_Sauce.set( + addItem( + tLastID = 120, + "Chilly Sauce", + "Spicy", + new GT_FoodStat( + 2, + 0.1F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 1000, + 0, + 10, + Potion.fireResistance.id, + 1000, + 0, + 60), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Bottle_Hot_Sauce.set( + addItem( + tLastID = 121, + "Hot Sauce", + "Very Spicy, I guess?", + new GT_FoodStat( + 2, + 0.1F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 2000, + 0, + 30, + Potion.fireResistance.id, + 2000, + 0, + 70), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 2L))); + ItemList.Bottle_Diabolo_Sauce.set( + addItem( + tLastID = 122, + "Diabolo Sauce", + "As if the Devil made this Sauce", + new GT_FoodStat( + 2, + 0.1F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 3000, + 1, + 50, + Potion.fireResistance.id, + 3000, + 0, + 80), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 3L))); + ItemList.Bottle_Diablo_Sauce.set( + addItem( + tLastID = 123, + "Diablo Sauce", + "Diablo always comes back!", + new GT_FoodStat( + 2, + 0.1F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 4000, + 1, + 70, + Potion.fireResistance.id, + 4000, + 0, + 90), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 4L))); + ItemList.Bottle_Snitches_Glitch_Sauce.set( + addItem( + tLastID = 124, + "Old Man Snitches glitched Diablo Sauce", + "[Missing No]", + SubTag.INVISIBLE, + new GT_FoodStat( + 2, + 0.1F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 9999, + 2, + 999, + Potion.fireResistance.id, + 9999, + 9, + 999), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 3L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 5L))); + ItemList.Bottle_Apple_Juice.set( + addItem( + tLastID = 125, + "Apple Juice", + "Made of the Apples from our best Oak Farms", + new GT_FoodStat( + 4, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.hunger.id, + 400, + 0, + 20), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L))); + ItemList.Bottle_Cider.set( + addItem( + tLastID = 126, + "Cider", + "If you have nothing better to do with your Apples", + new GT_FoodStat( + 4, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 400, + 0, + 60, + Potion.resistance.id, + 400, + 1, + 60, + Potion.poison.id, + 200, + 1, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 1L))); + ItemList.Bottle_Golden_Apple_Juice.set( + addItem( + tLastID = 127, + "Golden Apple Juice", + "A golden Apple in liquid form", + new GT_FoodStat( + 4, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.hunger.id, + 400, + 0, + 20, + Potion.field_76444_x.id, + 2400, + 0, + 100, + Potion.regeneration.id, + 100, + 1, + 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 1L))); + ItemList.Bottle_Golden_Cider.set( + addItem( + tLastID = 128, + "Golden Cider", + "More Resistance, less Regeneration", + new GT_FoodStat( + 4, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.confusion.id, + 400, + 0, + 60, + Potion.field_76444_x.id, + 2400, + 1, + 95, + Potion.poison.id, + 200, + 1, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 1L))); + ItemList.Bottle_Iduns_Apple_Juice.set( + addItem( + tLastID = 129, + "Idun's Apple Juice", + "So you got the Idea of using Notch Apples for a drink?", + new GT_FoodStat( + 4, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.regeneration.id, + 600, + 4, + 100, + Potion.field_76444_x.id, + 2400, + 0, + 100, + Potion.resistance.id, + 6000, + 0, + 100, + Potion.fireResistance.id, + 6000, + 0, + 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.NEBRISUM, 9L))); + ItemList.Bottle_Notches_Brew.set( + addItem( + tLastID = 130, + "Notches Brew", + "This is just overpowered", + new GT_FoodStat( + 4, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.regeneration.id, + 700, + 4, + 95, + Potion.field_76444_x.id, + 3000, + 1, + 95, + Potion.resistance.id, + 7000, + 1, + 95, + Potion.fireResistance.id, + 7000, + 0, + 95, + Potion.harm.id, + 0, + 2, + 20), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.NEBRISUM, 9L))); + ItemList.Bottle_Lemon_Juice.set( + addItem( + tLastID = 131, + "Lemon Juice", + "Maybe adding Sugar will make it less sour", + new GT_FoodStat( + 2, + 0.4F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.digSpeed.id, + 1200, + 0, + 60), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERFODIO, 1L))); + ItemList.Bottle_Limoncello.set( + addItem( + tLastID = 132, + "Limoncello", + "An alcoholic Drink which tastes like Lemons", + new GT_FoodStat( + 2, + 0.4F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.digSpeed.id, + 1200, + 0, + 90, + Potion.poison.id, + 200, + 1, + 5), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERFODIO, 1L))); + ItemList.Bottle_Lemonade.set( + addItem( + tLastID = 133, + "Lemonade", + "Cold and refreshing Lemonade", + new GT_FoodStat( + 4, + 0.3F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.digSpeed.id, + 900, + 1, + 90), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERFODIO, 1L))); + ItemList.Bottle_Alcopops.set( + addItem( + tLastID = 134, + "Alcopops", + "Don't let your Children drink this junk!", + new GT_FoodStat( + 2, + 0.2F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.digSpeed.id, + 900, + 1, + 90, + Potion.poison.id, + 300, + 2, + 20), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VENENUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VINCULUM, 1L))); + ItemList.Bottle_Cave_Johnsons_Grenade_Juice.set( + addItem( + tLastID = 135, + "Cave Johnson's Grenade Juice", + "When life gives you Lemons, make Life take them Lemons back!", + new GT_FoodStat( + 0, + 0.0F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false).setExplosive(), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MORTUUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERDITIO, 1L))); + ItemList.Bottle_Milk.set( + addItem( + tLastID = 136, + "Milk", + "Got Milk?", + OrePrefixes.bottle.get(Materials.Milk), + new GT_FoodStat( + 0, + 0.0F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false).setMilk(), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 1L))); + ItemList.Bottle_Holy_Water.set( + addItem( + tLastID = 137, + "Holy Water", + "May the holy Planks be with you", + OrePrefixes.bottle.get(Materials.HolyWater), + new GT_FoodStat( + 0, + 0.0F, + EnumAction.drink, + ItemList.Bottle_Empty.get(1L), + GregTech_API.sDrinksAlwaysDrinkable, + false, + false, + Potion.poison.id, + 100, + 1, + 100).setMilk(), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AURAM, 1L))); + + ItemList.Food_Potato_On_Stick.set( + addItem( + tLastID = 200, + "Potato on a Stick", + "Totally looks like a Crab Claw", + new GT_FoodStat(1, 0.3F, EnumAction.eat, new ItemStack(Items.stick, 1), false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + ItemList.Food_Potato_On_Stick_Roasted.set( + addItem( + tLastID = 201, + "Roasted Potato on a Stick", + "Still looks like a Crab Claw", + new GT_FoodStat(6, 0.6F, EnumAction.eat, new ItemStack(Items.stick, 1), false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Raw_Fries.set( + addItem( + tLastID = 202, + "Potato Strips", + "It's Potato in Stripe Form", + new GT_FoodStat(1, 0.3F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 16L); + ItemList.Food_Fries.set( + addItem( + tLastID = 203, + "Fries", + "Not to confuse with Fry the Delivery Boy", + new GT_FoodStat(7, 0.5F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 16L); + ItemList.Food_Packaged_Fries.set( + addItem( + tLastID = 204, + "Fries", + "Ketchup not included", + new GT_FoodStat( + 7, + 0.5F, + EnumAction.eat, + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Paper, 1L), + false, + true, + false), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Raw_PotatoChips.set( + addItem( + tLastID = 205, + "Potato Chips (Raw)", + "Just like a Potato", + new GT_FoodStat(1, 0.3F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 16L); + ItemList.Food_PotatoChips.set( + addItem( + tLastID = 206, + "Potato Chips", + "Crunchy", + new GT_FoodStat(7, 0.5F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 16L); + ItemList.Food_ChiliChips.set( + addItem( + tLastID = 207, + "Chili Chips", + "Spicy", + new GT_FoodStat(7, 0.6F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 16L); + ItemList.Food_Packaged_PotatoChips.set( + addItem( + tLastID = 208, + "Bag of Potato Chips", + "Full of delicious Air", + new GT_FoodStat( + 7, + 0.5F, + EnumAction.eat, + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Aluminium, 1L), + false, + true, + false), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Packaged_ChiliChips.set( + addItem( + tLastID = 209, + "Bag of Chili Chips", + "Stop making noises Baj!", + new GT_FoodStat( + 7, + 0.6F, + EnumAction.eat, + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Aluminium, 1L), + false, + true, + false), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Chum.set( + addItem( + tLastID = 210, + "Chum", + "Chum is Fum!", + new GT_FoodStat( + 5, + 0.2F, + EnumAction.eat, + null, + true, + false, + true, + Potion.hunger.id, + 1000, + 4, + 100, + Potion.confusion.id, + 300, + 1, + 80), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Chum_On_Stick.set( + addItem( + tLastID = 211, + "Chum on a Stick", + "Don't forget to try our Chum-balaya", + new GT_FoodStat( + 5, + 0.2F, + EnumAction.eat, + new ItemStack(Items.stick, 1), + true, + false, + true, + Potion.hunger.id, + 1000, + 4, + 100, + Potion.confusion.id, + 300, + 1, + 80), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Dough_Sugar.set( + addItem( + tLastID = 212, + "Sugary Dough", + "Don't eat the Dough before it is baken", + new GT_FoodStat(1, 0.1F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Food_Dough_Chocolate.set( + addItem( + tLastID = 213, + "Chocolate Dough", + "I said don't eat the Dough!", + new GT_FoodStat(1, 0.1F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Food_Raw_Cookie.set( + addItem( + tLastID = 214, + "Cookie shaped Dough", + "For baking Cookies", + new GT_FoodStat(1, 0.1F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + + ItemList.Food_Sliced_Buns.set( + addItem( + tLastID = 220, + "Buns", + "Pre Sliced", + new GT_FoodStat(3, 0.5F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Burger_Veggie.set( + addItem( + tLastID = 221, + "Veggieburger", + "No matter how you call this, this is NOT a Burger!", + new GT_FoodStat(3, 0.5F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Burger_Cheese.set( + addItem( + tLastID = 222, + "Cheeseburger", + "Cheesy!", + new GT_FoodStat(3, 0.5F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new ItemData(Materials.Cheese, 907200L))); + ItemList.Food_Burger_Meat.set( + addItem( + tLastID = 223, + "Hamburger", + "The Mc Burger Queen Burger", + new GT_FoodStat(3, 0.5F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.CORPUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Burger_Chum.set( + addItem( + tLastID = 224, + "Chumburger", + "Fum is Chum!", + new GT_FoodStat( + 5, + 0.2F, + EnumAction.eat, + null, + true, + false, + true, + Potion.hunger.id, + 1000, + 4, + 100, + Potion.confusion.id, + 300, + 1, + 80), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + + ItemList.Food_Sliced_Breads.set( + addItem( + tLastID = 230, + "Breads", + "Pre Sliced", + new GT_FoodStat(5, 0.6F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Sandwich_Veggie.set( + addItem( + tLastID = 231, + "Veggie Sandwich", + "Meatless", + new GT_FoodStat(7, 0.6F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 32L); + ItemList.Food_Sandwich_Cheese.set( + addItem( + tLastID = 232, + "Cheese Sandwich", + "Say Cheese!", + new GT_FoodStat(7, 0.6F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 32L); + ItemList.Food_Sandwich_Bacon.set( + addItem( + tLastID = 233, + "Bacon Sandwich", + "The best Sandwich ever!", + new GT_FoodStat(10, 0.8F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.CORPUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 32L); + ItemList.Food_Sandwich_Steak.set( + addItem( + tLastID = 234, + "Steak Sandwich", + "Not a 'Steam Sandwich'", + new GT_FoodStat(10, 0.8F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.CORPUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 32L); + + ItemList.Food_Sliced_Baguettes.set( + addItem( + tLastID = 240, + "Baguettes", + "Pre Sliced", + new GT_FoodStat(8, 0.5F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Large_Sandwich_Veggie.set( + addItem( + tLastID = 241, + "Large Veggie Sandwich", + "Just not worth it", + new GT_FoodStat(15, 0.8F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 3L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 16L); + ItemList.Food_Large_Sandwich_Cheese.set( + addItem( + tLastID = 242, + "Large Cheese Sandwich", + "I need another cheesy tooltip for this", + new GT_FoodStat(15, 0.8F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 3L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 16L); + ItemList.Food_Large_Sandwich_Bacon.set( + addItem( + tLastID = 243, + "Large Bacon Sandwich", + "For Men! (and manly Women)", + new GT_FoodStat(20, 1.0F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.CORPUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 16L); + ItemList.Food_Large_Sandwich_Steak.set( + addItem( + tLastID = 244, + "Large Steak Sandwich", + "Yes, I once accidentially called it 'Steam Sandwich'", + new GT_FoodStat(20, 1.0F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.CORPUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + setFluidContainerStats(32000 + tLastID, 0L, 16L); + + ItemList.Food_Raw_Pizza_Veggie.set( + addItem( + tLastID = 250, + "Raw Veggie Pizza", + "Into the Oven with it!", + new GT_FoodStat(1, 0.2F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Raw_Pizza_Cheese.set( + addItem( + tLastID = 251, + "Raw Cheese Pizza", + "Into the Oven with it!", + new GT_FoodStat(2, 0.2F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Raw_Pizza_Meat.set( + addItem( + tLastID = 252, + "Raw Mince Meat Pizza", + "Into the Oven with it!", + new GT_FoodStat(2, 0.2F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.CORPUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + + ItemList.Food_Baked_Pizza_Veggie.set( + addItem( + tLastID = 260, + "Veggie Pizza", + "The next they want is Gluten Free Pizzas...", + new GT_FoodStat(3, 0.3F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Baked_Pizza_Cheese.set( + addItem( + tLastID = 261, + "Cheese Pizza", + "Pizza Magarita", + new GT_FoodStat(4, 0.4F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Baked_Pizza_Meat.set( + addItem( + tLastID = 262, + "Mince Meat Pizza", + "Emo Pizza, it cuts itself!", + new GT_FoodStat(5, 0.5F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.CORPUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + + ItemList.Dye_Indigo.set( + addItem( + tLastID = 410, + "Indigo Dye", + "Blue Dye", + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 1L), + Dyes.dyeBlue)); + for (byte i = 0; i < 16; i = (byte) (i + 1)) { + ItemList.DYE_ONLY_ITEMS[i].set( + addItem( + tLastID = 414 + i, + Dyes.get(i).mName + " Dye", + "", + Dyes.get(i) + .name(), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 1L))); + } + ItemList.Plank_Oak + .set(addItem(tLastID = 470, "Oak Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Spruce.set( + addItem(tLastID = 471, "Spruce Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Birch.set( + addItem(tLastID = 472, "Birch Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Jungle.set( + addItem(tLastID = 473, "Jungle Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Acacia.set( + addItem(tLastID = 474, "Acacia Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_DarkOak.set( + addItem(tLastID = 475, "Dark Oak Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Larch.set( + addItem(tLastID = 476, "Larch Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Teak + .set(addItem(tLastID = 477, "Teak Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Acacia_Green.set( + addItem( + tLastID = 478, + "Green Acacia Plank", + aTextCover, + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Lime + .set(addItem(tLastID = 479, "Lime Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Chestnut.set( + addItem(tLastID = 480, "Chestnut Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Wenge.set( + addItem(tLastID = 481, "Wenge Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Baobab.set( + addItem(tLastID = 482, "Baobab Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Sequoia.set( + addItem(tLastID = 483, "Sequoia Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Kapok.set( + addItem(tLastID = 484, "Kapok Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Ebony.set( + addItem(tLastID = 485, "Ebony Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Mahagony.set( + addItem(tLastID = 486, "Mahagony Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Balsa.set( + addItem(tLastID = 487, "Balsa Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Willow.set( + addItem(tLastID = 488, "Willow Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Walnut.set( + addItem(tLastID = 489, "Walnut Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Greenheart.set( + addItem( + tLastID = 490, + "Greenheart Plank", + aTextCover, + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Cherry.set( + addItem(tLastID = 491, "Cherry Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Mahoe.set( + addItem(tLastID = 492, "Mahoe Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Poplar.set( + addItem(tLastID = 493, "Poplar Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Palm + .set(addItem(tLastID = 494, "Palm Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Papaya.set( + addItem(tLastID = 495, "Papaya Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Pine + .set(addItem(tLastID = 496, "Pine Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Plum + .set(addItem(tLastID = 497, "Plum Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Maple.set( + addItem(tLastID = 498, "Maple Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + ItemList.Plank_Citrus.set( + addItem(tLastID = 499, "Citrus Plank", aTextCover, new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 75); + + ItemList.SFMixture.set(addItem(tLastID = 270, "Super Fuel Binder", "Raw Material")); + ItemList.MSFMixture.set(addItem(tLastID = 271, "Magic Super Fuel Binder", "Raw Material")); + + GT_ModHandler.addCraftingRecipe( + ItemList.Plank_Oak.get(2L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "s ", " P", 'P', new ItemStack(Blocks.wooden_slab, 1, 0) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Plank_Spruce.get(2L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "s ", " P", 'P', new ItemStack(Blocks.wooden_slab, 1, 1) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Plank_Birch.get(2L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "s ", " P", 'P', new ItemStack(Blocks.wooden_slab, 1, 2) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Plank_Jungle.get(2L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "s ", " P", 'P', new ItemStack(Blocks.wooden_slab, 1, 3) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Plank_Acacia.get(2L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "s ", " P", 'P', new ItemStack(Blocks.wooden_slab, 1, 4) }); + GT_ModHandler.addCraftingRecipe( + ItemList.Plank_DarkOak.get(2L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE | GT_ModHandler.RecipeBits.REVERSIBLE, + new Object[] { "s ", " P", 'P', new ItemStack(Blocks.wooden_slab, 1, 5) }); + + GregTech_API.registerCover(ItemList.Plank_Oak.get(1L), TextureFactory.of(Blocks.planks, 0), null); + GregTech_API.registerCover(ItemList.Plank_Spruce.get(1L), TextureFactory.of(Blocks.planks, 1), null); + GregTech_API.registerCover(ItemList.Plank_Birch.get(1L), TextureFactory.of(Blocks.planks, 2), null); + GregTech_API.registerCover(ItemList.Plank_Jungle.get(1L), TextureFactory.of(Blocks.planks, 3), null); + GregTech_API.registerCover(ItemList.Plank_Acacia.get(1L), TextureFactory.of(Blocks.planks, 4), null); + GregTech_API.registerCover(ItemList.Plank_DarkOak.get(1L), TextureFactory.of(Blocks.planks, 5), null); + GregTech_API.registerCover( + ItemList.Plank_Larch.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 0, new ItemStack(Blocks.planks, 1, 0))), + 0), + null); + GregTech_API.registerCover( + ItemList.Plank_Teak.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 1, new ItemStack(Blocks.planks, 1, 0))), + 1), + null); + GregTech_API.registerCover( + ItemList.Plank_Acacia_Green.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 2, new ItemStack(Blocks.planks, 1, 0))), + 2), + null); + GregTech_API.registerCover( + ItemList.Plank_Lime.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 3, new ItemStack(Blocks.planks, 1, 0))), + 3), + null); + GregTech_API.registerCover( + ItemList.Plank_Chestnut.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 4, new ItemStack(Blocks.planks, 1, 0))), + 4), + null); + GregTech_API.registerCover( + ItemList.Plank_Wenge.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 5, new ItemStack(Blocks.planks, 1, 0))), + 5), + null); + GregTech_API.registerCover( + ItemList.Plank_Baobab.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 6, new ItemStack(Blocks.planks, 1, 0))), + 6), + null); + GregTech_API.registerCover( + ItemList.Plank_Sequoia.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 7, new ItemStack(Blocks.planks, 1, 0))), + 7), + null); + GregTech_API.registerCover( + ItemList.Plank_Kapok.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 8, new ItemStack(Blocks.planks, 1, 0))), + 8), + null); + GregTech_API.registerCover( + ItemList.Plank_Ebony.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 9, new ItemStack(Blocks.planks, 1, 0))), + 9), + null); + GregTech_API.registerCover( + ItemList.Plank_Mahagony.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 10, new ItemStack(Blocks.planks, 1, 0))), + 10), + null); + GregTech_API.registerCover( + ItemList.Plank_Balsa.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 11, new ItemStack(Blocks.planks, 1, 0))), + 11), + null); + GregTech_API.registerCover( + ItemList.Plank_Willow.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 12, new ItemStack(Blocks.planks, 1, 0))), + 12), + null); + GregTech_API.registerCover( + ItemList.Plank_Walnut.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 13, new ItemStack(Blocks.planks, 1, 0))), + 13), + null); + GregTech_API.registerCover( + ItemList.Plank_Greenheart.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 14, new ItemStack(Blocks.planks, 1, 0))), + 14), + null); + GregTech_API.registerCover( + ItemList.Plank_Cherry.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 15, new ItemStack(Blocks.planks, 1, 0))), + 15), + null); + GregTech_API.registerCover( + ItemList.Plank_Mahoe.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 16, new ItemStack(Blocks.planks, 1, 0))), + 0), + null); + GregTech_API.registerCover( + ItemList.Plank_Poplar.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 17, new ItemStack(Blocks.planks, 1, 0))), + 1), + null); + GregTech_API.registerCover( + ItemList.Plank_Palm.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 18, new ItemStack(Blocks.planks, 1, 0))), + 2), + null); + GregTech_API.registerCover( + ItemList.Plank_Papaya.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 19, new ItemStack(Blocks.planks, 1, 0))), + 3), + null); + GregTech_API.registerCover( + ItemList.Plank_Pine.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 20, new ItemStack(Blocks.planks, 1, 0))), + 4), + null); + GregTech_API.registerCover( + ItemList.Plank_Plum.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 21, new ItemStack(Blocks.planks, 1, 0))), + 5), + null); + GregTech_API.registerCover( + ItemList.Plank_Maple.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 22, new ItemStack(Blocks.planks, 1, 0))), + 6), + null); + GregTech_API.registerCover( + ItemList.Plank_Citrus.get(1L), + TextureFactory.of( + GT_Utility.getBlockFromStack( + GT_ModHandler.getModItem(Forestry.ID, "planks", 1L, 23, new ItemStack(Blocks.planks, 1, 0))), + 7), + null); + + ItemList.Crop_Drop_Plumbilia.set( + addItem( + tLastID = 500, + "Plumbilia Leaf", + "Source of Lead", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 1L))); + ItemList.Crop_Drop_Argentia.set( + addItem( + tLastID = 501, + "Argentia Leaf", + "Source of Silver", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 1L))); + ItemList.Crop_Drop_Indigo.set( + addItem( + tLastID = 502, + "Indigo Blossom", + "Used for making Blue Dye", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 1L))); + ItemList.Crop_Drop_Ferru.set( + addItem( + tLastID = 503, + "Ferru Leaf", + "Source of Iron", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 2L))); + ItemList.Crop_Drop_Aurelia.set( + addItem( + tLastID = 504, + "Aurelia Leaf", + "Source of Gold", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 1L))); + ItemList.Crop_Drop_TeaLeaf.set( + addItem( + tLastID = 505, + "Tea Leaf", + "Source of Tea", + "cropTea", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 1L))); + + ItemList.Crop_Drop_OilBerry.set( + addItem( + tLastID = 510, + "Oil Berry", + "Oil in Berry form", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L))); + ItemList.Crop_Drop_BobsYerUncleRanks.set( + addItem( + tLastID = 511, + "Bobs-Yer-Uncle-Berry", + "Source of Emeralds", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VITREUS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 1L))); + ItemList.Crop_Drop_UUMBerry.set( + addItem( + tLastID = 512, + "UUM Berry", + "UUM in Berry form", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L))); + ItemList.Crop_Drop_UUABerry.set( + addItem( + tLastID = 513, + "UUA Berry", + "UUA in Berry form", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L))); + + ItemList.Crop_Drop_MilkWart.set( + addItem( + tLastID = 520, + "Milk Wart", + "Source of Milk", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 1L))); + + ItemList.Crop_Drop_Coppon.set( + addItem( + tLastID = 530, + "Coppon Fiber", + "ORANGE WOOOOOOOL!!!", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERMUTATIO, 1L))); + + ItemList.Crop_Drop_Tine.set( + addItem( + tLastID = 540, + "Tine Twig", + "Source of Tin", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METALLUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 100); + + ItemList.Crop_Drop_Mica.set( + addItem( + tLastID = 538, + "Micadia Twig", + "Source of Mica", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TUTAMEN, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 1L))); + setBurnValue(32000 + tLastID, 240); + + ItemList.Crop_Drop_Bauxite.set(addItem(tLastID = 521, "Bauxia Leaf", "Source of Aluminium")); + ItemList.Crop_Drop_Ilmenite.set(addItem(tLastID = 522, "Titania Leaf", "Source of Titanium")); + ItemList.Crop_Drop_Pitchblende.set(addItem(tLastID = 523, "Reactoria Leaf", "Source of Uranium")); + ItemList.Crop_Drop_Uraninite.set(addItem(tLastID = 524, "Uranium Leaf", "Source of Uranite")); + ItemList.Crop_Drop_Thorium.set(addItem(tLastID = 526, "Thunder Leaf", "Source of Thorium")); + ItemList.Crop_Drop_Nickel.set(addItem(tLastID = 527, "Nickelback Leaf", "Source of Nickel")); + ItemList.Crop_Drop_Zinc.set(addItem(tLastID = 528, "Galvania Leaf", "Source of Zinc")); + ItemList.Crop_Drop_Manganese.set(addItem(tLastID = 529, "Pyrolusium Leaf", "Source of Manganese")); + ItemList.Crop_Drop_Scheelite.set(addItem(tLastID = 531, "Scheelinium Leaf", "Source of Tungsten")); + ItemList.Crop_Drop_Platinum.set(addItem(tLastID = 532, "Platina Leaf", "Source of Platinum")); + ItemList.Crop_Drop_Iridium.set(addItem(tLastID = 533, "Quantaria Leaf", "Source of Iridium")); + ItemList.Crop_Drop_Osmium.set(addItem(tLastID = 534, "Quantaria Leaf", "Source of Osmium")); + ItemList.Crop_Drop_Naquadah.set(addItem(tLastID = 535, "Stargatium Leaf", "Source of Naquadah")); + + ItemList.Crop_Drop_Chilly.set( + addItem( + tLastID = 550, + "Chilly Pepper", + "It is red and hot", + "cropChilipepper", + new GT_FoodStat(1, 0.3F, EnumAction.eat, null, false, true, false, Potion.confusion.id, 200, 1, 40), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Crop_Drop_Lemon.set( + addItem( + tLastID = 551, + "Lemon", + "Don't make Lemonade", + "cropLemon", + new GT_FoodStat(1, 0.3F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Crop_Drop_Tomato.set( + addItem( + tLastID = 552, + "Tomato", + "Solid Ketchup", + "cropTomato", + new GT_FoodStat(1, 0.2F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Crop_Drop_MTomato.set( + addItem( + tLastID = 553, + "Max Tomato", + "Full Health in one Tomato", + "cropTomato", + new GT_FoodStat( + 9, + 1.0F, + EnumAction.eat, + null, + false, + true, + false, + Potion.regeneration.id, + 100, + 100, + 100), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SANO, 3L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Crop_Drop_Grapes.set( + addItem( + tLastID = 554, + "Grapes", + "Source of Wine", + "cropGrape", + new GT_FoodStat(2, 0.3F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Crop_Drop_Onion.set( + addItem( + tLastID = 555, + "Onion", + "Taking over the whole Taste", + "cropOnion", + new GT_FoodStat(2, 0.2F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Crop_Drop_Cucumber.set( + addItem( + tLastID = 556, + "Cucumber", + "Not a Sea Cucumber!", + "cropCucumber", + new GT_FoodStat(1, 0.2F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Crop_Drop_Rape.set( + addItem( + tLastID = 557, + "Rape", + "Time to oil up!", + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 1L))); + + ItemList.Food_Cheese.set( + addItem( + tLastID = 558, + "Cheese", + "Click the Cheese", + "foodCheese", + new GT_FoodStat(3, 0.6F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 2L))); + ItemList.Food_Dough.set( + addItem( + tLastID = 559, + "Dough", + "For making Breads", + "foodDough", + new GT_FoodStat(1, 0.1F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Food_Flat_Dough.set( + addItem( + tLastID = 560, + "Flattened Dough", + "For making Pizza", + new GT_FoodStat(1, 0.1F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Food_Raw_Bread.set( + addItem( + tLastID = 561, + "Dough", + "In Bread Shape", + new GT_FoodStat(1, 0.2F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Food_Raw_Bun.set( + addItem( + tLastID = 562, + "Dough", + "In Bun Shape", + new GT_FoodStat(1, 0.1F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Food_Raw_Baguette.set( + addItem( + tLastID = 563, + "Dough", + "In Baguette Shape", + new GT_FoodStat(1, 0.3F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Food_Baked_Bun.set( + addItem( + tLastID = 564, + "Bun", + "Do not teleport Bread!", + new GT_FoodStat(3, 0.5F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Baked_Baguette.set( + addItem( + tLastID = 565, + "Baguette", + "I teleported nothing BUT Bread!!!", + new GT_FoodStat(8, 0.5F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Sliced_Bread.set( + addItem( + tLastID = 566, + "Sliced Bread", + "Just half a Bread", + new GT_FoodStat(2, 0.3F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Sliced_Bun.set( + addItem( + tLastID = 567, + "Sliced Bun", + "Just half a Bun", + new GT_FoodStat(1, 0.3F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Sliced_Baguette.set( + addItem( + tLastID = 568, + "Sliced Baguette", + "Just half a Baguette", + new GT_FoodStat(4, 0.3F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.IGNIS, 1L))); + ItemList.Food_Raw_Cake.set( + addItem( + tLastID = 569, + "Cake Bottom", + "For making Cake", + new GT_FoodStat(2, 0.2F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Food_Baked_Cake.set( + addItem( + tLastID = 570, + "Baked Cake Bottom", + "I know I promised you an actual Cake, but well...", + new GT_FoodStat(3, 0.3F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + ItemList.Food_Sliced_Lemon.set( + addItem( + tLastID = 571, + "Lemon Slice", + "Ideal to put on your Drink", + new GT_FoodStat(1, 0.075F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L))); + ItemList.Food_Sliced_Tomato.set( + addItem( + tLastID = 572, + "Tomato Slice", + "Solid Ketchup", + new GT_FoodStat(1, 0.05F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L))); + ItemList.Food_Sliced_Onion.set( + addItem( + tLastID = 573, + "Onion Slice", + "ONIONS, UNITE!", + new GT_FoodStat(1, 0.05F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L))); + ItemList.Food_Sliced_Cucumber.set( + addItem( + tLastID = 574, + "Cucumber Slice", + "QUEWWW-CUMMM-BERRR!!!", + new GT_FoodStat(1, 0.05F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 1L))); + + ItemList.Food_Sliced_Cheese.set( + addItem( + tLastID = 576, + "Cheese Slice", + "ALIEN ATTACK!!!, throw the CHEEEEESE!!!", + new GT_FoodStat(1, 0.1F, EnumAction.eat, null, false, true, false), + new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + + ItemList.Cover_AdvancedRedstoneTransmitterExternal.set( + addItem( + tLastID = 577, + "Advanced Redstone Transmitter (External)", + "Transfers Redstone signals wirelessly/n Can only connect with advanced wireless covers", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L))); + ItemList.Cover_AdvancedRedstoneTransmitterInternal.set( + addItem( + tLastID = 578, + "Advanced Redstone Transmitter (Internal)", + "Transfers Redstone signals wirelessly/n Can only connect with advanced wireless covers", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L))); + ItemList.Cover_AdvancedRedstoneReceiverExternal.set( + addItem( + tLastID = 579, + "Advanced Redstone Receiver (External)", + "Transfers Redstone signals wirelessly/n Can only connect with advanced wireless covers", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L))); + ItemList.Cover_AdvancedRedstoneReceiverInternal.set( + addItem( + tLastID = 580, + "Advanced Redstone Receiver (Internal)", + "Transfers Redstone signals wirelessly/n Can only connect with advanced wireless covers", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L))); + + ItemList.Cover_WirelessFluidDetector.set( + addItem( + tLastID = 581, + "Wireless Fluid Detector Cover", + "Transfers Fluid Amount as Redstone wirelessly/n Can only connect with advanced wireless covers", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.AQUA, 1L))); + ItemList.Cover_WirelessItemDetector.set( + addItem( + tLastID = 582, + "Wireless Item Detector Cover", + "Transfers Item Amount as Redstone wirelessly/n Can only connect with advanced wireless covers", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TERRA, 1L))); + + ItemList.Cover_WirelessNeedsMaintainance.set( + addItem( + tLastID = 583, + "Wireless Needs Maintenance Cover", + "Transfers Maintenance Issues as Redstone wirelessly/n Can only connect with advanced wireless covers", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 3L))); + + ItemList.Cover_WirelessActivityDetector.set( + addItem( + tLastID = 584, + "Wireless Activity Detector Cover", + "Transfers Activity as Redstone wirelessly/n Can only connect with advanced wireless covers", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.SENSUS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TERRA, 1L))); + + GregTech_API.registerCover( + ItemList.Cover_AdvancedRedstoneTransmitterExternal.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_TRANSMITTER)), + new GT_Cover_AdvancedRedstoneTransmitterExternal(TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_TRANSMITTER))); + + GregTech_API.registerCover( + ItemList.Cover_AdvancedRedstoneTransmitterInternal.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_TRANSMITTER)), + new GT_Cover_AdvancedRedstoneTransmitterInternal(TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_TRANSMITTER))); + + GregTech_API.registerCover( + ItemList.Cover_AdvancedRedstoneReceiverExternal.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_RECEIVER)), + new GT_Cover_AdvancedRedstoneReceiverExternal(TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_RECEIVER))); + + GregTech_API.registerCover( + ItemList.Cover_AdvancedRedstoneReceiverInternal.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_RECEIVER)), + new GT_Cover_AdvancedRedstoneReceiverInternal(TextureFactory.of(OVERLAY_ADVANCED_REDSTONE_RECEIVER))); + + GregTech_API.registerCover( + ItemList.Cover_WirelessFluidDetector.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_WIRELESS_FLUID_DETECTOR)), + new GT_Cover_WirelessFluidDetector(TextureFactory.of(OVERLAY_WIRELESS_FLUID_DETECTOR))); + + GregTech_API.registerCover( + ItemList.Cover_WirelessItemDetector.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_WIRELESS_ITEM_DETECTOR)), + new GT_Cover_WirelessItemDetector(TextureFactory.of(OVERLAY_WIRELESS_ITEM_DETECTOR))); + + GregTech_API.registerCover( + ItemList.Cover_WirelessActivityDetector.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_WIRELESS_ACTIVITYDETECTOR)), + new GT_Cover_WirelessDoesWorkDetector(TextureFactory.of(OVERLAY_WIRELESS_ACTIVITYDETECTOR))); + + GregTech_API.registerCover( + ItemList.Cover_WirelessNeedsMaintainance.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_WIRELESS_MAINTENANCE_DETECTOR)), + new GT_Cover_WirelessMaintenanceDetector(TextureFactory.of(OVERLAY_WIRELESS_MAINTENANCE_DETECTOR))); + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Cover_RedstoneTransmitterExternal.get(1L), + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Data, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_AdvancedRedstoneTransmitterExternal.get(1L)) + .duration(2 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Cover_RedstoneReceiverExternal.get(1L), + GT_OreDictUnificator.get(OrePrefixes.circuit, Materials.Data, 1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_AdvancedRedstoneReceiverExternal.get(1L)) + .duration(2 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Cover_FluidDetector.get(1L), + ItemList.Emitter_EV.get(1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_WirelessFluidDetector.get(1L)) + .duration(2 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Cover_ItemDetector.get(1L), + ItemList.Emitter_EV.get(1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_WirelessItemDetector.get(1L)) + .duration(2 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Cover_NeedsMaintainance.get(1L), + ItemList.Emitter_EV.get(1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_WirelessNeedsMaintainance.get(1L)) + .duration(2 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Cover_ActivityDetector.get(1L), + ItemList.Emitter_EV.get(1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(ItemList.Cover_WirelessActivityDetector.get(1L)) + .duration(2 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Cover_AdvancedRedstoneReceiverExternal.get(1L), + new Object[] { ItemList.Cover_AdvancedRedstoneReceiverInternal.get(1L) }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Cover_AdvancedRedstoneReceiverInternal.get(1L), + new Object[] { ItemList.Cover_AdvancedRedstoneReceiverExternal.get(1L) }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Cover_AdvancedRedstoneTransmitterExternal.get(1L), + new Object[] { ItemList.Cover_AdvancedRedstoneTransmitterInternal.get(1L) }); + GT_ModHandler.addShapelessCraftingRecipe( + ItemList.Cover_AdvancedRedstoneTransmitterInternal.get(1L), + new Object[] { ItemList.Cover_AdvancedRedstoneTransmitterExternal.get(1L) }); + + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 0), new ItemStack(Items.dye, 2, 1)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 1), new ItemStack(Items.dye, 2, 12)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 2), new ItemStack(Items.dye, 2, 13)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 3), new ItemStack(Items.dye, 2, 7)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 4), new ItemStack(Items.dye, 2, 1)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 5), new ItemStack(Items.dye, 2, 14)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 6), new ItemStack(Items.dye, 2, 7)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 7), new ItemStack(Items.dye, 2, 9)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 8), new ItemStack(Items.dye, 2, 7)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.yellow_flower, 1, 0), new ItemStack(Items.dye, 2, 11)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.double_plant, 1, 0), new ItemStack(Items.dye, 3, 11)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.double_plant, 1, 1), new ItemStack(Items.dye, 3, 13)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.double_plant, 1, 4), new ItemStack(Items.dye, 3, 1)); + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.double_plant, 1, 5), new ItemStack(Items.dye, 3, 9)); + GT_ModHandler.addExtractionRecipe( + ItemList.Crop_Drop_Plumbilia.get(1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Lead, 1L)); + GT_ModHandler.addExtractionRecipe( + ItemList.Crop_Drop_Argentia.get(1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Silver, 1L)); + GT_ModHandler.addExtractionRecipe(ItemList.Crop_Drop_Indigo.get(1L), ItemList.Dye_Indigo.get(1L)); + GT_ModHandler.addExtractionRecipe( + ItemList.Crop_Drop_MilkWart.get(1L), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Milk, 1L)); + GT_ModHandler.addExtractionRecipe( + ItemList.Crop_Drop_Coppon.get(1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Copper, 1L)); + GT_ModHandler.addExtractionRecipe( + ItemList.Crop_Drop_Tine.get(1L), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Tin, 1L)); + + // Compression recipes + { + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Crop_Drop_Coppon.get(4L)) + .itemOutputs(new ItemStack(Blocks.wool, 1, 1)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Crop_Drop_Plumbilia.get(4L)) + .itemOutputs(ItemList.IC2_PlantballCompressed.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Crop_Drop_Argentia.get(4L)) + .itemOutputs(ItemList.IC2_PlantballCompressed.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Crop_Drop_Indigo.get(4L)) + .itemOutputs(ItemList.IC2_PlantballCompressed.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Crop_Drop_Ferru.get(4L)) + .itemOutputs(ItemList.IC2_PlantballCompressed.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Crop_Drop_Aurelia.get(4L)) + .itemOutputs(ItemList.IC2_PlantballCompressed.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Crop_Drop_OilBerry.get(4L)) + .itemOutputs(ItemList.IC2_PlantballCompressed.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Crop_Drop_BobsYerUncleRanks.get(4L)) + .itemOutputs(ItemList.IC2_PlantballCompressed.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Crop_Drop_Tine.get(4L)) + .itemOutputs(ItemList.IC2_PlantballCompressed.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Crop_Drop_Rape.get(4L)) + .itemOutputs(ItemList.IC2_PlantballCompressed.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.red_flower, 8, 32767)) + .itemOutputs(ItemList.IC2_PlantballCompressed.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.yellow_flower, 8, 32767)) + .itemOutputs(ItemList.IC2_PlantballCompressed.get(1L)) + .duration(15 * SECONDS) + .eut(2) + .addTo(compressorRecipes); + } + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Food_Sliced_Cheese.get(1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Cheese, 1L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Dye_Cocoa.get(1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Cocoa, 1L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Crop_Drop_Tine.get(1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Wood, 2L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.pumpkin, 1, 0)) + .itemOutputs(new ItemStack(Items.pumpkin_seeds, 4, 0)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Items.melon, 1, 0)) + .itemOutputs(new ItemStack(Items.melon_seeds, 1, 0)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(GT_ModHandler.getIC2Item("crop", 1L)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wood, 1L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Items.stick, 1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.Wood, 2L)) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.wool, 1, WILDCARD)) + .itemOutputs(new ItemStack(Items.string, 2), new ItemStack(Items.string, 1)) + .outputChances(10000, 5000) + .duration(20 * SECONDS) + .eut(2) + .addTo(maceratorRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(ItemList.Tesseract.get(1)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.dust, MaterialsUEVplus.TranscendentMetal, 8L)) + .duration(5 * SECONDS) + .eut(32_000_000) + .addTo(maceratorRecipes); + try { + CropCard tCrop; + GT_Utility.getField(tCrop = Crops.instance.getCropList()[13], "mDrop") + .set(tCrop, ItemList.Crop_Drop_Ferru.get(1L)); + GT_Utility.getField(tCrop = Crops.instance.getCropList()[14], "mDrop") + .set(tCrop, ItemList.Crop_Drop_Aurelia.get(1L)); + } catch (Throwable e) { + if (GT_Values.D1) { + e.printStackTrace(GT_Log.err); + } + } + ItemList.Display_ITS_FREE.set( + addItem( + tLastID = 765, + "ITS FREE", + "(or at least almost free)", + SubTag.INVISIBLE, + new TC_Aspects.TC_AspectStack(TC_Aspects.LUCRUM, 1L))); + } + + @Override + public boolean onLeftClickEntity(ItemStack aStack, EntityPlayer aPlayer, Entity aEntity) { + super.onLeftClickEntity(aStack, aPlayer, aEntity); + int aDamage = aStack.getItemDamage(); + if ((aDamage >= 25000) && (aDamage < 27000)) { + if (aDamage >= 26000) { + return Behaviour_Arrow.DEFAULT_PLASTIC.onLeftClickEntity(this, aStack, aPlayer, aEntity); + } + return Behaviour_Arrow.DEFAULT_WOODEN.onLeftClickEntity(this, aStack, aPlayer, aEntity); + } + return false; + } + + @Override + public boolean hasProjectile(SubTag aProjectileType, ItemStack aStack) { + int aDamage = aStack.getItemDamage(); + return ((aDamage >= 25000) && (aDamage < 27000)) || (super.hasProjectile(aProjectileType, aStack)); + } + + @Override + public EntityArrow getProjectile(SubTag aProjectileType, ItemStack aStack, World aWorld, double aX, double aY, + double aZ) { + int aDamage = aStack.getItemDamage(); + if ((aDamage >= 25000) && (aDamage < 27000)) { + if (aDamage >= 26000) { + return Behaviour_Arrow.DEFAULT_PLASTIC.getProjectile(this, aProjectileType, aStack, aWorld, aX, aY, aZ); + } + return Behaviour_Arrow.DEFAULT_WOODEN.getProjectile(this, aProjectileType, aStack, aWorld, aX, aY, aZ); + } + return super.getProjectile(aProjectileType, aStack, aWorld, aX, aY, aZ); + } + + @Override + public EntityArrow getProjectile(SubTag aProjectileType, ItemStack aStack, World aWorld, EntityLivingBase aEntity, + float aSpeed) { + int aDamage = aStack.getItemDamage(); + if ((aDamage >= 25000) && (aDamage < 27000)) { + if (aDamage >= 26000) { + return Behaviour_Arrow.DEFAULT_PLASTIC + .getProjectile(this, aProjectileType, aStack, aWorld, aEntity, aSpeed); + } + return Behaviour_Arrow.DEFAULT_WOODEN.getProjectile(this, aProjectileType, aStack, aWorld, aEntity, aSpeed); + } + return super.getProjectile(aProjectileType, aStack, aWorld, aEntity, aSpeed); + } + + @Override + public boolean isItemStackUsable(ItemStack aStack) { + int aDamage = aStack.getItemDamage(); + Materials aMaterial = GregTech_API.sGeneratedMaterials[(aDamage % 1000)]; + if ((aDamage >= 25000) && (aDamage < 27000) && (aMaterial != null) && (aMaterial.mEnchantmentTools != null)) { + Enchantment tEnchant = aMaterial.mEnchantmentTools == Enchantment.fortune ? Enchantment.looting + : aMaterial.mEnchantmentTools; + if (tEnchant.type == EnumEnchantmentType.weapon) { + NBTTagCompound tNBT = GT_Utility.ItemNBT.getNBT(aStack); + if (!tNBT.getBoolean("GT.HasBeenUpdated")) { + tNBT.setBoolean("GT.HasBeenUpdated", true); + GT_Utility.ItemNBT.setNBT(aStack, tNBT); + GT_Utility.ItemNBT.addEnchantment(aStack, tEnchant, aMaterial.mEnchantmentToolsLevel); + } + } + } + return super.isItemStackUsable(aStack); + } + + @Override + public boolean doesShowInCreative(OrePrefixes aPrefix, Materials aMaterial, boolean aDoShowAllItems) { + return (aDoShowAllItems) || (!aPrefix.name() + .startsWith("toolHead")); + } + + @Override + public ItemStack onDispense(IBlockSource aSource, ItemStack aStack) { + int aDamage = aStack.getItemDamage(); + if ((aDamage >= 25000) && (aDamage < 27000)) { + if (aDamage >= 26000) { + return Behaviour_Arrow.DEFAULT_PLASTIC.onDispense(this, aSource, aStack); + } + return Behaviour_Arrow.DEFAULT_WOODEN.onDispense(this, aSource, aStack); + } + return super.onDispense(aSource, aStack); + } + + @Override + public final ItemStack getContainerItem(ItemStack aStack) { + int aDamage = aStack.getItemDamage(); + if (aDamage < 32000) { + return null; + } + if (aDamage < 32100) { + return ItemList.ThermosCan_Empty.get(1L); + } + if (aDamage < 32200) { + return ItemList.Bottle_Empty.get(1L); + } + return null; + } +} diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_03.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_03.java new file mode 100644 index 0000000000..3a0c4a95d8 --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_03.java @@ -0,0 +1,1087 @@ +package gregtech.common.items; + +import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASINGS; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_METRICS_TRANSMITTER; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL_UEV; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL_UHV; +import static gregtech.api.enums.Textures.BlockIcons.SOLARPANEL_UIV; +import static gregtech.client.GT_TooltipHandler.Tier.EV; +import static gregtech.client.GT_TooltipHandler.Tier.HV; +import static gregtech.client.GT_TooltipHandler.Tier.IV; +import static gregtech.client.GT_TooltipHandler.Tier.LV; +import static gregtech.client.GT_TooltipHandler.Tier.LuV; +import static gregtech.client.GT_TooltipHandler.Tier.MAX; +import static gregtech.client.GT_TooltipHandler.Tier.MV; +import static gregtech.client.GT_TooltipHandler.Tier.UEV; +import static gregtech.client.GT_TooltipHandler.Tier.UHV; +import static gregtech.client.GT_TooltipHandler.Tier.UIV; +import static gregtech.client.GT_TooltipHandler.Tier.ULV; +import static gregtech.client.GT_TooltipHandler.Tier.UMV; +import static gregtech.client.GT_TooltipHandler.Tier.UV; +import static gregtech.client.GT_TooltipHandler.Tier.UXV; +import static gregtech.client.GT_TooltipHandler.Tier.ZPM; +import static gregtech.client.GT_TooltipHandler.registerTieredTooltip; + +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.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TC_Aspects; +import gregtech.api.items.GT_MetaGenerated_Item_X32; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.common.covers.GT_Cover_Metrics_Transmitter; +import gregtech.common.covers.GT_Cover_SolarPanel; + +public class GT_MetaGenerated_Item_03 extends GT_MetaGenerated_Item_X32 { + + public static GT_MetaGenerated_Item_03 INSTANCE; + + public GT_MetaGenerated_Item_03() { + super( + "metaitem.03", + OrePrefixes.crateGtDust, + OrePrefixes.crateGtIngot, + OrePrefixes.crateGtGem, + OrePrefixes.crateGtPlate, + OrePrefixes.nanite, + OrePrefixes.rawOre); + INSTANCE = this; + Object[] o = new Object[0]; + + /* + * circuit boards tier 1-7: coated circuit board / wood plate + resin Plastic Circuit Board / Plastic + Copper + * Foil + Sulfuric Acid phenolic circuit board /carton+glue+chemical bath epoxy circuit board /epoxy plate + + * copper foil + sulfuric acid fiberglass circuit board (simple + multilayer) / glass + plastic + electrum foil + * + sulfuric acid wetware lifesupport board / fiberglass CB + teflon + + */ + ItemList.Circuit_Board_Wetware + .set(addItem(6, "Wetware Lifesupport Circuit Board", "The Board that keeps life", o)); + ItemList.Circuit_Board_Plastic.set(addItem(7, "Plastic Circuit Board", "A Good Board", o)); + ItemList.Circuit_Board_Bio.set(addItem(8, "Bio Circuit Board", "Bio genetic mutated Board", o)); + + /* + * electronic components: vacuum tube (glass tube + red alloy cables) basic electronic circuits normal+smd coils + * diodes normal+smd transistors normal+smd capacitors normal+smd Glass Fibers + */ + ItemList.Circuit_Parts_ResistorSMD.set( + addItem( + 11, + "SMD Resistor", + "Electronic Component", + OrePrefixes.componentCircuit.get(Materials.Resistor), + SubTag.NO_UNIFICATION)); + ItemList.Circuit_Parts_Glass_Tube.set(addItem(12, "Glass Tube", "", o)); + ItemList.Circuit_Parts_Coil.set(addItem(14, "Small Coil", "Basic Electronic Component", o)); + ItemList.Circuit_Parts_DiodeSMD.set( + addItem( + 16, + "SMD Diode", + "Electronic Component", + OrePrefixes.componentCircuit.get(Materials.Diode), + SubTag.NO_UNIFICATION)); + ItemList.Circuit_Parts_TransistorSMD.set( + addItem( + 18, + "SMD Transistor", + "Electronic Component", + OrePrefixes.componentCircuit.get(Materials.Transistor), + SubTag.NO_UNIFICATION)); + ItemList.Circuit_Parts_CapacitorSMD.set( + addItem( + 20, + "SMD Capacitor", + "Electronic Component", + OrePrefixes.componentCircuit.get(Materials.Capacitor), + SubTag.NO_UNIFICATION)); + ItemList.Circuit_Parts_GlassFiber + .set(addItem(21, "Glass Fiber", Materials.BorosilicateGlass.mChemicalFormula, o)); + ItemList.Circuit_Parts_PetriDish.set(addItem(22, "Petri Dish", "For cultivating cells", o)); + ItemList.Circuit_Parts_Reinforced_Glass_Tube.set(addItem(23, "Reinforced Glass Tube", "", o)); + + ItemList.Circuit_Parts_ResistorASMD + .set(addItem(24, "Advanced SMD Resistor", "Advanced Electronic Component", o)); + ItemList.Circuit_Parts_DiodeASMD.set(addItem(25, "Advanced SMD Diode", "Advanced Electronic Component", o)); + ItemList.Circuit_Parts_TransistorASMD + .set(addItem(26, "Advanced SMD Transistor", "Advanced Electronic Component", o)); + ItemList.Circuit_Parts_CapacitorASMD + .set(addItem(27, "Advanced SMD Capacitor", "Advanced Electronic Component", o)); + + ItemList.Circuit_Parts_ResistorXSMD + .set(addItem(178, "Optical SMD Resistor", "Highly Advanced Electronic Component", o)); + ItemList.Circuit_Parts_DiodeXSMD + .set(addItem(179, "Optical SMD Diode", "Highly Advanced Electronic Component", o)); + ItemList.Circuit_Parts_TransistorXSMD + .set(addItem(180, "Optical SMD Transistor", "Highly Advanced Electronic Component", o)); + ItemList.Circuit_Parts_CapacitorXSMD + .set(addItem(181, "Optical SMD Capacitor", "Highly Advanced Electronic Component", o)); + + ItemList.Circuit_Parts_InductorSMD.set( + addItem( + 182, + "SMD Inductor", + "Electronic Component", + OrePrefixes.componentCircuit.get(Materials.Inductor), + SubTag.NO_UNIFICATION)); + ItemList.Circuit_Parts_InductorASMD + .set(addItem(183, "Advanced SMD Inductor", "Advanced Electronic Component", o)); + ItemList.Circuit_Parts_InductorXSMD + .set(addItem(184, "Optical SMD Inductor", "Highly Advanced Electronic Component", o)); + + GT_OreDictUnificator + .set(OrePrefixes.componentCircuit, Materials.Resistor, ItemList.Circuit_Parts_Resistor.get(1L)); + GT_OreDictUnificator.set(OrePrefixes.componentCircuit, Materials.Diode, ItemList.Circuit_Parts_Diode.get(1L)); + GT_OreDictUnificator + .set(OrePrefixes.componentCircuit, Materials.Transistor, ItemList.Circuit_Parts_Transistor.get(1L)); + GT_OreDictUnificator.set(OrePrefixes.componentCircuit, Materials.Inductor, ItemList.Circuit_Parts_Coil.get(1L)); + GT_OreDictUnificator + .set(OrePrefixes.componentCircuit, Materials.Capacitor, ItemList.Circuit_Parts_Capacitor.get(1L)); + + GT_OreDictUnificator.addAssociation( + OrePrefixes.componentCircuit, + Materials.Resistor, + ItemList.Circuit_Parts_ResistorSMD.get(1L), + true); + GT_OreDictUnificator.addAssociation( + OrePrefixes.componentCircuit, + Materials.Diode, + ItemList.Circuit_Parts_DiodeSMD.get(1L), + true); + GT_OreDictUnificator.addAssociation( + OrePrefixes.componentCircuit, + Materials.Transistor, + ItemList.Circuit_Parts_TransistorSMD.get(1L), + true); + GT_OreDictUnificator.addAssociation( + OrePrefixes.componentCircuit, + Materials.Capacitor, + ItemList.Circuit_Parts_CapacitorSMD.get(1L), + true); + GT_OreDictUnificator.addAssociation( + OrePrefixes.componentCircuit, + Materials.Inductor, + ItemList.Circuit_Parts_InductorSMD.get(1L), + true); + + /* + * ICs Lenses made from perfect crystals first instead of plates Monocrystalline silicon ingot + * (normal+glowstone+naquadah) EBF, normal silicon no EBF need anymore wafer(normal+glowstone+naquadah) cut mono + * silicon ingot in cutting machine + * Integrated Logic Circuit(8bit DIP) RAM NAND Memory NOR Memory CPU (4 sizes) SoCs(2 sizes, high tier cheap low + * tech component) Power IC/High Power IC/Ultra High power + * nanotube interconnected circuit (H-IC + nanotubes) + * quantum chips + */ + ItemList.Circuit_Silicon_Ingot.set(addItem(30, "Monocrystalline Silicon Boule", "Raw Circuit", o)); + ItemList.Circuit_Silicon_Ingot2 + .set(addItem(31, "Phosphorus doped Monocrystalline Silicon Boule", "Raw Circuit", o)); + ItemList.Circuit_Silicon_Ingot3 + .set(addItem(32, "Naquadah doped Monocrystalline Silicon Boule", "Raw Circuit", o)); + ItemList.Circuit_Silicon_Ingot4 + .set(addItem(150, "Europium doped Monocrystalline Silicon Boule", "Raw Circuit", o)); + ItemList.Circuit_Silicon_Ingot5 + .set(addItem(152, "Americium doped Monocrystalline Silicon Boule", "Raw Circuit", o)); + ItemList.Circuit_Silicon_Ingot6.set(addItem(721, "Optically Enriched Crystalline Boule", "Raw Circuit", o)); + + ItemList.Circuit_Silicon_Wafer.set(addItem(33, "Wafer", "Raw Circuit", o)); + ItemList.Circuit_Silicon_Wafer2.set(addItem(34, "Phosphorus doped Wafer", "Raw Circuit", o)); + ItemList.Circuit_Silicon_Wafer3.set(addItem(35, "Naquadah doped Wafer", "Raw Circuit", o)); + ItemList.Circuit_Silicon_Wafer4.set(addItem(151, "Europium doped Wafer", "Raw Circuit", o)); + ItemList.Circuit_Silicon_Wafer5.set(addItem(153, "Americium doped Wafer", "Raw Circuit", o)); + ItemList.Circuit_Silicon_Wafer6.set(addItem(722, "Photonically Prepared Wafer", "Raw Circuit", o)); + ItemList.Circuit_Silicon_Wafer7.set(addItem(723, "Photonically Enhanced Wafer", "Raw Circuit", o)); + + ItemList.Circuit_Wafer_ILC.set(addItem(36, "Integrated Logic Circuit (Wafer)", "Raw Circuit", o)); + ItemList.Circuit_Chip_ILC.set(addItem(37, "Integrated Logic Circuit", "Integrated Circuit", o)); + + ItemList.Circuit_Wafer_Ram.set(addItem(38, "Random Access Memory Chip (Wafer)", "Raw Circuit", o)); + ItemList.Circuit_Chip_Ram.set(addItem(39, "Random Access Memory Chip", "Integrated Circuit", o)); + + ItemList.Circuit_Wafer_NAND.set(addItem(40, "NAND Memory Chip (Wafer)", "Raw Circuit", o)); + ItemList.Circuit_Chip_NAND.set(addItem(41, "NAND Memory Chip", "Integrated Circuit", o)); + + ItemList.Circuit_Wafer_NOR.set(addItem(42, "NOR Memory Chip (Wafer)", "Raw Circuit", o)); + ItemList.Circuit_Chip_NOR.set(addItem(43, "NOR Memory Chip", "Integrated Circuit", o)); + + ItemList.Circuit_Wafer_CPU.set(addItem(44, "Central Processing Unit (Wafer)", "Raw Circuit", o)); + ItemList.Circuit_Chip_CPU.set(addItem(45, "Central Processing Unit", "Integrated Circuit", o)); + + ItemList.Circuit_Wafer_SoC.set(addItem(46, "SoC Wafer", "Raw Circuit", o)); + ItemList.Circuit_Chip_SoC.set(addItem(47, "SoC", "System on a Chip", o)); + + ItemList.Circuit_Wafer_SoC2.set(addItem(48, "ASoC Wafer", "Raw Circuit", o)); + ItemList.Circuit_Chip_SoC2.set(addItem(49, "ASoC", "Advanced System on a Chip", o)); + + ItemList.Circuit_Wafer_PIC.set(addItem(50, "PIC Wafer", "Raw Circuit", o)); + ItemList.Circuit_Chip_PIC.set(addItem(51, "Power IC", "Power Circuit", o)); + + ItemList.Circuit_Wafer_HPIC.set(addItem(52, "HPIC Wafer", "Raw Circuit", o)); + ItemList.Circuit_Chip_HPIC.set(addItem(53, "High Power IC", "High Power Circuit", o)); + + ItemList.Circuit_Wafer_NanoCPU.set(addItem(54, "NanoCPU Wafer", "Raw Circuit", o)); + ItemList.Circuit_Chip_NanoCPU.set(addItem(55, "Nanocomponent Central Processing Unit", "Power Circuit", o)); + + ItemList.Circuit_Wafer_QuantumCPU.set(addItem(56, "QBit Wafer", "Raw Circuit", o)); + ItemList.Circuit_Chip_QuantumCPU.set(addItem(57, "QBit Processing Unit", "Quantum CPU", o)); + + ItemList.Circuit_Wafer_UHPIC.set(addItem(58, "UHPIC Wafer", "Raw Circuit", o)); + ItemList.Circuit_Chip_UHPIC.set(addItem(59, "Ultra High Power IC", "Ultra High Power Circuit", o)); + + ItemList.Circuit_Wafer_Simple_SoC.set(addItem(60, "Simple SoC Wafer", "Raw Primitive Circuit", o)); + ItemList.Circuit_Chip_Simple_SoC.set(addItem(61, "Simple SoC", "Simple System on a Chip", o)); + + ItemList.Circuit_Wafer_ULPIC.set(addItem(62, "ULPIC Wafer", "Raw Circuit", o)); + ItemList.Circuit_Chip_ULPIC.set(addItem(63, "Ultra Low Power IC", "Ultra Low Power Circuit", o)); + + ItemList.Circuit_Wafer_LPIC.set(addItem(64, "LPIC Wafer", "Raw Circuit", o)); + ItemList.Circuit_Chip_LPIC.set(addItem(65, "Low Power IC", "Low Power Circuit", o)); + + ItemList.Circuit_Wafer_NPIC.set(addItem(160, "NPIC Wafer", "Raw Circuit", o)); + ItemList.Circuit_Chip_NPIC.set(addItem(161, "Nano Power IC", "Nano Power Circuit", o)); + + ItemList.Circuit_Wafer_PPIC.set(addItem(162, "PPIC Wafer", "Raw Circuit", o)); + ItemList.Circuit_Chip_PPIC.set(addItem(163, "Piko Power IC", "Piko Power Circuit", o)); + + ItemList.Circuit_Wafer_QPIC.set(addItem(164, "QPIC Wafer", "Raw Circuit", o)); + ItemList.Circuit_Chip_QPIC.set(addItem(165, "Quantum Power IC", "Quantum Power Circuit", o)); + + ItemList.Circuit_Wafer_Bioware.set(addItem(188, "Living Bio Wafer", "Raw Circuit", o)); + ItemList.Circuit_Parts_Chip_Bioware.set(addItem(189, "Living Bio Chip", "Needed for Circuits", o)); + /* + * Engraved Crystal Chip Engraved Lapotron Chip Crystal CPU SoCrystal stem cells (disassemble eggs) + */ + ItemList.Circuit_Chip_CrystalSoC2 + .set(addItem(68, "Raw Advanced Crystal Chip", "Raw Advanced Crystal Processor", o)); + ItemList.Circuit_Parts_RawCrystalChip.set(addItem(69, "Raw Crystal Chip", "Raw Crystal Processor", o)); + ItemList.Circuit_Chip_CrystalCPU.set(addItem(70, "Crystal Processing Unit", "Crystal CPU", o)); // Crystal + // chip + // elite + // part + ItemList.Circuit_Chip_CrystalSoC.set(addItem(71, "Crystal SoC", "Crystal System on a Chip", o)); + ItemList.Circuit_Chip_NeuroCPU.set(addItem(72, "Neuro Processing Unit", "Neuro CPU", o)); + ItemList.Circuit_Chip_Stemcell.set(addItem(73, "Stemcells", "Raw inteligence", o)); + ItemList.Circuit_Parts_RawCrystalParts + .set(addItem(74, "Raw Crystal Chip Parts", "Raw Crystal Processor Parts", o)); + ItemList.Circuit_Chip_Biocell.set(addItem(76, "Biocells", "Mutated Raw inteligence", o)); + ItemList.Circuit_Chip_BioCPU.set(addItem(77, "Bio Processing Unit", "Bio CPU", o)); + ItemList.Circuit_Chip_Optical.set(addItem(724, "Raw Exposed Optical Chip", "Raw Optical Chip", o)); + + // Nand Chip + ItemList.NandChip.set( + addItem( + 75, + "NAND Chip", + "A very simple Circuit", + OrePrefixes.circuit.get(Materials.Primitive), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.NandChip.get(1), ULV); + // Vacuum Tube Item01 + // Basic Circuit IC2 + // Good Circuit Item01 + + // Integrated Logic Circuit Item01 + ItemList.Circuit_Integrated_Good.set( + addItem( + 79, + "Good Integrated Circuit", + "Good Circuit", + OrePrefixes.circuit.get(Materials.Good), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Integrated_Good.get(1), MV); + // Good Integrated Circuit Item01 + // Advanced Circuit IC2 + + ItemList.Circuit_Microprocessor.set( + addItem( + 78, + "Microprocessor", + "A Basic Circuit", + OrePrefixes.circuit.get(Materials.Basic), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Microprocessor.get(1), LV); + ItemList.Circuit_Processor.set( + addItem( + 80, + "Integrated Processor", + "A Good Circuit", + OrePrefixes.circuit.get(Materials.Good), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Processor.get(1), MV); + // ItemList.Circuit_Computer.set(addItem(tLastID = 81, "Processor Assembly", "Advanced Circuit", new + // Object[]{OrePrefixes.circuit.get(Materials.Advanced), SubTag.NO_UNIFICATION})); + // Workstation/ Item01 Datacircuit + // Mainframe Item01 DataProcessor + + ItemList.Circuit_Nanoprocessor.set( + addItem( + 82, + "Nanoprocessor", + "An Advanced Circuit", + OrePrefixes.circuit.get(Materials.Advanced), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Nanoprocessor.get(1), HV); + ItemList.Circuit_Nanocomputer.set( + addItem( + 83, + "Nanoprocessor Assembly", + "An Extreme Circuit", + OrePrefixes.circuit.get(Materials.Data), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Nanocomputer.get(1), EV); + ItemList.Circuit_Elitenanocomputer.set( + addItem( + 84, + "Elite Nanocomputer", + "An Elite Circuit", + OrePrefixes.circuit.get(Materials.Elite), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Elitenanocomputer.get(1), IV); + // Nanoprocessor Mainframe Item01 Energy Flow Circuit + + // Quantum circuits + ItemList.Circuit_Quantumprocessor.set( + addItem( + 85, + "Quantumprocessor", + "An Extreme Circuit", + OrePrefixes.circuit.get(Materials.Data), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Quantumprocessor.get(1), EV); + ItemList.Circuit_Quantumcomputer.set( + addItem( + 86, + "Quantumprocessor Assembly", + "An Elite Circuit", + OrePrefixes.circuit.get(Materials.Elite), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Quantumcomputer.get(1), IV); + ItemList.Circuit_Masterquantumcomputer.set( + addItem( + 87, + "Master Quantumcomputer", + "A Master Circuit", + OrePrefixes.circuit.get(Materials.Master), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Masterquantumcomputer.get(1), LuV); + ItemList.Circuit_Quantummainframe.set( + addItem( + 88, + "Quantumprocessor Mainframe", + "An Ultimate Circuit", + OrePrefixes.circuit.get(Materials.Ultimate), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Quantummainframe.get(1), ZPM); + + // Crystal circuits + ItemList.Circuit_Crystalprocessor.set( + addItem( + 89, + "Crystalprocessor", + "An Elite Circuit", + OrePrefixes.circuit.get(Materials.Elite), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Crystalprocessor.get(1), IV); + ItemList.Circuit_Crystalcomputer.set( + addItem( + 96, + "Crystalprocessor Assembly", + "A Master Circuit", + OrePrefixes.circuit.get(Materials.Master), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Crystalcomputer.get(1), LuV); + ItemList.Circuit_Ultimatecrystalcomputer.set( + addItem( + 90, + "Ultimate Crystalcomputer", + "An Ultimate Circuit", + OrePrefixes.circuit.get(Materials.Ultimate), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Ultimatecrystalcomputer.get(1), ZPM); + ItemList.Circuit_Crystalmainframe.set( + addItem( + 91, + "Crystalprocessor Mainframe", + "A Super Circuit", + OrePrefixes.circuit.get(Materials.SuperconductorUHV), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Crystalmainframe.get(1), UV); + + // ???? Scared to remove. + ItemList.Circuit_Ultimate.set(ItemList.Circuit_Ultimatecrystalcomputer.get(1L)); // maybe should be removed + + // Wetware circuits + ItemList.Circuit_Neuroprocessor.set( + addItem( + 92, + "Wetwareprocessor", + "A Master Circuit", + OrePrefixes.circuit.get(Materials.Master), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Neuroprocessor.get(1), LuV); + ItemList.Circuit_Wetwarecomputer.set( + addItem( + 93, + "Wetwareprocessor Assembly", + "An Ultimate Circuit", + OrePrefixes.circuit.get(Materials.Ultimate), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Wetwarecomputer.get(1), ZPM); + ItemList.Circuit_Wetwaresupercomputer.set( + addItem( + 94, + "Wetware Supercomputer", + "A Super Circuit", + OrePrefixes.circuit.get(Materials.SuperconductorUHV), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Wetwaresupercomputer.get(1), UV); + ItemList.Circuit_Wetwaremainframe.set( + addItem( + 95, + "Wetware Mainframe", + "An Infinite Circuit", + OrePrefixes.circuit.get(Materials.Infinite), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Wetwaremainframe.get(1), UHV); + + // Bioware circuits. + ItemList.Circuit_Bioprocessor.set( + addItem( + 97, + "Bioprocessor", + "An Ultimate Circuit", + OrePrefixes.circuit.get(Materials.Ultimate), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Bioprocessor.get(1), ZPM); + ItemList.Circuit_Biowarecomputer.set( + addItem( + 98, + "Biowareprocessor Assembly", + "A Super Circuit", + OrePrefixes.circuit.get(Materials.SuperconductorUHV), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Biowarecomputer.get(1), UV); + ItemList.Circuit_Biowaresupercomputer.set( + addItem( + 99, + "Bioware Supercomputer", + "An Infinite Circuit", + OrePrefixes.circuit.get(Materials.Infinite), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Biowaresupercomputer.get(1), UHV); + ItemList.Circuit_Biomainframe.set( + addItem( + 120, + "Bio Mainframe", + "A Bio Circuit", + OrePrefixes.circuit.get(Materials.Bio), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_Biomainframe.get(1), UEV); + + ItemList.Circuit_Board_Coated_Basic.set(addItem(100, "Circuit Board", "A basic Circuit Board", o)); + ItemList.Circuit_Board_Phenolic_Good.set(addItem(101, "Good Circuit Board", "A good Circuit Board", o)); + ItemList.Circuit_Board_Epoxy_Advanced + .set(addItem(102, "Advanced Circuit Board", "A advanced Circuit Board", o)); + ItemList.Circuit_Board_Fiberglass_Advanced + .set(addItem(103, "More Advanced Circuit Board", "A more advanced Circuit Board", o)); + ItemList.Circuit_Board_Multifiberglass_Elite + .set(addItem(104, "Elite Circuit Board", "A elite Circuit Board", o)); + ItemList.Circuit_Board_Wetware_Extreme + .set(addItem(105, "Extreme Wetware Lifesupport Circuit Board", "The Board that keeps life", o)); + ItemList.Circuit_Board_Plastic_Advanced.set(addItem(106, "Plastic Circuit Board", "A good Board", o)); + ItemList.Circuit_Board_Bio_Ultra + .set(addItem(107, "Ultra Bio Mutated Circuit Board", "Bio genetic mutated Board", o)); + ItemList.Circuit_Board_Optical.set(addItem(728, "Optical Circuit Board", "Optically Infused Board", o)); + + // Optical circuits + ItemList.Circuit_OpticalProcessor.set( + addItem( + 154, + "Optical Processor", + "An Optical Circuit", + OrePrefixes.circuit.get(Materials.SuperconductorUHV), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_OpticalProcessor.get(1), UV); + ItemList.Circuit_OpticalAssembly.set( + addItem( + 155, + "Optical Assembly", + "An Optical Circuit", + OrePrefixes.circuit.get(Materials.Infinite), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_OpticalAssembly.get(1), UHV); + ItemList.Circuit_OpticalComputer.set( + addItem( + 156, + "Optical Computer", + "An Optical Circuit", + OrePrefixes.circuit.get(Materials.Bio), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_OpticalComputer.get(1), UEV); + ItemList.Circuit_OpticalMainframe.set( + addItem( + 157, + "Optical Mainframe", + "An Optical Circuit", + OrePrefixes.circuit.get(Materials.Optical), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_OpticalMainframe.get(1), UIV); + + // Exotic circuits + ItemList.Circuit_ExoticProcessor.set( + addItem( + 166, + "Exotic Processor", + "An Exotic Circuit", + OrePrefixes.circuit.get(Materials.Infinite), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_ExoticProcessor.get(1), UHV); + ItemList.Circuit_ExoticAssembly.set( + addItem( + 167, + "Exotic Assembly", + "An Exotic Circuit", + OrePrefixes.circuit.get(Materials.Bio), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_ExoticAssembly.get(1), UEV); + ItemList.Circuit_ExoticComputer.set( + addItem( + 168, + "Exotic Computer", + "An Exotic Circuit", + OrePrefixes.circuit.get(Materials.Optical), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_ExoticComputer.get(1), UIV); + ItemList.Circuit_ExoticMainframe.set( + addItem( + 169, + "Exotic Mainframe", + "An Exotic Circuit", + OrePrefixes.circuit.get(Materials.Exotic), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_ExoticMainframe.get(1), UMV); + + // Cosmic circuits + ItemList.Circuit_CosmicProcessor.set( + addItem( + 170, + "Cosmic Processor", + "A Cosmic Circuit", + OrePrefixes.circuit.get(Materials.Bio), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_CosmicProcessor.get(1), UEV); + ItemList.Circuit_CosmicAssembly.set( + addItem( + 171, + "Cosmic Assembly", + "A Cosmic Circuit", + OrePrefixes.circuit.get(Materials.Optical), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_CosmicAssembly.get(1), UIV); + ItemList.Circuit_CosmicComputer.set( + addItem( + 172, + "Cosmic Computer", + "A Cosmic Circuit", + OrePrefixes.circuit.get(Materials.Exotic), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_CosmicComputer.get(1), UMV); + ItemList.Circuit_CosmicMainframe.set( + addItem( + 173, + "Cosmic Mainframe", + "A Cosmic Circuit", + OrePrefixes.circuit.get(Materials.Cosmic), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_CosmicMainframe.get(1), UXV); + + // Transcendent circuits + ItemList.Circuit_TranscendentProcessor.set( + addItem( + 174, + "Temporally Transcendent Processor", + "A circuit operating outside of known spacetime", + OrePrefixes.circuit.get(Materials.Optical), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_TranscendentProcessor.get(1), UIV); + ItemList.Circuit_TranscendentAssembly.set( + addItem( + 175, + "Temporally Transcendent Assembly", + "A circuit operating outside of known spacetime", + OrePrefixes.circuit.get(Materials.Exotic), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_TranscendentAssembly.get(1), UMV); + ItemList.Circuit_TranscendentComputer.set( + addItem( + 176, + "Temporally Transcendent Computer", + "A circuit operating outside of known spacetime", + OrePrefixes.circuit.get(Materials.Cosmic), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_TranscendentComputer.get(1), UXV); + ItemList.Circuit_TranscendentMainframe.set( + addItem( + 177, + "Temporally Transcendent Mainframe", + "A circuit operating outside of known spacetime", + OrePrefixes.circuit.get(Materials.Transcendent), + SubTag.NO_UNIFICATION)); + registerTieredTooltip(ItemList.Circuit_TranscendentMainframe.get(1), MAX); + + ItemList.Tube_Wires.set(addItem(110, "Tube Wires", "For the Vacuum Tubes", o)); + + ItemList.Cover_SolarPanel_UHV.set( + addItem( + 130, + "Solar Panel (UHV)", + "Ultimate High Voltage Solar Panel (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 128L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 128L))); + ItemList.Cover_SolarPanel_UEV.set( + addItem( + 131, + "Solar Panel (UEV)", + "Ultimate Extreme Voltage Solar Panel (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 256L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 256L))); + ItemList.Cover_SolarPanel_UIV.set( + addItem( + 132, + "Solar Panel (UIV)", + "Ultimate Insane Voltage Solar Panel (Needs cleaning with right click)", + new TC_Aspects.TC_AspectStack(TC_Aspects.ELECTRUM, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.POTENTIA, 512L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TENEBRAE, 512L))); + + GregTech_API.registerCover( + ItemList.Cover_SolarPanel_UHV.get(1L), + TextureFactory.of(SOLARPANEL_UHV), + new GT_Cover_SolarPanel(2097152)); + GregTech_API.registerCover( + ItemList.Cover_SolarPanel_UEV.get(1L), + TextureFactory.of(SOLARPANEL_UEV), + new GT_Cover_SolarPanel(8388608)); + GregTech_API.registerCover( + ItemList.Cover_SolarPanel_UIV.get(1L), + TextureFactory.of(SOLARPANEL_UIV), + new GT_Cover_SolarPanel(33554432)); + + ItemList.ULV_Coil.set(addItem(140, "Ultra Low Voltage Coil", "Primitive Coil", o)); + ItemList.LV_Coil.set(addItem(141, "Low Voltage Coil", "Basic Coil", o)); + ItemList.MV_Coil.set(addItem(142, "Medium Voltage Coil", "Good Coil", o)); + ItemList.HV_Coil.set(addItem(143, "High Voltage Coil", "Advanced Coil", o)); + ItemList.EV_Coil.set(addItem(144, "Extreme Voltage Coil", "Extreme Coil", o)); + ItemList.IV_Coil.set(addItem(145, "Insane Voltage Coil", "Elite Coil", o)); + ItemList.LuV_Coil.set(addItem(146, "Ludicrous Voltage Coil", "Master Coil", o)); + ItemList.ZPM_Coil.set(addItem(147, "ZPM Voltage Coil", "Ultimate Coil", o)); + ItemList.UV_Coil.set(addItem(148, "Ultimate Voltage Coil", "Super Coil", o)); + ItemList.UHV_Coil.set(addItem(149, "Highly Ultimate Voltage Coil", "Infinite Coil", o)); + + ItemList.GalliumArsenideCrystal.set(addItem(190, "Gallium Arsenide Crystal", "For making boules", o)); + ItemList.GalliumArsenideCrystalSmallPart + .set(addItem(191, "Small Gallium Arsenide Crystal", "For making boules", o)); + ItemList.KevlarFiber.set(addItem(192, "Kevlar Fiber", "For making Kevlar Plates", o)); + ItemList.WovenKevlar.set(addItem(193, "Woven Kevlar", "For making Kevlar Plates", o)); + ItemList.Spinneret.set(addItem(194, "Spinneret", "For making Kevlar Fiber", o)); + + ItemList.IndustrialApiary_Upgrade_Frame.set(addItem(199, "Upgrade Frame", "Crafting component", o)); + + ItemList.IndustrialApiary_Upgrade_Acceleration_1.set( + addItem( + 200, + "Acceleration Upgrade x2", + "Acceleration upgrade for Industrial Apiary/n Maximum Installed: 1/n * Unlocks 2x acceleration level/n * Energy Consumption +1 AMP LV", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_Acceleration_2.set( + addItem( + 201, + "Acceleration Upgrade x4", + "Acceleration upgrade for Industrial Apiary/n Maximum Installed: 1/n * Unlocks 4x acceleration level/n * Energy Consumption +1 AMP MV", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_Acceleration_3.set( + addItem( + 202, + "Acceleration Upgrade x8", + "Acceleration upgrade for Industrial Apiary/n Maximum Installed: 1/n * Unlocks 8x acceleration level/n * Energy Consumption +1 AMP HV", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_Acceleration_4.set( + addItem( + 203, + "Acceleration Upgrade x16", + "Acceleration upgrade for Industrial Apiary/n Maximum Installed: 1/n * Unlocks 16x acceleration level/n * Energy Consumption +1 AMP EV", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_Acceleration_5.set( + addItem( + 204, + "Acceleration Upgrade x32", + "Acceleration upgrade for Industrial Apiary/n Maximum Installed: 1/n * Unlocks 32x acceleration level/n * Energy Consumption +1 AMP IV", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_Acceleration_6.set( + addItem( + 205, + "Acceleration Upgrade x64", + "Acceleration upgrade for Industrial Apiary/n Maximum Installed: 1/n * Unlocks 64x acceleration level/n * Energy Consumption +1 AMP LuV", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_Acceleration_7.set( + addItem( + 206, + "Acceleration Upgrade x128", + "Acceleration upgrade for Industrial Apiary/n Maximum Installed: 1/n * Unlocks 128x acceleration level/n * Energy Consumption +1 AMP ZPM", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_Acceleration_8.set( + addItem( + 207, + "Acceleration Upgrade x256", + "Acceleration upgrade for Industrial Apiary/n Maximum Installed: 1/n * Unlocks 256x acceleration level/n * Energy Consumption +1 AMP UV", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_Acceleration_8_Upgraded.set( + addItem( + 208, + "Upgraded Acceleration Upgrade x256", + "Acceleration upgrade for Industrial Apiary/n Maximum Installed: 1/n * Unlocks 256x acceleration level/n * Will also grant 8x production upgrade/n * Energy Consumption +1 AMP UV", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_PRODUCTION.set( + addItem( + 209, + "Production Upgrade", + "Production upgrade for Industrial Apiary/n Maximum Installed: 8/n Increases production modifier by 0.25/n Energy Consumption +40%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_PLAINS.set( + addItem( + 210, + "Plains Emulation Upgrade", + "Plains emulation upgrade for Industrial Apiary/n Maximum Installed: 1/n * Biome Override: Plains/n * Energy Consumption +40%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_LIGHT.set( + addItem( + 211, + "Light Upgrade", + "Light upgrade for Industrial Apiary/n Maximum Installed: 1/n * Internal Lighting/n * Energy Consumption +5%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_FLOWERING.set( + addItem( + 212, + "Flowering Upgrade", + "Flowering upgrade for Industrial Apiary/n Maximum Installed: 8/n * Flowering and Pollination +20%/n * Energy Consumption +10%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_WINTER.set( + addItem( + 213, + "Winter Emulation Upgrade", + "Winter emulation upgrade for Industrial Apiary/n Maximum Installed: 1/n * Biome Override: Taiga/n * Energy Consumption +50%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_DRYER.set( + addItem( + 214, + "Dryer Upgrade", + "Dryer upgrade for Industrial Apiary/n Maximum Installed: 16/n * Humidity -12.5%/n * Energy Consumption +2.5%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_AUTOMATION.set( + addItem( + 215, + "Automation Upgrade", + "Automation upgrade for Industrial Apiary/n Maximum Installed: 1/n * Automation/n * Energy Consumption +10%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_HUMIDIFIER.set( + addItem( + 216, + "Humidifier Upgrade", + "Humidifier upgrade for Industrial Apiary/n Maximum Installed: 16/n * Humidity +12.5%/n * Energy Consumption +2.5%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_HELL.set( + addItem( + 217, + "HELL Emulation Upgrade", + "HELL emulation upgrade for Industrial Apiary/n Maximum Installed: 1/n * Biome Override: HELL/n * Energy Consumption +50%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_POLLEN.set( + addItem( + 218, + "Pollen Scrubber Upgrade", + "Pollen scrubber upgrade for Industrial Apiary/n Maximum Installed: 1/n * Flowering and Pollination -100%/n * Energy Consumption +30%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_DESERT.set( + addItem( + 219, + "Desert Emulation Upgrade", + "Desert emulation upgrade for Industrial Apiary/n Maximum Installed: 1/n * Biome Override: Desert/n * Energy Consumption +20%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_COOLER.set( + addItem( + 220, + "Cooler Upgrade", + "Cooler upgrade for Industrial Apiary/n Maximum Installed: 16/n * Temperature -12.5%/n * Energy Consumption +2.5%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_LIFESPAN.set( + addItem( + 221, + "Lifespan Upgrade", + "Lifespan upgrade for Industrial Apiary/n Maximum Installed: 4/n * Lifespan -33%/n * Energy Consumption +5%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_SEAL.set( + addItem( + 222, + "Seal Upgrade", + "Seal upgrade for Industrial Apiary/n Maximum Installed: 1/n * Rain Protection/n * Energy Consumption +5%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_STABILIZER.set( + addItem( + 223, + "Genetic Stabilizer Upgrade", + "Genetic stabilizer upgrade for Industrial Apiary/n Maximum Installed: 1/n * Genetic Decay -100%/n * Energy Consumption +150%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_JUNGLE.set( + addItem( + 224, + "Jungle Emulation Upgrade", + "Jungle emulation upgrade for Industrial Apiary/n Maximum Installed: 1/n * Biome Override: Jungle/n * Energy Consumption +20%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_TERRITORY.set( + addItem( + 225, + "Territory Upgrade", + "Territory upgrade for Industrial Apiary/n Maximum Installed: 4/n * Territory +50%/n * Energy Consumption +5%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_OCEAN.set( + addItem( + 226, + "Ocean Emulation Upgrade", + "Ocean emulation upgrade for Industrial Apiary/n Maximum Installed: 1/n * Biome Override: Ocean/n * Energy Consumption +20%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_SKY.set( + addItem( + 227, + "Open Sky Upgrade", + "Open sky upgrade for Industrial Apiary/n Maximum Installed: 1/n * Open Sky Simulation/n * Energy Consumption +5%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_HEATER.set( + addItem( + 228, + "Heater Upgrade", + "Heater upgrade for Industrial Apiary/n Maximum Installed: 16/n * Temperature +12.5%/n * Energy Consumption +2.5%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_SIEVE.set( + addItem( + 229, + "Sieve Upgrade", + "Sieve upgrade for Industrial Apiary/n Maximum Installed: 1/n * Pollen Collection/n * Energy Consumption +25%", + OrePrefixes.apiaryUpgrade.name())); + ItemList.IndustrialApiary_Upgrade_UNLIGHT.set( + addItem( + 231, + "Night Upgrade", + "Night upgrade for Industrial Apiary/n Maximum Installed: 1/n * Internal Darkness/n * Energy Consumption +5%", + OrePrefixes.apiaryUpgrade.name())); + + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_Acceleration_1.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_Acceleration_2.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_Acceleration_3.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_Acceleration_4.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_Acceleration_5.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_Acceleration_6.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_Acceleration_7.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_Acceleration_8.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_Acceleration_8_Upgraded.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_PRODUCTION.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_PLAINS.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_LIGHT.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_FLOWERING.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_WINTER.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_DRYER.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_AUTOMATION.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_HUMIDIFIER.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_HELL.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_POLLEN.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_DESERT.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_COOLER.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_LIFESPAN.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_SEAL.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_STABILIZER.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_JUNGLE.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_TERRITORY.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_OCEAN.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_SKY.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_HEATER.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_SIEVE.get(1L)); + OrePrefixes.apiaryUpgrade.add(ItemList.IndustrialApiary_Upgrade_UNLIGHT.get(1L)); + + ItemList.NuclearStar.set( + addItem( + 230, + "Nuclear Star", + "By the powers of Greg, I command this star to be really hot.", + SubTag.NO_UNIFICATION)); + + ItemList.Cover_Metrics_Transmitter.set( + addItem( + 232, + "Metrics Transmitter Cover", + String.join( + "/n ", + "Taking Information Panels to the next level!", + "Creates a GregTech Advanced Sensor Card when attached", + "Works across dimensions or if machine is dismantled", + "Removing this cover will destroy the linked card", + GT_Values.AuthorQuerns))); + GregTech_API.registerCover( + ItemList.Cover_Metrics_Transmitter.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_METRICS_TRANSMITTER)), + new GT_Cover_Metrics_Transmitter(TextureFactory.of(OVERLAY_METRICS_TRANSMITTER))); + + ItemList.Optical_Cpu_Containment_Housing.set(addItem(727, "Optical CPU Containment Housing", "CPU Housing", o)); + ItemList.Optically_Perfected_CPU.set(addItem(726, "Optically Perfected CPU", "Perfected CPU!", o)); + ItemList.Optically_Compatible_Memory.set(addItem(725, "Optically Compatible Memory", "Its in the name!", o)); + + ItemList.Timepiece.set(addItem(757, "Timepiece", "Beware of the kid with the hat", o)); + + int whiteDwarfIDs = 729; + ItemList.White_Dwarf_Shape_Extruder_Plate.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Plate)", + "Ultra Strong Stellar Shape for making Plates")); + ItemList.White_Dwarf_Shape_Extruder_Rod.set( + addItem(whiteDwarfIDs++, "White Dwarf Extruder Shape (Rod)", "Ultra Strong Stellar Shape for making Rods")); + ItemList.White_Dwarf_Shape_Extruder_Bolt.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Bolt)", + "Ultra Strong Stellar Shape for making Bolts")); + ItemList.White_Dwarf_Shape_Extruder_Ring.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Ring)", + "Ultra Strong Stellar Shape for making Rings")); + ItemList.White_Dwarf_Shape_Extruder_Cell.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Cell)", + "Ultra Strong Stellar Shape for making Cells")); + ItemList.White_Dwarf_Shape_Extruder_Ingot.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Ingot)", + "Ultra Strong Stellar Shape for, wait, can't we just use a Furnace?")); + ItemList.White_Dwarf_Shape_Extruder_Wire.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Wire)", + "Ultra Strong Stellar Shape for making Wires")); + ItemList.White_Dwarf_Shape_Extruder_Casing.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Casing)", + "Ultra Strong Stellar Shape for making Item Casings")); + ItemList.White_Dwarf_Shape_Extruder_Pipe_Tiny.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Tiny Pipe)", + "Ultra Strong Stellar Shape for making tiny Pipes")); + ItemList.White_Dwarf_Shape_Extruder_Pipe_Small.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Small Pipe)", + "Ultra Strong Stellar Shape for making small Pipes")); + ItemList.White_Dwarf_Shape_Extruder_Pipe_Medium.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Normal Pipe)", + "Ultra Strong Stellar Shape for making Pipes")); + ItemList.White_Dwarf_Shape_Extruder_Pipe_Large.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Large Pipe)", + "Ultra Strong Stellar Shape for making large Pipes")); + ItemList.White_Dwarf_Shape_Extruder_Pipe_Huge.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Huge Pipe)", + "Ultra Strong Stellar Shape for making full Block Pipes")); + ItemList.White_Dwarf_Shape_Extruder_Block.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Block)", + "Ultra Strong Stellar Shape for making Blocks")); + ItemList.White_Dwarf_Shape_Extruder_Sword.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Sword Blade)", + "Ultra Strong Stellar Shape for making Swords")); + ItemList.White_Dwarf_Shape_Extruder_Pickaxe.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Pickaxe Head)", + "Ultra Strong Stellar Shape for making Pickaxes")); + ItemList.White_Dwarf_Shape_Extruder_Shovel.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Shovel Head)", + "Ultra Strong Stellar Shape for making Shovels")); + ItemList.White_Dwarf_Shape_Extruder_Axe.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Axe Head)", + "Ultra Strong Stellar Shape for making Axes")); + ItemList.White_Dwarf_Shape_Extruder_Hoe.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Hoe Head)", + "Ultra Strong Stellar Shape for making Hoes")); + ItemList.White_Dwarf_Shape_Extruder_Hammer.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Hammer Head)", + "Ultra Strong Stellar Shape for making Hammers")); + ItemList.White_Dwarf_Shape_Extruder_File.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (File Head)", + "Ultra Strong Stellar Shape for making Files")); + ItemList.White_Dwarf_Shape_Extruder_Saw.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Saw Blade)", + "Ultra Strong Stellar Shape for making Saws")); + ItemList.White_Dwarf_Shape_Extruder_Gear.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Gear)", + "Ultra Strong Stellar Shape for making Gears")); + ItemList.White_Dwarf_Shape_Extruder_Bottle.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Bottle)", + "Ultra Strong Stellar Shape for making Bottles")); + ItemList.White_Dwarf_Shape_Extruder_Rotor.set( + addItem(whiteDwarfIDs++, "White Dwarf Extruder Shape (Rotor)", "Ultra Strong Stellar Shape for a Rotor")); + ItemList.White_Dwarf_Shape_Extruder_Small_Gear.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Small Gear)", + "Ultra Strong Stellar Shape for a Small Gear")); + ItemList.White_Dwarf_Shape_Extruder_Turbine_Blade.set( + addItem( + whiteDwarfIDs++, + "White Dwarf Extruder Shape (Turbine Blade)", + "Ultra Strong Stellar Extruder Shape for a Turbine Blade")); + ItemList.White_Dwarf_Shape_Extruder_ToolHeadDrill.set( + addItem( + whiteDwarfIDs, + "White Dwarf Extruder Shape (Drill Head)", + "White Dwarf Extruder Shape for a Drill Head")); + } + + @Override + public boolean doesShowInCreative(OrePrefixes aPrefix, Materials aMaterial, boolean aDoShowAllItems) { + return aDoShowAllItems || (aPrefix.toString() + .toLowerCase() + .contains("nanite")) + || (aPrefix.toString() + .toLowerCase() + .contains("rawore")); + } +} diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_98.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_98.java new file mode 100644 index 0000000000..0dab2af2cf --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_98.java @@ -0,0 +1,352 @@ +package gregtech.common.items; + +import java.util.Arrays; +import java.util.EnumMap; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +import javax.annotation.Nullable; + +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.items.GT_MetaGenerated_Item; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Util; +import gregtech.api.util.GT_Utility; + +/** This class holds cells for non-GT fluids. */ +public class GT_MetaGenerated_Item_98 extends GT_MetaGenerated_Item { + + public static GT_MetaGenerated_Item_98 INSTANCE; + + /** + * Registered fluids. + * + * <p> + * When adding a fluid, don't forget to make sure that GregTech loads after the mod that adds that fluid! + * + * <p> + * In order to avoid breaking existing worlds, fluids must not have their IDs changed! The only safe modification + * that can be made to this enum is adding new fluids, or removing existing fluids. When removing fluids, maybe + * leave a comment mentioning the old ID, so that we don't re-use it for a new fluid. + */ + public enum FluidCell { + // Next unused ID: 32 + + // GregTech + DRILLING_FLUID(5, "liquid_drillingfluid", CellType.REGULAR), + SQUID_INK(6, "squidink", CellType.SMALL), + BLUE_VITRIOL(22, "solution.bluevitriol", CellType.REGULAR), + NICKEL_SULFATE(23, "solution.nickelsulfate", CellType.REGULAR), + GREEN_VITRIOL(24, "solution.greenvitriol", CellType.REGULAR), + INDIUM_CONCENTRATE(25, "indiumconcentrate", CellType.REGULAR), + LEAD_ZINC_SOLUTION(26, "leadzincsolution", CellType.REGULAR), + + // New Horizons Core Mod + UNKNOWN_NUTRIENT_AGAR(7, "unknownnutrientagar", CellType.REGULAR), + SEAWEED_BROTH(8, "seaweedbroth", CellType.REGULAR), + SUPER_HEAVY_RADOX(28, "superheavyradox", CellType.REGULAR), + HEAVY_RADOX(29, "heavyradox", CellType.REGULAR), + CRACKED_RADOX(30, "crackedradox", CellType.REGULAR), + LIGHT_RADOX(31, "lightradox", CellType.REGULAR), + SUPER_LIGHT_RADOX(9, "superlightradox", CellType.REGULAR), + SODIUM_POTASSIUM(18, "sodiumpotassium", CellType.REGULAR), + ENRICHED_BACTERIAL_SLUDGE(19, "enrichedbacterialsludge", CellType.REGULAR), + FERMENTED_BACTERIAL_SLUDGE(20, "fermentedbacterialsludge", CellType.REGULAR), + POLLUTION(21, "pollution", CellType.REGULAR), + XENOXENE(27, "xenoxene", CellType.REGULAR), + + // BartWorks + ENZYME_SOLUTION(10, "enzymessollution", CellType.REGULAR), + ESCHERICHIA_COLI_FLUID(11, "escherichiakolifluid", CellType.REGULAR), + PENICILLIN(12, "penicillin", CellType.REGULAR), + FLUORESCENT_DNA(13, "fluorecentddna", CellType.REGULAR), + POLYMERASE(17, "polymerase", CellType.REGULAR), + + // Good Generator + COMBUSTION_PROMOTER(14, "combustionpromotor", CellType.REGULAR), + + // Galacticraft + BACTERIAL_SLUDGE(1, "bacterialsludge", CellType.REGULAR), + + // Railcraft + STEAM(0, "steam", CellType.REGULAR), + + // Gendustry + BACTERIA(15, "binnie.bacteria", CellType.REGULAR), + MUTAGEN(2, "mutagen", CellType.REGULAR), + LIQUID_DNA(16, "liquiddna", CellType.REGULAR), + + // Tinker's Construct + LIQUID_ENDER(3, "ender", CellType.REGULAR), + + // Hardcore Ender Expansion + ENDER_GOO(4, "endergoo", CellType.REGULAR),; + + private final int mId; + /** This is the Forge internal fluid name. */ + private final String mfluidName; + + private final CellType mType; + + @Nullable + private ItemStack mStack; + + FluidCell(int aId, String aFluidName, CellType aType) { + mId = aId; + mfluidName = aFluidName; + mType = aType; + } + + public int getId() { + return mId; + } + + public String getFluidName() { + return mfluidName; + } + + public CellType getDisplayType() { + return mType; + } + + /** + * Get a copy of this stack with stack size 1. + * <p> + * Always returns non-null stack even if the fluid referenced doesn't exist, so don't assume it's always valid. + */ + public ItemStack get() { + trySetStack(); + return GT_Utility.copy(mStack); + } + + /** + * Get a copy of this cell WITHOUT copy. + * <p> + * Always returns non-null stack even if the fluid referenced doesn't exist, so don't assume it's always valid. + * <p> + * Use with caution. + */ + public ItemStack getNoCopy() { + trySetStack(); + return mStack; + } + + /** + * Get a copy of this cell with specified stack size. + * <p> + * Always returns non-null stack even if the fluid referenced doesn't exist, so don't assume it's always valid. + */ + public ItemStack get(int aStackSize) { + trySetStack(); + return GT_Utility.copyAmount(aStackSize, mStack); + } + + private void trySetStack() { + if (mStack == null) { + mStack = new ItemStack(GT_MetaGenerated_Item_98.INSTANCE, 1, mId); + } + } + } + + /** Cell type specifies the cell capacity, appearance, and item name format. */ + private enum CellType { + + REGULAR(1_000, OrePrefixes.cell), + SMALL(144, OrePrefixes.cell), + MOLTEN(144, OrePrefixes.cellMolten), + PLASMA(1_000, OrePrefixes.cellPlasma); + + private final int capacity; + private final OrePrefixes prefix; + + CellType(int capacity, OrePrefixes prefix) { + this.capacity = capacity; + this.prefix = prefix; + } + } + + /** Struct class holding data that we need to properly handle a registered fluid cell item. */ + private static class RegisteredFluidData { + + private final short[] rgba; + private final IIconContainer iconContainer; + + private RegisteredFluidData(short[] rgba, IIconContainer iconContainer) { + this.rgba = rgba; + this.iconContainer = iconContainer; + } + } + + /** + * Map of ID to registered fluid data. + * + * <p> + * Only contains IDs that were successfully registered. + */ + private final Map<Integer, RegisteredFluidData> registeredFluidDataMap; + + private final EnumMap<CellType, IIconContainer> iconContainerMap; + + private GT_MetaGenerated_Item_98() { + // For some reason, fluid cells will be rendered only if the metadata ID is less than the + // offset. So we will specify maximum offset here. + // See: GT_MetaGenerated_Item_Renderer.java + super("metaitem.98", (short) 32766, (short) 0); + + registeredFluidDataMap = new HashMap<>(); + iconContainerMap = new EnumMap<>(CellType.class); + } + + /** + * Loading needs to happen after the fluids we need have been registered, which means during post-load. However, + * cell icons seem to be deleted some time between load and post-load, so we must pre-cache them. + */ + public static synchronized void preInit() { + if (INSTANCE == null) INSTANCE = new GT_MetaGenerated_Item_98(); + + // We'll just steal the icons from Water. They are all the same anyway (except _NULL is broken for cells). + for (CellType cellType : CellType.values()) { + IIconContainer iconContainer = Materials.Water.mIconSet.mTextures[cellType.prefix.mTextureIndex]; + INSTANCE.iconContainerMap.put(cellType, iconContainer); + } + } + + public static synchronized void init() { + INSTANCE.createAllItems(); + INSTANCE.registerOreDict(); + } + + private void createAllItems() { + for (FluidCell tCell : FluidCell.values()) { + tryToInitialize(tCell); + } + + // We're not going to use these BitSets, so clear them to save memory. + mEnabledItems.clear(); + mVisibleItems.clear(); + } + + private void tryToInitialize(FluidCell aCell) { + final boolean isStackAlreadySet = aCell.mStack != null; + + int id = aCell.getId(); + String fluidName = aCell.getFluidName(); + CellType cellType = aCell.getDisplayType(); + + // We'll check for ID uniqueness. Better to throw an exception than silently overwrite some + // fluid cells with other fluids due to ID collision. + if (registeredFluidDataMap.containsKey(id)) { + throw new IllegalStateException("Got ID collision for ID: " + id); + } + + aCell.trySetStack(); + + Fluid fluid = FluidRegistry.getFluid(fluidName); + if (fluid == null) { + // The fluid is not guaranteed to exist. + // These fluids are non-GT fluids, so the mod may not be present. + if (isStackAlreadySet) { + throw new RuntimeException( + "Cell item for fluid " + fluidName + + " has already been created, but the fluid doesn't exist during postload"); + } else { + // fluid doesn't exist and this item has not been referenced + return; + } + } + + FluidStack fluidStack = new FluidStack(fluid, cellType.capacity); + + ItemStack emptyCell = ItemList.Cell_Empty.get(1L); + FluidContainerRegistry + .registerFluidContainer(new FluidContainerRegistry.FluidContainerData(fluidStack, aCell.mStack, emptyCell)); + + GT_LanguageManager.addStringLocalization( + getUnlocalizedName(aCell.mStack) + ".name", + cellType.prefix.mLocalizedMaterialPre + fluid.getLocalizedName(fluidStack) + + cellType.prefix.mLocalizedMaterialPost); + + int color = fluid.getColor(); + short[] rgba = GT_Util.getRGBaArray(color); + + registeredFluidDataMap.put(id, new RegisteredFluidData(rgba, iconContainerMap.get(cellType))); + } + + private void registerOreDict() { + // The GregTech ore dictionary requires an entry in the Materials enum, and since the whole + // point of this class is to add cell items for non-GregTech fluids, the vast majority of + // cell items won't have an associated material. So only a rare few cell items will need to + // be registered. + + // Register IC2 steam cell and Railcraft steam cell as synonyms. + // There is no steam material, so we'll use Water.cellMolten instead. + GT_OreDictUnificator.add(OrePrefixes.cellMolten, Materials.Water, GT_ModHandler.getIC2Item("steamCell", 1L)); + GT_OreDictUnificator.add(OrePrefixes.cellMolten, Materials.Water, FluidCell.STEAM.getNoCopy()); + } + + @Override + public short[] getRGBa(ItemStack aStack) { + RegisteredFluidData fluidData = registeredFluidDataMap.get(aStack.getItemDamage()); + if (fluidData == null) { + return Materials._NULL.mRGBa; + } + + return fluidData.rgba; + } + + @Override + public ItemStack getContainerItem(ItemStack aStack) { + return ItemList.Cell_Empty.get(1L); + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item aItem, CreativeTabs aCreativeTab, List<ItemStack> aList) { + Arrays.stream(FluidCell.values()) + .filter(fluid -> FluidRegistry.getFluid(fluid.getFluidName()) != null) + .map(FluidCell::get) + .filter(Objects::nonNull) + .forEach(aList::add); + } + + @Override + public final IIcon getIconFromDamage(int aMetaData) { + IIconContainer iconContainer = getIconContainer(aMetaData); + if (iconContainer != null) { + return iconContainer.getIcon(); + } + return null; + } + + @Override + public IIconContainer getIconContainer(int aMetaData) { + RegisteredFluidData fluidData = registeredFluidDataMap.get(aMetaData); + if (fluidData == null) { + return null; + } + return fluidData.iconContainer; + } + + @Override + public int getItemStackLimit(ItemStack aStack) { + return 64; + } +} diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_99.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_99.java new file mode 100644 index 0000000000..08d6f23164 --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_99.java @@ -0,0 +1,214 @@ +package gregtech.common.items; + +import static gregtech.api.enums.GT_Values.M; +import static gregtech.api.enums.OrePrefixes.cellMolten; + +import java.util.BitSet; +import java.util.List; + +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; + +import com.google.common.collect.ImmutableList; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.SubTag; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.items.GT_MetaGenerated_Item; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_OreDictUnificator; + +public class GT_MetaGenerated_Item_99 extends GT_MetaGenerated_Item { + + public static GT_MetaGenerated_Item_99 INSTANCE; + + /** + * Ore prefixes appear in this list in the order in which they will be assigned ID blocks. + * + * <p> + * In order to avoid breaking existing worlds, the entries in this list must not be re-ordered! The only safe + * modification that can be made to this list is adding new entries to the end. + */ + private static final ImmutableList<OrePrefixes> CRACKED_CELL_TYPES = ImmutableList.of( + OrePrefixes.cellHydroCracked1, + OrePrefixes.cellHydroCracked2, + OrePrefixes.cellHydroCracked3, + OrePrefixes.cellSteamCracked1, + OrePrefixes.cellSteamCracked2, + OrePrefixes.cellSteamCracked3); + + private static final int NUM_CRACKED_CELL_TYPES = CRACKED_CELL_TYPES.size(); + + /** + * Assignment of metadata IDs: 0 - 999: Molten cells 10_000 - 15_999: Cracked fluid cells (# IDs used is + * NUM_CRACKED_CELL_TYPES * 1_000; update this if you add any) + */ + private final BitSet enabled = new BitSet(); + + public GT_MetaGenerated_Item_99() { + super("metaitem.99", (short) (10_000 + NUM_CRACKED_CELL_TYPES * 1_000), (short) 0); + + INSTANCE = this; + + for (Materials tMaterial : GregTech_API.sGeneratedMaterials) { + if (tMaterial == null || tMaterial.mMetaItemSubID < 0 || tMaterial.mMetaItemSubID >= 1_000) { + continue; + } + + if ((tMaterial.contains(SubTag.SMELTING_TO_FLUID)) && (!tMaterial.contains(SubTag.NO_SMELTING)) + && !tMaterial.contains(SubTag.SMELTING_TO_GEM)) { + registerMolten(tMaterial, tMaterial.mMetaItemSubID); + if (tMaterial.mSmeltInto != tMaterial && tMaterial.mSmeltInto.mMetaItemSubID >= 0 + && tMaterial.mSmeltInto.mMetaItemSubID < 1_000) { + registerMolten(tMaterial.mSmeltInto, tMaterial.mSmeltInto.mMetaItemSubID); + } + } + + if (tMaterial.canBeCracked()) { + registerCracked(tMaterial, tMaterial.mMetaItemSubID); + } + } + + // We're not going to use these BitSets, so clear them to save memory. + mEnabledItems.clear(); + mVisibleItems.clear(); + } + + private void registerMolten(Materials tMaterial, int i) { + ItemStack tStack = new ItemStack(this, 1, i); + enabled.set(i); + + GT_LanguageManager.addStringLocalization( + getUnlocalizedName(tStack) + ".name", + cellMolten.getDefaultLocalNameFormatForItem(tMaterial)); + GT_LanguageManager.addStringLocalization( + getUnlocalizedName(tStack) + ".tooltip", + tMaterial.getToolTip(cellMolten.mMaterialAmount / M)); + + if (cellMolten.mIsUnificatable) { + GT_OreDictUnificator.set(cellMolten, tMaterial, tStack); + } else { + GT_OreDictUnificator.registerOre(cellMolten.get(tMaterial), tStack); + } + } + + private void registerCracked(Materials tMaterial, int i) { + int offset = 10_000; + for (OrePrefixes prefix : CRACKED_CELL_TYPES) { + ItemStack tStack = new ItemStack(this, 1, offset + i); + enabled.set(offset + i); + + GT_LanguageManager.addStringLocalization( + getUnlocalizedName(tStack) + ".name", + prefix.getDefaultLocalNameFormatForItem(tMaterial)); + GT_LanguageManager.addStringLocalization( + getUnlocalizedName(tStack) + ".tooltip", + tMaterial.getToolTip(prefix.mMaterialAmount / M)); + + if (prefix.mIsUnificatable) { + GT_OreDictUnificator.set(prefix, tMaterial, tStack); + } else { + GT_OreDictUnificator.registerOre(prefix.get(tMaterial), tStack); + } + + offset += 1_000; + } + } + + /** Returns null for item damage out of bounds. */ + private Materials getMaterial(int damage) { + if (damage < 0) { + return null; + } + return GregTech_API.sGeneratedMaterials[damage % 1_000]; + } + + /** Returns null for item damage out of bounds. */ + private OrePrefixes getOrePrefix(int damage) { + if (damage < 0) { + return null; + } else if (damage < 1_000) { + return cellMolten; + } else if (damage >= 10_000 && damage < 10_000 + (NUM_CRACKED_CELL_TYPES * 1_000)) { + return CRACKED_CELL_TYPES.get((damage / 1_000) - 10); + } + return null; + } + + @Override + public short[] getRGBa(ItemStack aStack) { + OrePrefixes prefix = getOrePrefix(aStack.getItemDamage()); + Materials material = getMaterial(aStack.getItemDamage()); + if (material == null) { + material = Materials._NULL; + } + + if (prefix == cellMolten) { + return material.mMoltenRGBa; + } else { + return material.mRGBa; + } + } + + @Override + public String getItemStackDisplayName(ItemStack aStack) { + String aName = super.getItemStackDisplayName(aStack); + Materials material = getMaterial(aStack.getItemDamage()); + if (material != null) { + return material.getLocalizedNameForItem(aName); + } + return aName; + } + + @Override + public ItemStack getContainerItem(ItemStack aStack) { + OrePrefixes prefix = getOrePrefix(aStack.getItemDamage()); + if (prefix != null) { + return prefix.mContainerItem; + } + return null; + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item aItem, CreativeTabs aCreativeTab, List<ItemStack> aList) { + enabled.stream() + .mapToObj(i -> new ItemStack(this, 1, i)) + .forEach(aList::add); + } + + @Override + public final IIcon getIconFromDamage(int aMetaData) { + IIconContainer iconContainer = getIconContainer(aMetaData); + if (iconContainer != null) { + return iconContainer.getIcon(); + } + return null; + } + + @Override + public IIconContainer getIconContainer(int aMetaData) { + Materials material = getMaterial(aMetaData); + OrePrefixes prefix = getOrePrefix(aMetaData); + if (material != null && prefix != null) { + return material.mIconSet.mTextures[prefix.mTextureIndex]; + } + return null; + } + + @Override + public int getItemStackLimit(ItemStack aStack) { + OrePrefixes prefix = getOrePrefix(aStack.getItemDamage()); + if (prefix != null) { + return prefix.mDefaultStackSize; + } else { + return 64; + } + } +} diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Tool_01.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Tool_01.java new file mode 100644 index 0000000000..309507f2a9 --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Tool_01.java @@ -0,0 +1,824 @@ +package gregtech.common.items; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TC_Aspects; +import gregtech.api.enums.ToolDictNames; +import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.common.tools.GT_Tool_Axe; +import gregtech.common.tools.GT_Tool_BranchCutter; +import gregtech.common.tools.GT_Tool_ButcheryKnife; +import gregtech.common.tools.GT_Tool_BuzzSaw; +import gregtech.common.tools.GT_Tool_Chainsaw_HV; +import gregtech.common.tools.GT_Tool_Chainsaw_LV; +import gregtech.common.tools.GT_Tool_Chainsaw_MV; +import gregtech.common.tools.GT_Tool_Crowbar; +import gregtech.common.tools.GT_Tool_Drill_HV; +import gregtech.common.tools.GT_Tool_Drill_LV; +import gregtech.common.tools.GT_Tool_Drill_MV; +import gregtech.common.tools.GT_Tool_File; +import gregtech.common.tools.GT_Tool_HardHammer; +import gregtech.common.tools.GT_Tool_Hoe; +import gregtech.common.tools.GT_Tool_JackHammer; +import gregtech.common.tools.GT_Tool_Knife; +import gregtech.common.tools.GT_Tool_Mortar; +import gregtech.common.tools.GT_Tool_Pickaxe; +import gregtech.common.tools.GT_Tool_Plow; +import gregtech.common.tools.GT_Tool_Plunger; +import gregtech.common.tools.GT_Tool_RollingPin; +import gregtech.common.tools.GT_Tool_Saw; +import gregtech.common.tools.GT_Tool_Scoop; +import gregtech.common.tools.GT_Tool_Screwdriver; +import gregtech.common.tools.GT_Tool_Screwdriver_LV; +import gregtech.common.tools.GT_Tool_Sense; +import gregtech.common.tools.GT_Tool_Shovel; +import gregtech.common.tools.GT_Tool_SoftHammer; +import gregtech.common.tools.GT_Tool_Soldering_Iron; +import gregtech.common.tools.GT_Tool_Sword; +import gregtech.common.tools.GT_Tool_Turbine_Huge; +import gregtech.common.tools.GT_Tool_Turbine_Large; +import gregtech.common.tools.GT_Tool_Turbine_Normal; +import gregtech.common.tools.GT_Tool_Turbine_Small; +import gregtech.common.tools.GT_Tool_UniversalSpade; +import gregtech.common.tools.GT_Tool_WireCutter; +import gregtech.common.tools.GT_Tool_Wrench; +import gregtech.common.tools.GT_Tool_Wrench_HV; +import gregtech.common.tools.GT_Tool_Wrench_LV; +import gregtech.common.tools.GT_Tool_Wrench_MV; +import gregtech.common.tools.pocket.GT_Tool_Pocket_BranchCutter; +import gregtech.common.tools.pocket.GT_Tool_Pocket_File; +import gregtech.common.tools.pocket.GT_Tool_Pocket_Knife; +import gregtech.common.tools.pocket.GT_Tool_Pocket_Multitool; +import gregtech.common.tools.pocket.GT_Tool_Pocket_Saw; +import gregtech.common.tools.pocket.GT_Tool_Pocket_Screwdriver; +import gregtech.common.tools.pocket.GT_Tool_Pocket_WireCutter; + +public class GT_MetaGenerated_Tool_01 extends GT_MetaGenerated_Tool { + + public static final short SWORD = 0; + public static final short PICKAXE = 2; + public static final short SHOVEL = 4; + public static final short AXE = 6; + public static final short HOE = 8; + public static final short SAW = 10; + public static final short HARDHAMMER = 12; + public static final short SOFTMALLET = 14; + + @Deprecated + public static final short SOFTHAMMER = SOFTMALLET; + + public static final short WRENCH = 16; + public static final short FILE = 18; + public static final short CROWBAR = 20; + public static final short SCREWDRIVER = 22; + public static final short MORTAR = 24; + public static final short WIRECUTTER = 26; + public static final short SCOOP = 28; + public static final short BRANCHCUTTER = 30; + public static final short UNIVERSALSPADE = 32; + public static final short KNIFE = 34; + public static final short BUTCHERYKNIFE = 36; + + @Deprecated + public static final short SICKLE = 38; + + public static final short SENSE = 40; + public static final short PLOW = 42; + public static final short PLUNGER = 44; + public static final short ROLLING_PIN = 46; + public static final short DRILL_LV = 100; + public static final short DRILL_MV = 102; + public static final short DRILL_HV = 104; + public static final short CHAINSAW_LV = 110; + public static final short CHAINSAW_MV = 112; + public static final short CHAINSAW_HV = 114; + public static final short WRENCH_LV = 120; + public static final short WRENCH_MV = 122; + public static final short WRENCH_HV = 124; + public static final short JACKHAMMER = 130; + public static final short BUZZSAW_LV = 140; + public static final short BUZZSAW_MV = 142; + public static final short BUZZSAW_HV = 144; + + @Deprecated + public static final short BUZZSAW = BUZZSAW_LV; + + public static final short SCREWDRIVER_LV = 150; + public static final short SCREWDRIVER_MV = 152; + public static final short SCREWDRIVER_HV = 154; + public static final short SOLDERING_IRON_LV = 160; + public static final short SOLDERING_IRON_MV = 162; + public static final short SOLDERING_IRON_HV = 164; + public static final short TURBINE_SMALL = 170; + public static final short TURBINE = 172; + public static final short TURBINE_LARGE = 174; + public static final short TURBINE_HUGE = 176; + + @Deprecated + public static final short TURBINE_BLADE = 178; + + public static final short POCKET_MULTITOOL = 180; + public static final short POCKET_BRANCHCUTTER = 182; + public static final short POCKET_FILE = 184; + public static final short POCKET_KNIFE = 186; + public static final short POCKET_SAW = 188; + public static final short POCKET_SCREWDRIVER = 190; + public static final short POCKET_WIRECUTTER = 192; + + public static GT_MetaGenerated_Tool_01 INSTANCE; + + public GT_MetaGenerated_Tool_01() { + super("metatool.01"); + INSTANCE = this; + addTool( + SWORD, + "Sword", + "", + new GT_Tool_Sword(), + ToolDictNames.craftingToolSword, + ToolDictNames.craftingToolBlade, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 4L)); + addTool( + PICKAXE, + "Pickaxe", + "", + new GT_Tool_Pickaxe(), + ToolDictNames.craftingToolPickaxe, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERFODIO, 4L)); + addTool( + SHOVEL, + "Shovel", + "", + new GT_Tool_Shovel(), + ToolDictNames.craftingToolShovel, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERFODIO, 4L)); + addTool( + AXE, + "Axe", + "", + new GT_Tool_Axe(), + ToolDictNames.craftingToolAxe, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 2L)); + addTool( + HOE, + "Hoe", + "", + new GT_Tool_Hoe(), + ToolDictNames.craftingToolHoe, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MESSIS, 4L)); + addTool( + SAW, + "Saw", + "Can also harvest Ice", + new GT_Tool_Saw(), + ToolDictNames.craftingToolSaw, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 2L)); + GregTech_API.registerTool( + addTool( + HARDHAMMER, + "Hammer", + "Crushes Ores instead of harvesting them", + new GT_Tool_HardHammer(), + ToolDictNames.craftingToolHardHammer, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sHardHammerList); + GregTech_API.registerTool( + addTool( + SOFTMALLET, + "Soft Mallet", + "", + new GT_Tool_SoftHammer(), + ToolDictNames.craftingToolSoftHammer, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LIMUS, 4L)), + GregTech_API.sSoftHammerList); + GregTech_API.registerTool( + addTool( + WRENCH, + "Wrench", + "Hold Leftclick to dismantle Machines", + new GT_Tool_Wrench(), + ToolDictNames.craftingToolWrench, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sWrenchList); + addTool( + FILE, + "File", + "", + new GT_Tool_File(), + ToolDictNames.craftingToolFile, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)); + GregTech_API.registerTool( + addTool( + CROWBAR, + "Crowbar", + "Dismounts Covers and Rotates Rails", + new GT_Tool_Crowbar(), + ToolDictNames.craftingToolCrowbar, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 2L)), + GregTech_API.sCrowbarList); + GregTech_API.registerTool( + addTool( + SCREWDRIVER, + "Screwdriver", + "Adjusts Covers and Machines", + new GT_Tool_Screwdriver(), + ToolDictNames.craftingToolScrewdriver, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sScrewdriverList); + addTool( + MORTAR, + "Mortar", + "", + new GT_Tool_Mortar(), + ToolDictNames.craftingToolMortar, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERDITIO, 2L)); + GregTech_API.registerTool( + addTool( + WIRECUTTER, + "Wire Cutter", + "", + new GT_Tool_WireCutter(), + ToolDictNames.craftingToolWireCutter, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sWireCutterList); + addTool( + SCOOP, + "Scoop", + "", + new GT_Tool_Scoop(), + ToolDictNames.craftingToolScoop, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.BESTIA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PANNUS, 2L)); + addTool( + BRANCHCUTTER, + "Branch Cutter", + "", + new GT_Tool_BranchCutter(), + ToolDictNames.craftingToolBranchCutter, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 2L)); + GregTech_API.registerTool( + addTool( + UNIVERSALSPADE, + "Universal Spade", + "", + new GT_Tool_UniversalSpade(), + ToolDictNames.craftingToolBlade, + ToolDictNames.craftingToolShovel, + ToolDictNames.craftingToolCrowbar, + ToolDictNames.craftingToolSaw, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METO, 1L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 1L)), + GregTech_API.sCrowbarList); + addTool( + KNIFE, + "Knife", + "", + new GT_Tool_Knife(), + ToolDictNames.craftingToolBlade, + ToolDictNames.craftingToolKnife, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.TELUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.CORPUS, 2L)); + addTool( + BUTCHERYKNIFE, + "Butchery Knife", + "Has a slow Attack Rate", + new GT_Tool_ButcheryKnife(), + ToolDictNames.craftingToolBlade, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.CORPUS, 4L)); + + addTool( + SENSE, + "Sense", + "Because a Scythe doesn't make Sense", + new GT_Tool_Sense(), + ToolDictNames.craftingToolBlade, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.HERBA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MORTUUS, 2L)); + addTool( + PLOW, + "Plow", + "Used to get rid of Snow", + new GT_Tool_Plow(), + ToolDictNames.craftingToolPlow, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.GELUM, 2L)); + addTool( + PLUNGER, + "Plunger", + "", + new GT_Tool_Plunger(), + ToolDictNames.craftingToolPlunger, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.VACUOS, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ITER, 2L)); + addTool( + ROLLING_PIN, + "Rolling Pin", + "", + new GT_Tool_RollingPin(), + ToolDictNames.craftingToolRollingPin, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.LIMUS, 4L)); + + addTool( + DRILL_LV, + "Drill (LV)", + "", + new GT_Tool_Drill_LV(), + ToolDictNames.craftingToolMiningDrill, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERFODIO, 4L)); + addTool( + DRILL_MV, + "Drill (MV)", + "", + new GT_Tool_Drill_MV(), + ToolDictNames.craftingToolMiningDrill, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERFODIO, 4L)); + addTool( + DRILL_HV, + "Drill (HV)", + "", + new GT_Tool_Drill_HV(), + ToolDictNames.craftingToolMiningDrill, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERFODIO, 4L)); + addTool( + CHAINSAW_LV, + "Chainsaw (LV)", + "Can also harvest Ice", + new GT_Tool_Chainsaw_LV(), + ToolDictNames.craftingToolSaw, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 2L)); + addTool( + CHAINSAW_MV, + "Chainsaw (MV)", + "Can also harvest Ice", + new GT_Tool_Chainsaw_MV(), + ToolDictNames.craftingToolSaw, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 2L)); + addTool( + CHAINSAW_HV, + "Chainsaw (HV)", + "Can also harvest Ice", + new GT_Tool_Chainsaw_HV(), + ToolDictNames.craftingToolSaw, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.METO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 2L)); + GregTech_API.registerTool( + addTool( + WRENCH_LV, + "Wrench (LV)", + "Hold Left Button to dismantle Machines", + new GT_Tool_Wrench_LV(), + ToolDictNames.craftingToolWrench, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sWrenchList); + GregTech_API.registerTool( + addTool( + WRENCH_MV, + "Wrench (MV)", + "Hold Left Button to dismantle Machines", + new GT_Tool_Wrench_MV(), + ToolDictNames.craftingToolWrench, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sWrenchList); + GregTech_API.registerTool( + addTool( + WRENCH_HV, + "Wrench (HV)", + "Hold Left Button to dismantle Machines", + new GT_Tool_Wrench_HV(), + ToolDictNames.craftingToolWrench, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 4L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sWrenchList); + GregTech_API.registerTool( + addTool( + JACKHAMMER, + "JackHammer (HV)", + "Breaks Rocks into pieces", + new GT_Tool_JackHammer(), + ToolDictNames.craftingToolJackHammer, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERFODIO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.PERDITIO, 2L)), + GregTech_API.sJackhammerList); + addTool( + BUZZSAW_LV, + "Buzzsaw (LV)", + "Not suitable for harvesting Blocks", + new GT_Tool_BuzzSaw(), + ToolDictNames.craftingToolSaw, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 2L)); + addTool( + BUZZSAW_MV, + "Buzzsaw (MV)", + "Not suitable for harvesting Blocks", + new GT_Tool_BuzzSaw(), + ToolDictNames.craftingToolSaw, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 2L)); + addTool( + BUZZSAW_HV, + "Buzzsaw (HV)", + "Not suitable for harvesting Blocks", + new GT_Tool_BuzzSaw(), + ToolDictNames.craftingToolSaw, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ARBOR, 2L)); + GregTech_API.registerTool( + addTool( + SCREWDRIVER_LV, + "Screwdriver (LV)", + "Adjusts Covers and Machines", + new GT_Tool_Screwdriver_LV(), + ToolDictNames.craftingToolScrewdriver, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sScrewdriverList); + GregTech_API.registerTool( + addTool( + SCREWDRIVER_MV, + "Screwdriver (MV)", + "Adjusts Covers and Machines", + new GT_Tool_Screwdriver_LV(), + ToolDictNames.craftingToolScrewdriver, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sScrewdriverList); + GregTech_API.registerTool( + addTool( + SCREWDRIVER_HV, + "Screwdriver (HV)", + "Adjusts Covers and Machines", + new GT_Tool_Screwdriver_LV(), + ToolDictNames.craftingToolScrewdriver, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sScrewdriverList); + GregTech_API.registerTool( + addTool( + SOLDERING_IRON_LV, + "Soldering Iron (LV)", + "Fixes burned out Circuits. Needs soldering materials in inventory.", + new GT_Tool_Soldering_Iron(), + ToolDictNames.craftingToolSolderingIron, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sSolderingToolList); + GregTech_API.registerTool( + addTool( + SOLDERING_IRON_MV, + "Soldering Iron (MV)", + "Fixes burned out Circuits. Needs soldering materials in inventory.", + new GT_Tool_Soldering_Iron(), + ToolDictNames.craftingToolSolderingIron, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sSolderingToolList); + GregTech_API.registerTool( + addTool( + SOLDERING_IRON_HV, + "Soldering Iron (HV)", + "Fixes burned out Circuits. Needs soldering materials in inventory.", + new GT_Tool_Soldering_Iron(), + ToolDictNames.craftingToolSolderingIron, + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L)), + GregTech_API.sSolderingToolList); + + addTool(TURBINE_SMALL, "Small Turbine", "Turbine Rotors for your power station", new GT_Tool_Turbine_Small()); + addTool(TURBINE, "Turbine", "Turbine Rotors for your power station", new GT_Tool_Turbine_Normal()); + addTool(TURBINE_LARGE, "Large Turbine", "Turbine Rotors for your power station", new GT_Tool_Turbine_Large()); + addTool(TURBINE_HUGE, "Huge Turbine", "Turbine Rotors for your power station", new GT_Tool_Turbine_Huge()); + + addTool( + POCKET_MULTITOOL, + "Pocket Multitool", + "6 useful Tools in one!", + new GT_Tool_Pocket_Multitool(POCKET_KNIFE), + null, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 6), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 3), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 3)); + addTool( + POCKET_KNIFE, + "Pocket Multitool (Knife)", + "", + new GT_Tool_Pocket_Knife(POCKET_SAW), + ToolDictNames.craftingToolKnife, + ToolDictNames.craftingToolBlade, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 6), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 3), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 3)); + addTool( + POCKET_SAW, + "Pocket Multitool (Saw)", + "Can also harvest Ice", + new GT_Tool_Pocket_Saw(POCKET_FILE), + ToolDictNames.craftingToolSaw, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 6), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 3), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 3)); + addTool( + POCKET_FILE, + "Pocket Multitool (File)", + "", + new GT_Tool_Pocket_File(POCKET_SCREWDRIVER), + ToolDictNames.craftingToolFile, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 6), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 3), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 3)); + GregTech_API.registerTool( + addTool( + POCKET_SCREWDRIVER, + "Pocket Multitool (Screwdriver)", + "Adjusts Covers and Machines", + new GT_Tool_Pocket_Screwdriver(POCKET_WIRECUTTER), + ToolDictNames.craftingToolScrewdriver, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 6), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 3), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 3)), + GregTech_API.sScrewdriverList); + GregTech_API.registerTool( + addTool( + POCKET_WIRECUTTER, + "Pocket Multitool (Wire Cutter)", + "", + new GT_Tool_Pocket_WireCutter(POCKET_BRANCHCUTTER), + ToolDictNames.craftingToolWireCutter, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 6), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 3), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 3)), + GregTech_API.sWireCutterList); + addTool( + POCKET_BRANCHCUTTER, + "Pocket Multitool (Branch Cutter)", + "", + new GT_Tool_Pocket_BranchCutter(POCKET_MULTITOOL), + ToolDictNames.craftingToolBranchCutter, + new TC_Aspects.TC_AspectStack(TC_Aspects.INSTRUMENTUM, 6), + new TC_Aspects.TC_AspectStack(TC_Aspects.FABRICO, 3), + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 3)); + + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.Flint, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', new ItemStack(Items.flint, 1), 'S', OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.Bronze, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.Bronze), 'S', OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.Iron, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.Iron), 'S', OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.Steel, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.Steel), 'S', OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.WroughtIron, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.WroughtIron), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.RedSteel, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.RedSteel), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.BlueSteel, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.BlueSteel), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.BlackSteel, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.BlackSteel), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.DamascusSteel, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.DamascusSteel), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.Thaumium, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.Thaumium), 'S', + OrePrefixes.stone }); + + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(ROLLING_PIN, 1, Materials.Wood, Materials.Wood, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " S", " I ", "S f", 'I', OrePrefixes.plank.get(Materials.Wood), 'S', + OrePrefixes.stick.get(Materials.Wood) }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(ROLLING_PIN, 1, Materials.Plastic, Materials.Plastic, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " S", " I ", "S f", 'I', OrePrefixes.ingot.get(Materials.Plastic), 'S', + OrePrefixes.stick.get(Materials.Plastic) }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(ROLLING_PIN, 1, Materials.Aluminium, Materials.Aluminium, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " S", " I ", "S f", 'I', OrePrefixes.ingot.get(Materials.Aluminium), 'S', + OrePrefixes.stick.get(Materials.Aluminium) }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(ROLLING_PIN, 1, Materials.StainlessSteel, Materials.StainlessSteel, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " S", " I ", "S f", 'I', OrePrefixes.ingot.get(Materials.StainlessSteel), 'S', + OrePrefixes.stick.get(Materials.StainlessSteel) }); + + if (!GregTech_API.sSpecialFile.get(ConfigCategories.general, "DisableFlintTools", false)) { + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(SWORD, 1, Materials.Flint, Materials.Wood, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { "F", "F", "S", 'S', OrePrefixes.stick.get(Materials.Wood), 'F', + new ItemStack(Items.flint, 1) }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(PICKAXE, 1, Materials.Flint, Materials.Wood, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { "FFF", " S ", " S ", 'S', OrePrefixes.stick.get(Materials.Wood), 'F', + new ItemStack(Items.flint, 1) }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(SHOVEL, 1, Materials.Flint, Materials.Wood, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { "F", "S", "S", 'S', OrePrefixes.stick.get(Materials.Wood), 'F', + new ItemStack(Items.flint, 1) }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(AXE, 1, Materials.Flint, Materials.Wood, null), + GT_ModHandler.RecipeBits.MIRRORED | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { "FF", "FS", " S", 'S', OrePrefixes.stick.get(Materials.Wood), 'F', + new ItemStack(Items.flint, 1) }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(HOE, 1, Materials.Flint, Materials.Wood, null), + GT_ModHandler.RecipeBits.MIRRORED | GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { "FF", " S", " S", 'S', OrePrefixes.stick.get(Materials.Wood), 'F', + new ItemStack(Items.flint, 1) }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(KNIFE, 1, Materials.Flint, Materials.Wood, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { "F", "S", 'S', OrePrefixes.stick.get(Materials.Wood), 'F', + new ItemStack(Items.flint, 1) }); + + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.Flint, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', new ItemStack(Items.flint, 1), 'S', OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.Bronze, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.Bronze), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.Iron, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.Iron), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.Steel, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.Steel), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.WroughtIron, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.WroughtIron), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.RedSteel, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.RedSteel), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.BlueSteel, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.BlueSteel), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.BlackSteel, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.BlackSteel), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.DamascusSteel, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.DamascusSteel), 'S', + OrePrefixes.stone }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(MORTAR, 1, Materials.Thaumium, Materials.Stone, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " I ", "SIS", "SSS", 'I', OrePrefixes.ingot.get(Materials.Thaumium), 'S', + OrePrefixes.stone }); + + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(ROLLING_PIN, 1, Materials.Wood, Materials.Wood, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " S", " I ", "S f", 'I', OrePrefixes.plank.get(Materials.Wood), 'S', + OrePrefixes.stick.get(Materials.Wood) }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(ROLLING_PIN, 1, Materials.Plastic, Materials.Plastic, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " S", " I ", "S f", 'I', OrePrefixes.ingot.get(Materials.Plastic), 'S', + OrePrefixes.stick.get(Materials.Plastic) }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(ROLLING_PIN, 1, Materials.Aluminium, Materials.Aluminium, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " S", " I ", "S f", 'I', OrePrefixes.ingot.get(Materials.Aluminium), 'S', + OrePrefixes.stick.get(Materials.Aluminium) }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(ROLLING_PIN, 1, Materials.StainlessSteel, Materials.StainlessSteel, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " S", " I ", "S f", 'I', OrePrefixes.ingot.get(Materials.StainlessSteel), 'S', + OrePrefixes.stick.get(Materials.StainlessSteel) }); + GT_ModHandler.addCraftingRecipe( + INSTANCE.getToolWithStats(ROLLING_PIN, 1, Materials.IronWood, Materials.IronWood, null), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { " S", " I ", "S f", 'I', OrePrefixes.ingot.get(Materials.IronWood), 'S', + OrePrefixes.stick.get(Materials.IronWood) }); + + GT_ModHandler.addShapelessCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Coal, 1L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ToolDictNames.craftingToolMortar, new ItemStack(Items.coal, 1) }); + GT_ModHandler.addShapelessCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Clay, 1L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ToolDictNames.craftingToolMortar, new ItemStack(Blocks.clay, 1) }); + GT_ModHandler.addShapelessCraftingRecipe( + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Wheat, 1L), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ToolDictNames.craftingToolMortar, new ItemStack(Items.wheat, 1) }); + GT_ModHandler.addShapelessCraftingRecipe( + new ItemStack(Items.flint, 1), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ToolDictNames.craftingToolMortar, new ItemStack(Blocks.gravel, 1) }); + GT_ModHandler.addShapelessCraftingRecipe( + new ItemStack(Items.blaze_powder, 2), + GT_ModHandler.RecipeBits.NOT_REMOVABLE, + new Object[] { ToolDictNames.craftingToolMortar, new ItemStack(Items.blaze_rod, 1) }); + + } + } +} diff --git a/src/main/java/gregtech/common/items/GT_NeutronReflector_Item.java b/src/main/java/gregtech/common/items/GT_NeutronReflector_Item.java new file mode 100644 index 0000000000..b2fd104917 --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_NeutronReflector_Item.java @@ -0,0 +1,54 @@ +package gregtech.common.items; + +import net.minecraft.item.ItemStack; + +import gregtech.api.items.GT_Generic_Item; +import ic2.api.reactor.IReactor; +import ic2.api.reactor.IReactorComponent; + +public class GT_NeutronReflector_Item extends GT_Generic_Item implements IReactorComponent { + + public GT_NeutronReflector_Item(String aUnlocalized, String aEnglish, int aMaxDamage) { + super(aUnlocalized, aEnglish, "Undestructable"); + this.setMaxStackSize(64); + this.setMaxDamage(aMaxDamage); + } + + @Override + public boolean acceptUraniumPulse(IReactor reactor, ItemStack yourStack, ItemStack pulsingStack, int youX, int youY, + int pulseX, int pulseY, boolean heatrun) { + if (!heatrun) { + ((IReactorComponent) pulsingStack.getItem()) + .acceptUraniumPulse(reactor, pulsingStack, yourStack, pulseX, pulseY, youX, youY, heatrun); + } + return true; + } + + @Override + public boolean canStoreHeat(IReactor aReactor, ItemStack aStack, int x, int y) { + return false; + } + + @Override + public int getMaxHeat(IReactor aReactor, ItemStack aStack, int x, int y) { + return 0; + } + + @Override + public int getCurrentHeat(IReactor aReactor, ItemStack aStack, int x, int y) { + return 0; + } + + @Override + public float influenceExplosion(IReactor aReactor, ItemStack aStack) { + return -1.0F; + } + + @Override + public int alterHeat(IReactor aReactor, ItemStack aStack, int x, int y, int aHeat) { + return aHeat; + } + + @Override + public void processChamber(IReactor aReactor, ItemStack aStack, int x, int y, boolean aHeatRun) {} +} diff --git a/src/main/java/gregtech/common/items/GT_SensorCard_Item.java b/src/main/java/gregtech/common/items/GT_SensorCard_Item.java new file mode 100644 index 0000000000..67e5b24a70 --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_SensorCard_Item.java @@ -0,0 +1,111 @@ +package gregtech.common.items; + +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.UUID; + +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ChunkCoordinates; +import net.minecraft.world.World; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.interfaces.tileentity.IGregTechDeviceInformation; +import gregtech.api.items.GT_Generic_Item; +import gregtech.api.util.GT_LanguageManager; +import shedar.mods.ic2.nuclearcontrol.api.CardState; +import shedar.mods.ic2.nuclearcontrol.api.ICardWrapper; +import shedar.mods.ic2.nuclearcontrol.api.IPanelDataSource; +import shedar.mods.ic2.nuclearcontrol.api.IRemoteSensor; +import shedar.mods.ic2.nuclearcontrol.api.PanelSetting; +import shedar.mods.ic2.nuclearcontrol.api.PanelString; + +public class GT_SensorCard_Item extends GT_Generic_Item implements IRemoteSensor, IPanelDataSource { + + private static final UUID CARD_TYPE = new UUID(0L, 41L); + + private int strCount; + + public GT_SensorCard_Item(String aUnlocalized, String aEnglish) { + super(aUnlocalized, aEnglish, "Insert into Display Panel"); + setMaxStackSize(1); + } + + @Override + public void addAdditionalToolTips(List<String> aList, ItemStack aStack, EntityPlayer aPlayer) { + super.addAdditionalToolTips(aList, aStack, aPlayer); + if (aStack != null) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + aList.add(transItem("014", "Missing Coordinates!")); + } else { + aList.add(transItem("015", "Device at:")); + aList.add( + String.format( + "x: %d, y: %d, z: %d", + tNBT.getInteger("x"), + tNBT.getInteger("y"), + tNBT.getInteger("z"))); + } + } + } + + @Override + public CardState update(TileEntity aPanel, ICardWrapper aCard, int aMaxRange) { + return update(aPanel.getWorldObj(), aCard, aMaxRange); + } + + @Override + public CardState update(World world, ICardWrapper aCard, int aMaxRange) { + ChunkCoordinates target = aCard.getTarget(); + + TileEntity tTileEntity = world.getTileEntity(target.posX, target.posY, target.posZ); + if (((tTileEntity instanceof IGregTechDeviceInformation)) + && (((IGregTechDeviceInformation) tTileEntity).isGivingInformation())) { + String[] tInfoData = ((IGregTechDeviceInformation) tTileEntity).getInfoData(); + for (int i = 0; i < tInfoData.length; i++) { + aCard.setString("mString" + i, tInfoData[i]); + } + aCard.setInt("mString", strCount = tInfoData.length); + return CardState.OK; + } + return CardState.NO_TARGET; + } + + @Override + public List<PanelString> getStringData(int aSettings, ICardWrapper aCard, boolean aLabels) { + List<PanelString> rList = new LinkedList<>(); + for (int i = 0; i < (strCount = aCard.getInt("mString")); i++) { + if ((aSettings & 1 << i) != 0) { + PanelString line = new PanelString(); + line.textLeft = GT_LanguageManager.getTranslation(aCard.getString("mString" + i), "\\\\"); + rList.add(line); + } + } + return rList; + } + + @Override + public List<PanelSetting> getSettingsList() { + List<PanelSetting> rList = new ArrayList<>(); + for (int i = 0; i < strCount; i++) { + rList.add(new PanelSetting(String.valueOf((i + 1)), 1 << i, getCardType())); + } + return rList; + } + + @Override + public UUID getCardType() { + return CARD_TYPE; + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item aItem, CreativeTabs aCreativeTab, List<ItemStack> aOutputSubItems) {} +} diff --git a/src/main/java/gregtech/common/items/GT_TierDrone.java b/src/main/java/gregtech/common/items/GT_TierDrone.java new file mode 100644 index 0000000000..58da852d0e --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_TierDrone.java @@ -0,0 +1,18 @@ +package gregtech.common.items; + +import gregtech.api.items.GT_Generic_Item; + +public class GT_TierDrone extends GT_Generic_Item { + + private final int level; + + public GT_TierDrone(String aUnlocalized, String aEnglish, String aEnglishTooltip, int level) { + super(aUnlocalized, aEnglish, aEnglishTooltip); + this.level = level; + this.setMaxStackSize(64); + } + + public int getLevel() { + return level; + } +} diff --git a/src/main/java/gregtech/common/items/GT_VolumetricFlask.java b/src/main/java/gregtech/common/items/GT_VolumetricFlask.java new file mode 100644 index 0000000000..50a88f4700 --- /dev/null +++ b/src/main/java/gregtech/common/items/GT_VolumetricFlask.java @@ -0,0 +1,361 @@ +package gregtech.common.items; + +import static gregtech.api.enums.Mods.GregTech; +import static gregtech.api.util.GT_Utility.formatNumbers; +import static ic2.core.util.LiquidUtil.drainContainerStack; +import static ic2.core.util.LiquidUtil.fillContainerStack; +import static ic2.core.util.LiquidUtil.placeFluid; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.util.MovingObjectPosition.MovingObjectType; +import net.minecraft.world.World; +import net.minecraftforge.common.util.FakePlayer; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidBlock; +import net.minecraftforge.fluids.IFluidContainerItem; +import net.minecraftforge.fluids.IFluidHandler; + +import com.gtnewhorizons.modularui.api.ModularUITextures; +import com.gtnewhorizons.modularui.api.math.Alignment; +import com.gtnewhorizons.modularui.api.math.Color; +import com.gtnewhorizons.modularui.api.screen.IItemWithModularUI; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.widget.TextWidget; +import com.gtnewhorizons.modularui.common.widget.VanillaButtonWidget; +import com.gtnewhorizons.modularui.common.widget.textfield.NumericWidget; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.gui.modularui.GT_UIInfos; +import gregtech.api.gui.modularui.GT_UITextures; +import gregtech.api.items.GT_Generic_Item; +import gregtech.api.util.GT_Utility; +import ic2.core.util.LiquidUtil; + +public class GT_VolumetricFlask extends GT_Generic_Item implements IFluidContainerItem, IItemWithModularUI { + + private final int maxCapacity; + private final String unlocalFlaskName; + + @SideOnly(Side.CLIENT) + public IIcon iconWindow; + + public GT_VolumetricFlask(String unlocalized, String english, int maxCapacity) { + super(unlocalized, english, null); + this.maxCapacity = maxCapacity; + unlocalFlaskName = unlocalized; + setMaxStackSize(64); + setNoRepair(); + } + + @Override + public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) { + if (!world.isRemote && isEmpty(stack) && getMovingObjectPositionFromPlayer(world, player, true) == null) + GT_UIInfos.openPlayerHeldItemUI(player); + return super.onItemRightClick(stack, world, player); + } + + @Override + public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int ordinalSide, + float xOffset, float yOffset, float zOffset) { + if (player instanceof FakePlayer) { + return false; + } + if (world.isRemote) return false; + if (interactWithTank(stack, player, world, x, y, z, ordinalSide)) { + return true; + } + MovingObjectPosition mop = getMovingObjectPositionFromPlayer(world, player, true); + if (mop == null) { + return false; + } + if (mop.typeOfHit == MovingObjectType.BLOCK) { + x = mop.blockX; + y = mop.blockY; + z = mop.blockZ; + if (!world.canMineBlock(player, x, y, z) || !player.canPlayerEdit(x, y, z, mop.sideHit, stack)) { + return false; + } + if (collectFluidBlock(stack, player, world, x, y, z)) { + return true; + } + ForgeDirection dir = ForgeDirection.VALID_DIRECTIONS[mop.sideHit]; + FluidStack fluidStack = drainContainerStack(stack, player, 1000, true); + if (placeFluid(fluidStack, world, x, y, z) + || (player.canPlayerEdit(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ, mop.sideHit, stack) + && placeFluid(fluidStack, world, x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ))) { + if (!player.capabilities.isCreativeMode) drainContainerStack(stack, player, 1000, false); + return true; + } + } + return false; + } + + public boolean isEmpty(ItemStack stack) { + return getFluid(stack) == null; + } + + public int getFreeSpace(ItemStack stack) { + int capacity = getCapacity(stack); + if (capacity > 0) { + FluidStack fluidStack = getFluid(stack); + return fluidStack == null ? capacity : capacity - fluidStack.amount; + } + return 0; + } + + public int getMaxCapacity() { + return this.maxCapacity; + } + + @Override + public int getCapacity(ItemStack stack) { + int capacity = 1000; + if (stack.hasTagCompound()) { + NBTTagCompound nbt = stack.getTagCompound(); + if (nbt.hasKey("Capacity", 3)) capacity = nbt.getInteger("Capacity"); + } + return Math.min(getMaxCapacity(), capacity); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aIconRegister) { + super.registerIcons(aIconRegister); + iconWindow = aIconRegister.registerIcon(GregTech.getResourcePath("gt." + unlocalFlaskName + ".window")); + } + + public void setCapacity(ItemStack stack, int capacity) { + capacity = Math.min(capacity, getMaxCapacity()); + NBTTagCompound nbt = stack.getTagCompound(); + if (nbt == null) { + stack.setTagCompound(nbt = new NBTTagCompound()); + } + nbt.setInteger("Capacity", capacity); + } + + @Override + public FluidStack getFluid(ItemStack stack) { + if (stack.hasTagCompound()) { + NBTTagCompound nbt = stack.getTagCompound(); + if (nbt.hasKey("Fluid", 10)) return FluidStack.loadFluidStackFromNBT(nbt.getCompoundTag("Fluid")); + } + return null; + } + + public void setFluid(ItemStack stack, FluidStack fluidStack) { + boolean removeFluid = (fluidStack == null) || (fluidStack.amount <= 0); + NBTTagCompound nbt = stack.getTagCompound(); + if (nbt == null) { + if (removeFluid) return; + stack.setTagCompound(nbt = new NBTTagCompound()); + } + if (removeFluid) { + nbt.removeTag("Fluid"); + if (nbt.hasNoTags()) { + stack.setTagCompound(null); + } + } else { + nbt.setTag("Fluid", fluidStack.writeToNBT(new NBTTagCompound())); + } + } + + @Override + public int fill(ItemStack stack, FluidStack resource, boolean doFill) { + if (stack.stackSize != 1) return 0; + if ((resource == null) || (resource.amount <= 0)) { + return 0; + } + FluidStack fluidStack = getFluid(stack); + if (fluidStack == null) { + fluidStack = new FluidStack(resource, 0); + } else if (!fluidStack.isFluidEqual(resource)) { + return 0; + } + int amount = Math.min(getCapacity(stack) - fluidStack.amount, resource.amount); + if ((doFill) && (amount > 0)) { + fluidStack.amount += amount; + setFluid(stack, fluidStack); + } + return amount; + } + + @Override + public FluidStack drain(ItemStack stack, int maxDrain, boolean doDrain) { + if (stack.stackSize != 1) return null; + FluidStack fluidStack = getFluid(stack); + if (fluidStack == null) return null; + maxDrain = Math.min(fluidStack.amount, maxDrain); + if (doDrain) { + fluidStack.amount -= maxDrain; + setFluid(stack, fluidStack); + } + return new FluidStack(fluidStack, maxDrain); + } + + @Override + protected void addAdditionalToolTips(List<String> info, ItemStack stack, EntityPlayer aPlayer) { + FluidStack fs = getFluid(stack); + if (fs != null) { + info.add(String.format("< %s, %s mB >", GT_Utility.getFluidName(fs, true), formatNumbers(fs.amount))); + } else { + info.add(String.format("< Empty, %s mB >", formatNumbers(getCapacity(stack)))); + } + info.add("Rightclick on air to set volume (only while empty)"); + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item item, CreativeTabs creativeTabs, List<ItemStack> itemList) { + itemList.add(new ItemStack(this)); + for (Fluid fluid : FluidRegistry.getRegisteredFluids() + .values()) { + if (fluid != null) { + ItemStack stack = new ItemStack(this); + setCapacity(stack, getMaxCapacity()); + fill(stack, new FluidStack(fluid, Integer.MAX_VALUE), true); + itemList.add(stack); + } + } + } + + private boolean interactWithTank(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, + int ordinalSide) { + if (world.isRemote) { + return false; + } + TileEntity te = world.getTileEntity(x, y, z); + if (!(te instanceof IFluidHandler handler)) { + return false; + } + ForgeDirection dir = ForgeDirection.getOrientation(ordinalSide); + FluidStack fs = this.getFluid(stack); + int capacity = getCapacity(stack); + if (fs != null && (!player.isSneaking() || fs.amount >= capacity)) { + int amount = handler.fill(dir, fs, false); + if (amount > 0) { + fs = LiquidUtil.drainContainerStack(stack, player, amount, false); + if (fs != null && fs.amount > 0) { + handler.fill(dir, fs, true); + } + } + } else { + int amount = fs == null ? capacity : capacity - fs.amount; + FluidStack input = handler.drain(dir, amount, false); + if (input != null && input.amount > 0) { + amount = LiquidUtil.fillContainerStack(stack, player, input, false); + if (amount > 0) { + handler.drain(dir, amount, true); + } + } + } + return true; + } + + private boolean collectFluidBlock(ItemStack stack, EntityPlayer player, World world, int x, int y, int z) { + Block block = world.getBlock(x, y, z); + if (block instanceof IFluidBlock liquid) { + if (liquid.canDrain(world, x, y, z)) { + FluidStack fluid = liquid.drain(world, x, y, z, false); + int amount = fillContainerStack(stack, player, fluid, true); + if (amount == fluid.amount) { + fillContainerStack(stack, player, fluid, false); + liquid.drain(world, x, y, z, true); + return true; + } + } + } else if (world.getBlockMetadata(x, y, z) == 0) { + FluidStack fluid = null; + if (block != Blocks.water && block != Blocks.flowing_water) { + if (block == Blocks.lava || block == Blocks.flowing_lava) { + fluid = new FluidStack(FluidRegistry.LAVA, 1000); + } + } else { + fluid = new FluidStack(FluidRegistry.WATER, 1000); + } + + if (fluid != null) { + int amount = fillContainerStack(stack, player, fluid, true); + if (amount == fluid.amount) { + fillContainerStack(stack, player, fluid, false); + world.setBlockToAir(x, y, z); + return true; + } + } + } + return false; + } + + @Override + public ModularWindow createWindow(UIBuildContext buildContext, ItemStack stack) { + if (!(stack.getItem() instanceof GT_VolumetricFlask)) return null; + return new VolumetricFlaskUIFactory(buildContext, stack).createWindow(); + } + + private class VolumetricFlaskUIFactory { + + private final UIBuildContext buildContext; + private int capacity; + private final int maxCapacity; + + public VolumetricFlaskUIFactory(UIBuildContext buildContext, ItemStack flask) { + this.buildContext = buildContext; + GT_VolumetricFlask flaskItem = (GT_VolumetricFlask) flask.getItem(); + this.capacity = flaskItem.getCapacity(flask); + this.maxCapacity = flaskItem.getMaxCapacity(); + } + + public ModularWindow createWindow() { + ModularWindow.Builder builder = ModularWindow.builder(150, 54); + builder.setBackground(ModularUITextures.VANILLA_BACKGROUND); + + NumericWidget capacityWidget = new NumericWidget(); + builder.widget( + capacityWidget.setGetter(() -> capacity) + .setSetter(value -> setCapacity(getCurrentItem(), capacity = (int) value)) + .setBounds(1, maxCapacity) + .setScrollValues(1, 144, 1000) + .setDefaultValue(capacity) + .setTextColor(Color.WHITE.dark(1)) + .setTextAlignment(Alignment.CenterLeft) + .setFocusOnGuiOpen(true) + .setBackground(GT_UITextures.BACKGROUND_TEXT_FIELD.withOffset(-1, -1, 2, 2)) + .setPos(8, 8) + .setSize(77, 12)) + .widget(new TextWidget("Capacity").setPos(88, 10)) + .widget( + new VanillaButtonWidget().setDisplayString("Confirm") + .setOnClick((clickData, widget) -> { + capacityWidget.onRemoveFocus(); + if (!widget.isClient()) { + widget.getWindow() + .tryClose(); + } + }) + .setPos(8, 26) + .setSize(48, 20)); + + return builder.build(); + } + + private ItemStack getCurrentItem() { + return buildContext.getPlayer().inventory.getCurrentItem(); + } + } +} diff --git a/src/main/java/gregtech/common/items/ItemComb.java b/src/main/java/gregtech/common/items/ItemComb.java new file mode 100644 index 0000000000..8fd37fd0d9 --- /dev/null +++ b/src/main/java/gregtech/common/items/ItemComb.java @@ -0,0 +1,1908 @@ +package gregtech.common.items; + +import static gregtech.api.enums.GT_Values.L; +import static gregtech.api.enums.GT_Values.NF; +import static gregtech.api.enums.GT_Values.NI; +import static gregtech.api.enums.GT_Values.V; +import static gregtech.api.enums.Mods.AE2FluidCraft; +import static gregtech.api.enums.Mods.ExtraUtilities; +import static gregtech.api.enums.Mods.GalaxySpace; +import static gregtech.api.enums.Mods.GregTech; +import static gregtech.api.enums.Mods.MagicBees; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.enums.Mods.Thaumcraft; +import static gregtech.api.enums.Mods.ThaumicBases; +import static gregtech.api.recipe.RecipeMaps.autoclaveRecipes; +import static gregtech.api.recipe.RecipeMaps.centrifugeRecipes; +import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; +import static gregtech.api.util.GT_RecipeConstants.CLEANROOM; +import static gregtech.api.util.GT_RecipeConstants.UniversalChemical; + +import java.util.Arrays; +import java.util.List; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.IIcon; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableMap.Builder; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import forestry.api.core.Tabs; +import forestry.api.recipes.RecipeManagers; +import gregtech.GT_Mod; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.interfaces.IGT_ItemWithMaterialRenderer; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_RecipeBuilder; +import gregtech.api.util.GT_Utility; +import gregtech.common.render.items.GT_GeneratedMaterial_Renderer; +import gregtech.loaders.misc.GT_Bees; + +public class ItemComb extends Item implements IGT_ItemWithMaterialRenderer { + + @SideOnly(Side.CLIENT) + private IIcon secondIcon; + + public ItemComb() { + super(); + this.setCreativeTab(Tabs.tabApiculture); + this.setHasSubtypes(true); + this.setUnlocalizedName("gt.comb"); + GameRegistry.registerItem(this, "gt.comb", GregTech.ID); + } + + public ItemStack getStackForType(CombType type) { + return new ItemStack(this, 1, type.getId()); + } + + public ItemStack getStackForType(CombType type, int count) { + return new ItemStack(this, count, type.getId()); + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item item, CreativeTabs tabs, List<ItemStack> list) { + for (CombType type : CombType.values()) { + if (type.showInList) { + list.add(this.getStackForType(type)); + } + } + } + + @Override + @SideOnly(Side.CLIENT) + public boolean requiresMultipleRenderPasses() { + return true; + } + + @Override + public int getRenderPasses(int meta) { + return 2; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister iconRegister) { + this.itemIcon = iconRegister.registerIcon("forestry:beeCombs.0"); + this.secondIcon = iconRegister.registerIcon("forestry:beeCombs.1"); + } + + @Override + public IIcon getIcon(ItemStack stack, int pass) { + return (pass == 0) ? itemIcon : secondIcon; + } + + @Override + @SideOnly(Side.CLIENT) + public int getColorFromItemStack(ItemStack stack, int pass) { + CombType type = CombType.valueOf(stack.getItemDamage()); + return type.getColours()[GT_Utility.clamp(pass, 0, 1)]; + } + + @Override + public String getItemStackDisplayName(ItemStack stack) { + return CombType.valueOf(stack.getItemDamage()) + .getName(); + } + + @Override + public void addInformation(ItemStack stack, EntityPlayer player, List<String> tooltip, boolean debugInfo) { + tooltip.add(EnumChatFormatting.DARK_RED + "Forestry can't process it"); + } + + @Override + public boolean shouldUseCustomRenderer(int aMetaData) { + return CombType.valueOf(aMetaData).material.renderer != null; + } + + @Override + public GT_GeneratedMaterial_Renderer getMaterialRenderer(int aMetaData) { + return CombType.valueOf(aMetaData).material.renderer; + } + + @Override + public boolean allowMaterialRenderer(int aMetaData) { + return true; + } + + @Override + public IIcon getIcon(int aMetaData, int pass) { + return (pass == 0) ? itemIcon : secondIcon; + } + + @Override + public IIcon getOverlayIcon(int aMetaData, int pass) { + return null; + } + + @Override + public short[] getRGBa(ItemStack aStack) { + return CombType.valueOf(aStack.getItemDamage()).material.mRGBa; + } + + public void initCombsRecipes() { + + // Organic + addProcessGT(CombType.LIGNIE, new Materials[] { Materials.Lignite }, Voltage.LV); + addProcessGT(CombType.COAL, new Materials[] { Materials.Coal }, Voltage.LV); + addCentrifugeToItemStack( + CombType.STICKY, + new ItemStack[] { ItemList.IC2_Resin.get(1), ItemList.IC2_Plantball.get(1), ItemList.FR_Wax.get(1) }, + new int[] { 50 * 100, 15 * 100, 50 * 100 }, + Voltage.ULV); + addProcessGT(CombType.OIL, new Materials[] { Materials.Oilsands }, Voltage.LV); + addProcessGT(CombType.APATITE, new Materials[] { Materials.Apatite }, Voltage.LV); + addCentrifugeToMaterial( + CombType.ASH, + new Materials[] { Materials.DarkAsh, Materials.Ash }, + new int[] { 50 * 100, 50 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 50 * 100); + addCentrifugeToItemStack( + CombType.PHOSPHORUS, + new ItemStack[] { Materials.Phosphorus.getDust(1), Materials.TricalciumPhosphate.getDust(2), + ItemList.FR_Wax.get(1) }, + new int[] { 100 * 100, 100 * 100, 100 * 100 }, + Voltage.HV); + addCentrifugeToItemStack( + CombType.MICA, + new ItemStack[] { Materials.Mica.getDust(2), ItemList.FR_Wax.get(1) }, + new int[] { 100 * 100, 75 * 100 }, + Voltage.HV); + if (GT_Mod.gregtechproxy.mNerfedCombs) { + addCentrifugeToItemStack( + CombType.LIGNIE, + new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Lignite, 1), + ItemList.FR_Wax.get(1) }, + new int[] { 90 * 100, 50 * 100 }, + Voltage.ULV); + addCentrifugeToItemStack( + CombType.COAL, + new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Coal, 1), + ItemList.FR_Wax.get(1) }, + new int[] { 5 * 100, 50 * 100 }, + Voltage.ULV); + addCentrifugeToItemStack( + CombType.OIL, + new ItemStack[] { ItemList.Crop_Drop_OilBerry.get(6), GT_Bees.drop.getStackForType(DropType.OIL), + ItemList.FR_Wax.get(1) }, + new int[] { 100 * 100, 100 * 100, 50 * 100 }, + Voltage.ULV); + } else { + addCentrifugeToItemStack( + CombType.LIGNIE, + new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Lignite, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Lignite, 1), ItemList.FR_Wax.get(1) }, + new int[] { 90 * 100, 100 * 100, 50 * 100 }, + Voltage.ULV); + addCentrifugeToItemStack( + CombType.COAL, + new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Coal, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Coal, 1), ItemList.FR_Wax.get(1) }, + new int[] { 5 * 100, 100 * 100, 50 * 100 }, + Voltage.ULV); + addCentrifugeToItemStack( + CombType.OIL, + new ItemStack[] { ItemList.Crop_Drop_OilBerry.get(6), GT_Bees.drop.getStackForType(DropType.OIL), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Oilsands, 1), ItemList.FR_Wax.get(1) }, + new int[] { 100 * 100, 100 * 100, 100 * 100, 50 * 100 }, + Voltage.ULV); + addCentrifugeToMaterial( + CombType.APATITE, + new Materials[] { Materials.Apatite, Materials.Phosphate }, + new int[] { 100 * 100, 80 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + } + // ic2 + addCentrifugeToItemStack( + CombType.COOLANT, + new ItemStack[] { GT_Bees.drop.getStackForType(DropType.COOLANT), ItemList.FR_Wax.get(1) }, + new int[] { 100 * 100, 100 * 100 }, + Voltage.HV, + 196); + addCentrifugeToItemStack( + CombType.ENERGY, + new ItemStack[] { GT_Bees.drop.getStackForType(DropType.HOT_COOLANT), ItemList.IC2_Energium_Dust.get(1L), + ItemList.FR_RefractoryWax.get(1) }, + new int[] { 20 * 100, 20 * 100, 50 * 100 }, + Voltage.HV, + 196); + addCentrifugeToItemStack( + CombType.LAPOTRON, + new ItemStack[] { GT_Bees.drop.getStackForType(DropType.LAPIS), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.LapotronDust", 1, 0), + GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 2) }, + new int[] { 20 * 100, 100 * 100, 40 * 100 }, + Voltage.HV, + 240); + addCentrifugeToMaterial( + CombType.PYROTHEUM, + new Materials[] { Materials.Blaze, Materials.Pyrotheum }, + new int[] { 25 * 100, 20 * 100 }, + new int[] {}, + Voltage.HV, + NI, + 30 * 100); + addCentrifugeToItemStack( + CombType.CRYOTHEUM, + new ItemStack[] { ItemList.FR_RefractoryWax.get(1), Materials.Cryotheum.getDust(1) }, + new int[] { 50 * 100, 100 * 100 }, + Voltage.MV); + addCentrifugeToItemStack( + CombType.BLIZZ, + new ItemStack[] { ItemList.FR_RefractoryWax.get(1), Materials.Blizz.getDust(1) }, + new int[] { 50 * 100, 100 * 100 }, + Voltage.MV); + // Alloy + addProcessGT(CombType.REDALLOY, new Materials[] { Materials.RedAlloy }, Voltage.LV); + addProcessGT(CombType.REDSTONEALLOY, new Materials[] { Materials.RedstoneAlloy }, Voltage.LV); + addProcessGT(CombType.CONDUCTIVEIRON, new Materials[] { Materials.ConductiveIron }, Voltage.MV); + addProcessGT(CombType.VIBRANTALLOY, new Materials[] { Materials.VibrantAlloy }, Voltage.HV); + addProcessGT(CombType.ENERGETICALLOY, new Materials[] { Materials.EnergeticAlloy }, Voltage.HV); + addProcessGT(CombType.ELECTRICALSTEEL, new Materials[] { Materials.ElectricalSteel }, Voltage.LV); + addProcessGT(CombType.DARKSTEEL, new Materials[] { Materials.DarkSteel }, Voltage.MV); + addProcessGT(CombType.PULSATINGIRON, new Materials[] { Materials.PulsatingIron }, Voltage.HV); + addProcessGT(CombType.STAINLESSSTEEL, new Materials[] { Materials.StainlessSteel }, Voltage.HV); + addProcessGT(CombType.BEDROCKIUM, new Materials[] { Materials.Bedrockium }, Voltage.EV); + addCentrifugeToItemStack( + CombType.ENDERIUM, + new ItemStack[] { ItemList.FR_RefractoryWax.get(1), + GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.EnderiumBase, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Enderium, 1) }, + new int[] { 50 * 100, 30 * 100, 50 * 100 }, + Voltage.HV); + if (GT_Mod.gregtechproxy.mNerfedCombs) { + addCentrifugeToMaterial( + CombType.REDALLOY, + new Materials[] { Materials.RedAlloy }, + new int[] { 100 * 100 }, + new int[] {}, + Voltage.ULV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.REDSTONEALLOY, + new Materials[] { Materials.RedstoneAlloy }, + new int[] { 100 * 100 }, + new int[] {}, + Voltage.ULV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.CONDUCTIVEIRON, + new Materials[] { Materials.ConductiveIron }, + new int[] { 90 * 100 }, + new int[] {}, + Voltage.MV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.VIBRANTALLOY, + new Materials[] { Materials.VibrantAlloy }, + new int[] { 70 * 100 }, + new int[] {}, + Voltage.HV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.ENERGETICALLOY, + new Materials[] { Materials.EnergeticAlloy }, + new int[] { 80 * 100 }, + new int[] {}, + Voltage.HV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.ELECTRICALSTEEL, + new Materials[] { Materials.ElectricalSteel }, + new int[] { 100 * 100 }, + new int[] {}, + Voltage.ULV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.DARKSTEEL, + new Materials[] { Materials.DarkSteel }, + new int[] { 100 * 100 }, + new int[] {}, + Voltage.MV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.PULSATINGIRON, + new Materials[] { Materials.PulsatingIron }, + new int[] { 80 * 100 }, + new int[] {}, + Voltage.HV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.STAINLESSSTEEL, + new Materials[] { Materials.StainlessSteel }, + new int[] { 50 * 100 }, + new int[] {}, + Voltage.HV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.BEDROCKIUM, + new Materials[] { Materials.Bedrockium }, + new int[] { 50 * 100 }, + new int[] {}, + Voltage.EV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + + } else { + addCentrifugeToMaterial( + CombType.REDALLOY, + new Materials[] { Materials.RedAlloy, Materials.Redstone, Materials.Copper }, + new int[] { 100 * 100, 75 * 100, 90 * 100 }, + new int[] {}, + Voltage.ULV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.REDSTONEALLOY, + new Materials[] { Materials.RedstoneAlloy, Materials.Redstone, Materials.Silicon, Materials.Coal }, + new int[] { 100 * 100, 90 * 100, 75 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.CONDUCTIVEIRON, + new Materials[] { Materials.ConductiveIron, Materials.Silver, Materials.Iron }, + new int[] { 90 * 100, 55 * 100, 65 * 100 }, + new int[] {}, + Voltage.MV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.VIBRANTALLOY, + new Materials[] { Materials.VibrantAlloy, Materials.Chrome }, + new int[] { 70 * 100, 50 * 100 }, + new int[] {}, + Voltage.HV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.ENERGETICALLOY, + new Materials[] { Materials.EnergeticAlloy, Materials.Gold }, + new int[] { 80 * 100, 60 * 100 }, + new int[] {}, + Voltage.HV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.ELECTRICALSTEEL, + new Materials[] { Materials.ElectricalSteel, Materials.Silicon, Materials.Coal }, + new int[] { 100 * 100, 75 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.DARKSTEEL, + new Materials[] { Materials.DarkSteel, Materials.Coal }, + new int[] { 100 * 100, 75 * 100 }, + new int[] {}, + Voltage.MV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.PULSATINGIRON, + new Materials[] { Materials.PulsatingIron, Materials.Iron }, + new int[] { 80 * 100, 75 * 100 }, + new int[] {}, + Voltage.HV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.STAINLESSSTEEL, + new Materials[] { Materials.StainlessSteel, Materials.Iron, Materials.Chrome, Materials.Manganese, + Materials.Nickel }, + new int[] { 50 * 100, 75 * 100, 55 * 100, 75 * 100, 75 * 100 }, + new int[] {}, + Voltage.HV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + addCentrifugeToMaterial( + CombType.BEDROCKIUM, + new Materials[] { Materials.Bedrockium }, + new int[] { 50 * 100 }, + new int[] {}, + Voltage.EV, + ItemList.FR_RefractoryWax.get(1), + 50 * 100); + } + // Thaumic + addProcessGT(CombType.THAUMIUMDUST, new Materials[] { Materials.Thaumium }, Voltage.MV); + addCentrifugeToItemStack( + CombType.THAUMIUMSHARD, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1, 1), + GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1, 2), + GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1, 3), + GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1, 4), + GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1, 5), + GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1, 6), + GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0) }, + new int[] { 20 * 100, 20 * 100, 20 * 100, 20 * 100, 20 * 100, 20 * 100, 50 * 100 }, + Voltage.ULV); + addProcessGT(CombType.AMBER, new Materials[] { Materials.Amber }, Voltage.LV); + addProcessGT(CombType.QUICKSILVER, new Materials[] { Materials.Cinnabar }, Voltage.LV); + addCentrifugeToItemStack( + CombType.SALISMUNDUS, + new ItemStack[] { GT_ModHandler.getModItem(Thaumcraft.ID, "ItemResource", 1, 14), + GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0) }, + new int[] { 100 * 100, 50 * 100 }, + Voltage.MV); + addCentrifugeToItemStack( + CombType.TAINTED, + new ItemStack[] { GT_ModHandler.getModItem(Thaumcraft.ID, "ItemResource", 1, 11), + GT_ModHandler.getModItem(Thaumcraft.ID, "ItemResource", 1, 12), + GT_ModHandler.getModItem(Thaumcraft.ID, "blockTaintFibres", 1, 0), + GT_ModHandler.getModItem(Thaumcraft.ID, "blockTaintFibres", 1, 1), + GT_ModHandler.getModItem(Thaumcraft.ID, "blockTaintFibres", 1, 2), + GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0) }, + new int[] { 15 * 100, 15 * 100, 15 * 100, 15 * 100, 15 * 100, 50 * 100 }, + Voltage.ULV); + addProcessGT(CombType.MITHRIL, new Materials[] { Materials.Mithril }, Voltage.HV); + addProcessGT(CombType.ASTRALSILVER, new Materials[] { Materials.AstralSilver }, Voltage.HV); + addCentrifugeToMaterial( + CombType.ASTRALSILVER, + new Materials[] { Materials.AstralSilver, Materials.Silver }, + new int[] { 20 * 100, (GT_Mod.gregtechproxy.mNerfedCombs ? 10 : 75) * 100 }, + new int[] {}, + Voltage.HV, + GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0), + 50 * 100); + addCentrifugeToItemStack( + CombType.THAUMINITE, + new ItemStack[] { GT_ModHandler.getModItem(ThaumicBases.ID, "resource", 1, 0), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Thaumium, 1), + GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0) }, + new int[] { 20 * 100, 10 * 100, 50 * 100 }, + Voltage.HV); + addProcessGT(CombType.SHADOWMETAL, new Materials[] { Materials.Shadow }, Voltage.HV); + addCentrifugeToMaterial( + CombType.SHADOWMETAL, + new Materials[] { Materials.Shadow, Materials.ShadowSteel }, + new int[] { (GT_Mod.gregtechproxy.mNerfedCombs ? 20 : 75) * 100, 10 * 100 }, + new int[] {}, + Voltage.HV, + GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0), + 50 * 100); + addProcessGT(CombType.DIVIDED, new Materials[] { Materials.Diamond }, Voltage.HV); + addCentrifugeToItemStack( + CombType.DIVIDED, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0), + GT_ModHandler.getModItem(ExtraUtilities.ID, "unstableingot", 1, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Iron, 1), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Diamond, 1) }, + new int[] { 50 * 100, 20 * 100, (GT_Mod.gregtechproxy.mNerfedCombs ? 10 : 75) * 100, + (GT_Mod.gregtechproxy.mNerfedCombs ? 5 : 55) * 100 }, + Voltage.HV); + addProcessGT(CombType.SPARKELING, new Materials[] { Materials.NetherStar }, Voltage.EV); + addCentrifugeToItemStack( + CombType.SPARKELING, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0), + GT_ModHandler.getModItem(MagicBees.ID, "miscResources", 2, 5), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.NetherStar, 1) }, + new int[] { 50 * 100, 10 * 100, (GT_Mod.gregtechproxy.mNerfedCombs ? 10 : 50) * 100 }, + Voltage.EV); + if (GT_Mod.gregtechproxy.mNerfedCombs) { + addCentrifugeToMaterial( + CombType.THAUMIUMDUST, + new Materials[] { Materials.Thaumium }, + new int[] { 100 * 100 }, + new int[] {}, + Voltage.MV, + GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0), + 50 * 100); + addCentrifugeToItemStack( + CombType.QUICKSILVER, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0), + GT_ModHandler.getModItem(Thaumcraft.ID, "ItemNugget", 1, 5) }, + new int[] { 50 * 100, 100 * 100 }, + Voltage.ULV); + } else { + addCentrifugeToMaterial( + CombType.THAUMIUMDUST, + new Materials[] { Materials.Thaumium, Materials.Iron }, + new int[] { 100 * 100, 75 * 100 }, + new int[] {}, + Voltage.MV, + GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0), + 50 * 100); + addCentrifugeToMaterial( + CombType.AMBER, + new Materials[] { Materials.Amber }, + new int[] { 100 * 100 }, + new int[] {}, + Voltage.ULV, + GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0), + 50 * 100); + addCentrifugeToItemStack( + CombType.QUICKSILVER, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0), + GT_ModHandler.getModItem(Thaumcraft.ID, "ItemNugget", 1, 5), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Cinnabar, 1) }, + new int[] { 50 * 100, 100 * 100, 85 * 100 }, + Voltage.ULV); + addCentrifugeToMaterial( + CombType.MITHRIL, + new Materials[] { Materials.Mithril, Materials.Platinum }, + new int[] { 75 * 100, 55 * 100 }, + new int[] {}, + Voltage.HV, + GT_ModHandler.getModItem(MagicBees.ID, "wax", 1, 0), + 50 * 100); + } + + // Gem Line + addProcessGT(CombType.STONE, new Materials[] { Materials.Soapstone }, Voltage.LV); + addProcessGT(CombType.CERTUS, new Materials[] { Materials.CertusQuartz }, Voltage.LV); + addProcessGT(CombType.FLUIX, new Materials[] { Materials.Fluix }, Voltage.LV); + addProcessGT(CombType.REDSTONE, new Materials[] { Materials.Redstone }, Voltage.LV); + addCentrifugeToMaterial( + CombType.RAREEARTH, + new Materials[] { Materials.RareEarth }, + new int[] { 100 * 100 }, + new int[] { 1 }, + Voltage.ULV, + NI, + 30 * 100); + addProcessGT(CombType.LAPIS, new Materials[] { Materials.Lapis }, Voltage.LV); + addProcessGT(CombType.RUBY, new Materials[] { Materials.Ruby }, Voltage.LV); + addProcessGT(CombType.REDGARNET, new Materials[] { Materials.GarnetRed }, Voltage.LV); + addProcessGT(CombType.YELLOWGARNET, new Materials[] { Materials.GarnetYellow }, Voltage.LV); + addProcessGT(CombType.SAPPHIRE, new Materials[] { Materials.Sapphire }, Voltage.LV); + addProcessGT(CombType.DIAMOND, new Materials[] { Materials.Diamond }, Voltage.LV); + addProcessGT(CombType.OLIVINE, new Materials[] { Materials.Olivine }, Voltage.LV); + addProcessGT(CombType.EMERALD, new Materials[] { Materials.Emerald }, Voltage.LV); + addProcessGT(CombType.FIRESTONE, new Materials[] { Materials.Firestone }, Voltage.LV); + addProcessGT(CombType.PYROPE, new Materials[] { Materials.Pyrope }, Voltage.LV); + addProcessGT(CombType.GROSSULAR, new Materials[] { Materials.Grossular }, Voltage.LV); + if (GT_Mod.gregtechproxy.mNerfedCombs) { + addCentrifugeToMaterial( + CombType.STONE, + new Materials[] { Materials.Stone, Materials.GraniteBlack, Materials.GraniteRed, Materials.Basalt, + Materials.Marble, Materials.Redrock }, + new int[] { 70 * 100, 50 * 100, 50 * 100, 50 * 100, 50 * 100, 50 * 100 }, + new int[] { 9, 9, 9, 9, 9, 9 }, + Voltage.ULV, + NI, + 50 * 100); + addCentrifugeToMaterial( + CombType.FLUIX, + new Materials[] { Materials.Fluix }, + new int[] { 25 * 100 }, + new int[] { 9 }, + Voltage.ULV, + NI, + 30 * 100); + } else { + addCentrifugeToMaterial( + CombType.STONE, + new Materials[] { Materials.Soapstone, Materials.Talc, Materials.Apatite, Materials.Phosphate, + Materials.TricalciumPhosphate }, + new int[] { 95 * 100, 90 * 100, 80 * 100, 75 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 50 * 100); + addCentrifugeToMaterial( + CombType.CERTUS, + new Materials[] { Materials.CertusQuartz, Materials.Quartzite, Materials.Barite }, + new int[] { 100 * 100, 80 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 50 * 100); + addCentrifugeToMaterial( + CombType.FLUIX, + new Materials[] { Materials.Fluix, Materials.Redstone, Materials.CertusQuartz, Materials.NetherQuartz }, + new int[] { 25 * 100, 90 * 100, 90 * 100, 90 * 100 }, + new int[] { 9, 1, 1, 1 }, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.REDSTONE, + new Materials[] { Materials.Redstone, Materials.Cinnabar }, + new int[] { 100 * 100, 80 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.LAPIS, + new Materials[] { Materials.Lapis, Materials.Sodalite, Materials.Lazurite, Materials.Calcite }, + new int[] { 100 * 100, 90 * 100, 90 * 100, 85 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.RUBY, + new Materials[] { Materials.Ruby, Materials.Redstone }, + new int[] { 100 * 100, 90 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.REDGARNET, + new Materials[] { Materials.GarnetRed, Materials.GarnetYellow }, + new int[] { 100 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.YELLOWGARNET, + new Materials[] { Materials.GarnetYellow, Materials.GarnetRed }, + new int[] { 100 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.SAPPHIRE, + new Materials[] { Materials.Sapphire, Materials.GreenSapphire, Materials.Almandine, Materials.Pyrope }, + new int[] { 100 * 100, 90 * 100, 90 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.DIAMOND, + new Materials[] { Materials.Diamond, Materials.Graphite }, + new int[] { 100 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.OLIVINE, + new Materials[] { Materials.Olivine, Materials.Bentonite, Materials.Magnesite, Materials.Glauconite }, + new int[] { 100 * 100, 90 * 100, 80 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.EMERALD, + new Materials[] { Materials.Emerald, Materials.Beryllium, Materials.Thorium }, + new int[] { 100 * 100, 85 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.FIRESTONE, + new Materials[] { Materials.Firestone }, + new int[] { 100 * 100 }, + new int[] {}, + Voltage.ULV, + ItemList.FR_RefractoryWax.get(1), + 30 * 100); + addCentrifugeToMaterial( + CombType.PYROPE, + new Materials[] { Materials.Pyrope, Materials.Aluminium, Materials.Magnesium, Materials.Silicon }, + new int[] { 100 * 100, 75 * 100, 80 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.GROSSULAR, + new Materials[] { Materials.Grossular, Materials.Aluminium, Materials.Silicon }, + new int[] { 100 * 100, 75 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + } + + // Metals Line + addProcessGT(CombType.SLAG, new Materials[] { Materials.Limestone }, Voltage.LV); + addProcessGT(CombType.COPPER, new Materials[] { Materials.Copper }, Voltage.LV); + addProcessGT(CombType.TIN, new Materials[] { Materials.Tin }, Voltage.LV); + addProcessGT(CombType.LEAD, new Materials[] { Materials.Lead }, Voltage.LV); + addProcessGT(CombType.INDIUM, new Materials[] { Materials.Indium }, Voltage.ZPM); + addProcessGT(CombType.NICKEL, new Materials[] { Materials.Nickel }, Voltage.LV); + addProcessGT(CombType.ZINC, new Materials[] { Materials.Zinc }, Voltage.LV); + addProcessGT(CombType.SILVER, new Materials[] { Materials.Silver }, Voltage.LV); + addProcessGT(CombType.CRYOLITE, new Materials[] { Materials.Cryolite }, Voltage.LV); + addProcessGT(CombType.GOLD, new Materials[] { Materials.Gold }, Voltage.LV); + addProcessGT(CombType.SULFUR, new Materials[] { Materials.Sulfur }, Voltage.LV); + addProcessGT(CombType.GALLIUM, new Materials[] { Materials.Gallium }, Voltage.LV); + addProcessGT(CombType.ARSENIC, new Materials[] { Materials.Arsenic }, Voltage.LV); + addProcessGT(CombType.IRON, new Materials[] { Materials.Iron }, Voltage.LV); + addProcessGT(CombType.STEEL, new Materials[] { Materials.Steel }, Voltage.LV); + if (GT_Mod.gregtechproxy.mNerfedCombs) { + addCentrifugeToMaterial( + CombType.SLAG, + new Materials[] { Materials.Stone, Materials.GraniteBlack, Materials.GraniteRed }, + new int[] { 50 * 100, 20 * 100, 20 * 100 }, + new int[] { 9, 9, 9 }, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.COPPER, + new Materials[] { Materials.Copper }, + new int[] { 70 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.TIN, + new Materials[] { Materials.Tin }, + new int[] { 60 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.LEAD, + new Materials[] { Materials.Lead }, + new int[] { 45 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.IRON, + new Materials[] { Materials.Iron }, + new int[] { 30 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.STEEL, + new Materials[] { Materials.Steel }, + new int[] { 40 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.SILVER, + new Materials[] { Materials.Silver }, + new int[] { 80 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.CRYOLITE, + new Materials[] { Materials.Cryolite }, + new int[] { 80 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.SULFUR, + new Materials[] { Materials.Sulfur }, + new int[] { 100 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + } else { + addCentrifugeToMaterial( + CombType.SLAG, + new Materials[] { Materials.Salt, Materials.RockSalt, Materials.Lepidolite, Materials.Spodumene, + Materials.Monazite }, + new int[] { 100 * 100, 100 * 100, 100 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.COPPER, + new Materials[] { Materials.Copper, Materials.Tetrahedrite, Materials.Chalcopyrite, Materials.Malachite, + Materials.Pyrite, Materials.Stibnite }, + new int[] { 100 * 100, 85 * 100, 95 * 100, 80 * 100, 75 * 100, 65 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.TIN, + new Materials[] { Materials.Tin, Materials.Cassiterite, Materials.CassiteriteSand }, + new int[] { 100 * 100, 85 * 100, 65 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.LEAD, + new Materials[] { Materials.Lead, Materials.Galena }, + new int[] { 100 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + + addCentrifugeToMaterial( + CombType.IRON, + new Materials[] { Materials.Iron, Materials.Magnetite, Materials.BrownLimonite, + Materials.YellowLimonite, Materials.VanadiumMagnetite, Materials.MeteoricIron }, + new int[] { 100 * 100, 90 * 100, 85 * 100, 85 * 100, 80 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.LEAD, + new Materials[] { Materials.Steel, Materials.Magnetite, Materials.VanadiumMagnetite, + Materials.Molybdenite, Materials.Molybdenum, Materials.MeteoricIron }, + new int[] { 100 * 100, 90 * 100, 80 * 100, 65 * 100, 65 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + + addCentrifugeToMaterial( + CombType.NICKEL, + new Materials[] { Materials.Nickel, Materials.Garnierite, Materials.Pentlandite, Materials.Cobaltite, + Materials.Wulfenite, Materials.Powellite }, + new int[] { 100 * 100, 85 * 100, 85 * 100, 80 * 100, 75 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.ZINC, + new Materials[] { Materials.Zinc, Materials.Sphalerite, Materials.Sulfur }, + new int[] { 100 * 100, 80 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.SILVER, + new Materials[] { Materials.Silver, Materials.Galena }, + new int[] { 100 * 100, 80 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.CRYOLITE, + new Materials[] { Materials.Cryolite, Materials.Silver }, + new int[] { 100 * 100, 80 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.GOLD, + new Materials[] { Materials.Gold }, + new int[] { 100 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.SULFUR, + new Materials[] { Materials.Sulfur, Materials.Pyrite, Materials.Sphalerite }, + new int[] { 100 * 100, 90 * 100, 80 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.GALLIUM, + new Materials[] { Materials.Gallium, Materials.Niobium }, + new int[] { 80 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.ARSENIC, + new Materials[] { Materials.Arsenic, Materials.Bismuth, Materials.Antimony }, + new int[] { 80 * 100, 70 * 100, 70 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + } + + // Rare Metals Line + addProcessGT(CombType.BAUXITE, new Materials[] { Materials.Bauxite }, Voltage.LV); + addProcessGT(CombType.ALUMINIUM, new Materials[] { Materials.Aluminium }, Voltage.LV); + addProcessGT(CombType.MANGANESE, new Materials[] { Materials.Manganese }, Voltage.LV); + addProcessGT(CombType.TITANIUM, new Materials[] { Materials.Titanium }, Voltage.EV); + addProcessGT(CombType.MAGNESIUM, new Materials[] { Materials.Magnesium }, Voltage.LV); + addProcessGT(CombType.CHROME, new Materials[] { Materials.Chrome }, Voltage.HV); + addProcessGT(CombType.TUNGSTEN, new Materials[] { Materials.Tungsten }, Voltage.IV); + addProcessGT(CombType.PLATINUM, new Materials[] { Materials.Platinum }, Voltage.HV); + addProcessGT(CombType.MOLYBDENUM, new Materials[] { Materials.Molybdenum }, Voltage.LV); + addProcessGT(CombType.IRIDIUM, new Materials[] { Materials.Iridium }, Voltage.IV); + addProcessGT(CombType.PALLADIUM, new Materials[] { Materials.Palladium }, Voltage.IV); + addProcessGT(CombType.OSMIUM, new Materials[] { Materials.Osmium }, Voltage.IV); + addProcessGT(CombType.LITHIUM, new Materials[] { Materials.Lithium }, Voltage.MV); + addProcessGT(CombType.ELECTROTINE, new Materials[] { Materials.Electrotine }, Voltage.MV); + addProcessGT(CombType.DRACONIC, new Materials[] { Materials.Draconium }, Voltage.IV); + addProcessGT(CombType.AWAKENEDDRACONIUM, new Materials[] { Materials.DraconiumAwakened }, Voltage.ZPM); + if (GT_Mod.gregtechproxy.mNerfedCombs) { + addCentrifugeToItemStack( + CombType.SALT, + new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Salt, 6), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.RockSalt, 6), ItemList.FR_Wax.get(1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Saltpeter, 6) }, + new int[] { 100 * 100, 100 * 100, 50 * 100, 25 * 100 }, + Voltage.MV, + 160); + } else { + addCentrifugeToMaterial( + CombType.BAUXITE, + new Materials[] { Materials.Bauxite, Materials.Aluminium }, + new int[] { 75 * 100, 55 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.ALUMINIUM, + new Materials[] { Materials.Aluminium, Materials.Bauxite }, + new int[] { 60 * 100, 80 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.MANGANESE, + new Materials[] { Materials.Manganese, Materials.Grossular, Materials.Spessartine, Materials.Pyrolusite, + Materials.Tantalite }, + new int[] { 30 * 100, 100 * 100, 100 * 100, 100 * 100, 100 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.TITANIUM, + new Materials[] { Materials.Titanium, Materials.Ilmenite, Materials.Bauxite, Materials.Rutile }, + new int[] { 90 * 100, 80 * 100, 75 * 100, 75 * 100 }, + new int[] {}, + Voltage.EV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.MAGNESIUM, + new Materials[] { Materials.Magnesium, Materials.Magnesite }, + new int[] { 100 * 100, 80 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.CHROME, + new Materials[] { Materials.Chrome, Materials.Ruby, Materials.Chromite, Materials.Redstone, + Materials.Neodymium, Materials.Bastnasite }, + new int[] { 50 * 100, 100 * 100, 50 * 100, 100 * 100, 80 * 100, 80 * 100 }, + new int[] {}, + Voltage.HV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.TUNGSTEN, + new Materials[] { Materials.Tungsten, Materials.Tungstate, Materials.Scheelite, Materials.Lithium }, + new int[] { 50 * 100, 80 * 100, 75 * 100, 75 * 100 }, + new int[] {}, + Voltage.IV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.PLATINUM, + new Materials[] { Materials.Platinum, Materials.Cooperite, Materials.Palladium }, + new int[] { 40 * 100, 40 * 100, 40 * 100 }, + new int[] {}, + Voltage.HV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.MOLYBDENUM, + new Materials[] { Materials.Molybdenum, Materials.Molybdenite, Materials.Powellite, + Materials.Wulfenite }, + new int[] { 100 * 100, 80 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.IRIDIUM, + new Materials[] { Materials.Iridium, Materials.Osmium }, + new int[] { 20 * 100, 15 * 100 }, + new int[] {}, + Voltage.IV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.OSMIUM, + new Materials[] { Materials.Osmium, Materials.Iridium }, + new int[] { 25 * 100, 15 * 100 }, + new int[] {}, + Voltage.IV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.LITHIUM, + new Materials[] { Materials.Lithium, Materials.Aluminium }, + new int[] { 85 * 100, 75 * 100 }, + new int[] {}, + Voltage.MV, + NI, + 30 * 100); + addCentrifugeToItemStack( + CombType.SALT, + new ItemStack[] { GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Salt, 6), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.RockSalt, 6), ItemList.FR_Wax.get(1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Saltpeter, 6) }, + new int[] { 100 * 100, 100 * 100, 50 * 100, 25 * 100 }, + Voltage.MV, + 160); + } + + // Radioactive Line + addProcessGT(CombType.ALMANDINE, new Materials[] { Materials.Almandine }, Voltage.LV); + addProcessGT(CombType.URANIUM, new Materials[] { Materials.Uranium }, Voltage.EV); + addProcessGT(CombType.PLUTONIUM, new Materials[] { Materials.Plutonium }, Voltage.EV); + addProcessGT(CombType.NAQUADAH, new Materials[] { Materials.Naquadah }, Voltage.IV); + addProcessGT(CombType.NAQUADRIA, new Materials[] { Materials.Naquadria }, Voltage.LuV); + addProcessGT(CombType.THORIUM, new Materials[] { Materials.Thorium }, Voltage.EV); + addProcessGT(CombType.LUTETIUM, new Materials[] { Materials.Lutetium }, Voltage.IV); + addProcessGT(CombType.AMERICIUM, new Materials[] { Materials.Americium }, Voltage.LuV); + addProcessGT(CombType.NEUTRONIUM, new Materials[] { Materials.Neutronium }, Voltage.UHV); + if (!GT_Mod.gregtechproxy.mNerfedCombs) { + addCentrifugeToMaterial( + CombType.ALMANDINE, + new Materials[] { Materials.Almandine, Materials.Pyrope, Materials.Sapphire, Materials.GreenSapphire }, + new int[] { 90 * 100, 80 * 100, 75 * 100, 75 * 100 }, + new int[] {}, + Voltage.ULV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.URANIUM, + new Materials[] { Materials.Uranium, Materials.Pitchblende, Materials.Uraninite, Materials.Uranium235 }, + new int[] { 50 * 100, 65 * 100, 75 * 100, 50 * 100 }, + new int[] {}, + Voltage.EV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.PLUTONIUM, + new Materials[] { Materials.Plutonium, Materials.Uranium235 }, + new int[] { 10, 5 }, + new int[] {}, + Voltage.EV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.NAQUADAH, + new Materials[] { Materials.Naquadah, Materials.NaquadahEnriched, Materials.Naquadria }, + new int[] { 10 * 100, 5 * 100, 5 * 100 }, + new int[] {}, + Voltage.IV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.NAQUADRIA, + new Materials[] { Materials.Naquadria, Materials.NaquadahEnriched, Materials.Naquadah }, + new int[] { 10 * 100, 10 * 100, 15 * 100 }, + new int[] {}, + Voltage.LuV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.THORIUM, + new Materials[] { Materials.Thorium, Materials.Uranium, Materials.Coal }, + new int[] { 75 * 100, 75 * 100 * 100, 95 * 100 }, + new int[] {}, + Voltage.EV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.LUTETIUM, + new Materials[] { Materials.Lutetium, Materials.Thorium }, + new int[] { 35 * 100, 55 * 100 }, + new int[] {}, + Voltage.IV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.AMERICIUM, + new Materials[] { Materials.Americium, Materials.Lutetium }, + new int[] { 25 * 100, 45 * 100 }, + new int[] {}, + Voltage.LuV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.NEUTRONIUM, + new Materials[] { Materials.Neutronium, Materials.Americium }, + new int[] { 15 * 100, 35 * 100 }, + new int[] {}, + Voltage.UHV, + NI, + 30 * 100); + } + + // Twilight + addCentrifugeToItemStack( + CombType.NAGA, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1L, 4), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.NagaScaleChip", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.NagaScaleFragment", 1L, 0), + ItemList.FR_Wax.get(1) }, + new int[] { 5 * 100, 33 * 100, 8 * 100, 30 * 100 }, + Voltage.MV); + addCentrifugeToItemStack( + CombType.LICH, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1L, 5), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.LichBoneChip", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.LichBoneFragment", 1L, 0), + ItemList.FR_Wax.get(1) }, + new int[] { 5 * 100, 33 * 100, 8 * 100, 30 * 100 }, + Voltage.HV); + addCentrifugeToItemStack( + CombType.HYDRA, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1L, 1), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.FieryBloodDrop", 1L, 0), + GT_Bees.drop.getStackForType(DropType.HYDRA), ItemList.FR_Wax.get(1) }, + new int[] { 5 * 100, 33 * 100, 8 * 100, 30 * 100 }, + Voltage.HV); + addCentrifugeToItemStack( + CombType.URGHAST, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1L, 2), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CarminiteChip", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CarminiteFragment", 1L, 0), + ItemList.FR_Wax.get(1) }, + new int[] { 5 * 100, 33 * 100, 8 * 100, 30 * 100 }, + Voltage.EV); + addCentrifugeToItemStack( + CombType.SNOWQUEEN, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1L, 3), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.SnowQueenBloodDrop", 1L, 0), + GT_Bees.drop.getStackForType(DropType.SNOW_QUEEN), ItemList.FR_Wax.get(1) }, + new int[] { 5 * 100, 33 * 100, 8 * 100, 30 * 100 }, + Voltage.EV); + + // HEE + addCentrifugeToItemStack( + CombType.ENDDUST, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1L, 0), + GT_Bees.propolis.getStackForType(PropolisType.End), GT_Bees.drop.getStackForType(DropType.ENDERGOO), + Materials.Endstone.getBlocks(4) }, + new int[] { 20 * 100, 15 * 100, 10 * 100, 100 * 100 }, + Voltage.HV); + addCentrifugeToItemStack( + CombType.STARDUST, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1L, 0), + GT_Bees.propolis.getStackForType(PropolisType.Stardust), + GT_Bees.drop.getStackForType(DropType.ENDERGOO) }, + new int[] { 20 * 100, 15 * 100, 10 * 100 }, + Voltage.HV); + addCentrifugeToItemStack( + CombType.ECTOPLASMA, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1L, 0), + GT_Bees.propolis.getStackForType(PropolisType.Ectoplasma), + GT_Bees.drop.getStackForType(DropType.ENDERGOO) }, + new int[] { 25 * 100, 10 * 100, 15 * 100 }, + Voltage.EV); + addCentrifugeToItemStack( + CombType.ARCANESHARD, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1L, 0), + GT_Bees.propolis.getStackForType(PropolisType.Arcaneshard), + GT_Bees.drop.getStackForType(DropType.ENDERGOO) }, + new int[] { 25 * 100, 10 * 100, 15 * 100 }, + Voltage.EV); + addCentrifugeToItemStack( + CombType.DRAGONESSENCE, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1L, 0), + GT_Bees.propolis.getStackForType(PropolisType.Dragonessence), + GT_Bees.drop.getStackForType(DropType.ENDERGOO) }, + new int[] { 30 * 100, (int) (7.5 * 100), 20 * 100 }, + Voltage.IV); + addCentrifugeToItemStack( + CombType.ENDERMAN, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1L, 0), + GT_Bees.propolis.getStackForType(PropolisType.Enderman), + GT_Bees.drop.getStackForType(DropType.ENDERGOO) }, + new int[] { 3000, 750, 2000 }, + Voltage.IV); + addCentrifugeToItemStack( + CombType.SILVERFISH, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1L, 0), + GT_Bees.propolis.getStackForType(PropolisType.Silverfish), + GT_Bees.drop.getStackForType(DropType.ENDERGOO), new ItemStack(Items.spawn_egg, 1, 60) }, + new int[] { 25 * 100, 10 * 100, 20 * 100, 15 * 100 }, + Voltage.EV); + addProcessGT(CombType.ENDIUM, new Materials[] { Materials.HeeEndium }, Voltage.HV); + if (!GT_Mod.gregtechproxy.mNerfedCombs) { + addCentrifugeToMaterial( + CombType.ENDIUM, + new Materials[] { Materials.HeeEndium }, + new int[] { 50 * 100 }, + new int[] {}, + Voltage.HV, + GT_ModHandler.getModItem(MagicBees.ID, "wax", 1L, 0), + 20 * 100); + } + addCentrifugeToItemStack( + CombType.RUNEI, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.RuneOfPowerFragment", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.RuneOfAgilityFragment", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.RuneOfVigorFragment", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.RuneOfDefenseFragment", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.RuneOfMagicFragment", 1L, 0) }, + new int[] { 25 * 100, 5 * 100, 5 * 100, 5 * 100, 5 * 100, 5 * 100 }, + Voltage.IV); + addCentrifugeToItemStack( + CombType.RUNEII, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.RuneOfVoidFragment", 1L, 0) }, + new int[] { 50 * 100, (int) (2.5 * 100) }, + Voltage.IV); + addCentrifugeToItemStack( + CombType.FIREESSENSE, + new ItemStack[] { GT_ModHandler.getModItem(MagicBees.ID, "wax", 1L, 0), + GT_Bees.propolis.getStackForType(PropolisType.Fireessence), + GT_Bees.drop.getStackForType(DropType.ENDERGOO) }, + new int[] { 30 * 100, (int) (7.5 * 100), 20 * 100 }, + Voltage.IV); + // Walrus Recipe + if (AE2FluidCraft.isModLoaded()) { + addCentrifugeToItemStack( + CombType.WALRUS, + new ItemStack[] { GT_ModHandler.getModItem(AE2FluidCraft.ID, "walrus", 1L, 0) }, + new int[] { 100 * 100 }, + Voltage.LV); + } + // Space Line + addCentrifugeToItemStack( + CombType.SPACE, + new ItemStack[] { ItemList.FR_Wax.get(1L), ItemList.FR_RefractoryWax.get(1L), + GT_Bees.drop.getStackForType(DropType.OXYGEN), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CoinSpace", 1L, 0) }, + new int[] { 50 * 100, 30 * 100, 15 * 100, 5 * 100 }, + Voltage.HV); + addProcessGT(CombType.METEORICIRON, new Materials[] { Materials.MeteoricIron }, Voltage.HV); + addProcessGT(CombType.DESH, new Materials[] { Materials.Desh }, Voltage.EV); + addProcessGT(CombType.LEDOX, new Materials[] { Materials.Ledox }, Voltage.EV); + addProcessGT(CombType.CALLISTOICE, new Materials[] { Materials.CallistoIce }, Voltage.IV); + addProcessGT(CombType.MYTRYL, new Materials[] { Materials.Mytryl }, Voltage.IV); + addProcessGT(CombType.QUANTIUM, new Materials[] { Materials.Quantium }, Voltage.IV); + addProcessGT(CombType.ORIHARUKON, new Materials[] { Materials.Oriharukon }, Voltage.IV); + addProcessGT(CombType.INFUSEDGOLD, new Materials[] { Materials.InfusedGold }, Voltage.IV); + addCentrifugeToMaterial( + CombType.INFUSEDGOLD, + new Materials[] { Materials.InfusedGold, Materials.Gold }, + new int[] { (GT_Mod.gregtechproxy.mNerfedCombs ? 20 : 50) * 100, + (GT_Mod.gregtechproxy.mNerfedCombs ? 10 : 30) * 100 }, + new int[] {}, + Voltage.IV, + 200, + NI, + 10 * 100); + addProcessGT(CombType.MYSTERIOUSCRYSTAL, new Materials[] { Materials.MysteriousCrystal }, Voltage.LuV); + addCentrifugeToMaterial( + CombType.MYSTERIOUSCRYSTAL, + new Materials[] { Materials.MysteriousCrystal }, + new int[] { (GT_Mod.gregtechproxy.mNerfedCombs ? 10 : 40) * 100, + (GT_Mod.gregtechproxy.mNerfedCombs ? 15 : 50) * 100 }, + new int[] {}, + Voltage.LuV, + 512, + NI, + 50 * 100); + addProcessGT(CombType.BLACKPLUTONIUM, new Materials[] { Materials.BlackPlutonium }, Voltage.LuV); + addProcessGT(CombType.TRINIUM, new Materials[] { Materials.Trinium }, Voltage.ZPM); + if (!GT_Mod.gregtechproxy.mNerfedCombs) { + addCentrifugeToMaterial( + CombType.METEORICIRON, + new Materials[] { Materials.MeteoricIron, Materials.Iron }, + new int[] { 85 * 100, 100 * 100 }, + new int[] {}, + Voltage.HV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.DESH, + new Materials[] { Materials.Desh, Materials.Titanium }, + new int[] { 75 * 100, 50 * 100 }, + new int[] {}, + Voltage.EV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.LEDOX, + new Materials[] { Materials.Ledox, Materials.CallistoIce, Materials.Lead }, + new int[] { 65 * 100, 55 * 100, 85 * 100 }, + new int[] {}, + Voltage.EV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.CALLISTOICE, + new Materials[] { Materials.CallistoIce, Materials.Ledox, Materials.Lead }, + new int[] { 65 * 100, 75 * 100, 100 * 100 }, + new int[] {}, + Voltage.IV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.MYTRYL, + new Materials[] { Materials.Mytryl, Materials.Mithril }, + new int[] { 55 * 100, 50 * 100 }, + new int[] {}, + Voltage.IV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.QUANTIUM, + new Materials[] { Materials.Quantium, Materials.Osmium }, + new int[] { 50 * 100, 60 * 100 }, + new int[] {}, + Voltage.IV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.ORIHARUKON, + new Materials[] { Materials.Oriharukon, Materials.Lead }, + new int[] { 50 * 100, 75 * 100 }, + new int[] {}, + Voltage.IV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.BLACKPLUTONIUM, + new Materials[] { Materials.BlackPlutonium, Materials.Plutonium }, + new int[] { 25 * 100, 50 * 100 }, + new int[] {}, + Voltage.LuV, + NI, + 30 * 100); + addCentrifugeToMaterial( + CombType.TRINIUM, + new Materials[] { Materials.Trinium, Materials.Iridium }, + new int[] { 35 * 100, 45 * 100 }, + new int[] {}, + Voltage.ZPM, + NI, + 30 * 100); + } + + // Planet Line + addCentrifugeToItemStack( + CombType.MOON, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MoonStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100 }, + Voltage.MV, + 300); + addCentrifugeToItemStack( + CombType.MARS, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MarsStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100 }, + Voltage.HV, + 300); + addCentrifugeToItemStack( + CombType.JUPITER, + new ItemStack[] { GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.IoStoneDust", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EuropaIceDust", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EuropaStoneDust", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.GanymedeStoneDust", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CallistoStoneDust", 1L, 0), + GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.CallistoIce, 1L), ItemList.FR_Wax.get(1L) }, + new int[] { 30 * 100, 30 * 100, 30 * 100, 30 * 100, 30 * 100, 5 * 100, 50 * 100 }, + Voltage.HV, + 300); + addCentrifugeToItemStack( + CombType.MERCURY, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MercuryCoreDust", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MercuryStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100, 30 * 100 }, + Voltage.EV, + 300); + addCentrifugeToItemStack( + CombType.VENUS, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.VenusStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100 }, + Voltage.EV, + 300); + addCentrifugeToItemStack( + CombType.SATURN, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EnceladusStoneDust", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TitanStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100, 30 * 100 }, + Voltage.IV, + 300); + addCentrifugeToItemStack( + CombType.URANUS, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MirandaStoneDust", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.OberonStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100, 30 * 100 }, + Voltage.IV, + 300); + addCentrifugeToItemStack( + CombType.NEPTUN, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.ProteusStoneDust", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TritonStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100, 30 * 100 }, + Voltage.IV, + 300); + addCentrifugeToItemStack( + CombType.PLUTO, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.PlutoStoneDust", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.PlutoIceDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100, 30 * 100 }, + Voltage.LuV, + 300); + addCentrifugeToItemStack( + CombType.HAUMEA, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.HaumeaStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100 }, + Voltage.LuV, + 300); + addCentrifugeToItemStack( + CombType.MAKEMAKE, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MakeMakeStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100 }, + Voltage.LuV, + 300); + addCentrifugeToItemStack( + CombType.CENTAURI, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CentauriASurfaceDust", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CentauriAStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100, 30 * 100 }, + Voltage.ZPM, + 300); + addCentrifugeToItemStack( + CombType.TCETI, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TCetiEStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100 }, + Voltage.ZPM, + 300); + addCentrifugeToItemStack( + CombType.BARNARDA, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.BarnardaEStoneDust", 1L, 0), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.BarnardaFStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100, 30 * 100 }, + Voltage.ZPM, + 300); + addCentrifugeToItemStack( + CombType.VEGA, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.VegaBStoneDust", 1L, 0) }, + new int[] { 50 * 100, 30 * 100 }, + Voltage.ZPM, + 300); + if (GalaxySpace.isModLoaded()) { + addCentrifugeToItemStack( + CombType.SEAWEED, + new ItemStack[] { ItemList.FR_Wax.get(1L), + GT_ModHandler.getModItem(GalaxySpace.ID, "tcetiedandelions", 1L, 0) }, + new int[] { 50 * 100, 100 * 100 }, + Voltage.UV, + 100); + } + // Infinity Line + addCentrifugeToMaterial( + CombType.INFINITYCATALYST, + new Materials[] { Materials.InfinityCatalyst, Materials.Neutronium }, + new int[] { 25 * 100, 20 * 100 }, + new int[] {}, + Voltage.ZPM, + 100, + NI, + 50 * 100); + + // (Noble)gas Line + addFluidExtractorProcess(CombType.HELIUM, Materials.Helium.getGas(250), Voltage.HV); + addFluidExtractorProcess(CombType.ARGON, Materials.Argon.getGas(250), Voltage.MV); + addFluidExtractorProcess(CombType.NITROGEN, Materials.Nitrogen.getGas(500), Voltage.MV); + addFluidExtractorProcess(CombType.HYDROGEN, Materials.Hydrogen.getGas(500), Voltage.MV); + addFluidExtractorProcess(CombType.FLUORINE, Materials.Fluorine.getGas(250), Voltage.MV); + addFluidExtractorProcess(CombType.OXYGEN, Materials.Oxygen.getGas(500), Voltage.MV); + // Organic part 2, unknown liquid + // yes, unknowwater. It's not a typo, it's how it is spelled. Stupid game. + addFluidExtractorProcess(CombType.UNKNOWNWATER, FluidRegistry.getFluidStack("unknowwater", 250), Voltage.ZPM); + /* + * TODO: update this comment + * The Centrifuge Recipes for Infused Shards and Nether/End-Shard from the Infused Shard Line are below the + * NobleGas Lines for Xenon and co. in GT_MachineRecipeLoader.java In Lines 1525 + */ + } + + /** + * Currently only used for CombType.MOLYBDENUM + * + * @param circuitNumber should not conflict with addProcessGT + * + **/ + public void addAutoclaveProcess(CombType comb, Materials aMaterial, Voltage volt, int circuitNumber) { + if (GT_OreDictUnificator.get(OrePrefixes.crushedPurified, aMaterial, 4) == NI) { + return; + } + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + recipeBuilder + .itemInputs(GT_Utility.copyAmount(9, getStackForType(comb)), GT_Utility.getIntegratedCircuit(circuitNumber)) + .itemOutputs(GT_OreDictUnificator.get(OrePrefixes.crushedPurified, aMaterial, 4)) + .fluidInputs(Materials.UUMatter.getFluid(Math.max(1, ((aMaterial.getMass() + volt.getUUAmplifier()) / 10)))) + .duration(((int) (aMaterial.getMass() * 128)) * TICKS) + .eut(volt.getAutoClaveEnergy()); + if (volt.compareTo(Voltage.HV) > 0) { + recipeBuilder.requiresCleanRoom(); + } + recipeBuilder.addTo(autoclaveRecipes); + } + + public void addFluidExtractorProcess(CombType comb, FluidStack fluid, Voltage volt) { + if (fluid == null) { + return; + } + + int duration = (fluid.getFluid() + .getDensity() * 128 > 0 + ? (fluid.getFluid() + .getDensity() * 100) + : 128); + int eut = volt.getSimpleEnergy() / 2; + + GT_Values.RA.stdBuilder() + .itemInputs(GT_Utility.copyAmount(1, getStackForType(comb))) + .fluidOutputs(fluid) + .duration(duration) + .eut(eut) + .addTo(fluidExtractionRecipes); + } + + /** + * this only adds Chemical and AutoClave process. If you need Centrifuge recipe. use addCentrifugeToMaterial or + * addCentrifugeToItemStack + * + * @param volt This determine the required Tier of process for this recipes. This decide the required aEU/t, + * progress time, required additional UU-Matter, requirement of cleanRoom, needed fluid stack for + * Chemical. + * @param aMaterial result of Material that should be generated by this process. + **/ + public void addProcessGT(CombType comb, Materials[] aMaterial, Voltage volt) { + ItemStack tComb = getStackForType(comb); + for (Materials materials : aMaterial) { + if (GT_OreDictUnificator.get(OrePrefixes.crushedPurified, materials, 4) != null) { + ItemStack combInput; + ItemStack combOutput; + FluidStack fluidInput; + FluidStack fluidOutput; + int durationTicks; + int eut; + boolean requiresCleanroom; + switch (comb) { + case NEUTRONIUM -> { + combInput = GT_Utility.copyAmount(4, tComb); + combOutput = Materials.Neutronium.getNuggets(1); + fluidInput = volt.getFluidAccordingToCombTier(); + fluidOutput = Materials.Neutronium.getMolten(576); + durationTicks = volt.getComplexTime() * 17; + eut = volt.getChemicalEnergy(); + requiresCleanroom = volt.compareTo(Voltage.IV) > 0; + } + case OSMIUM -> { + combInput = GT_Utility.copyAmount(4, tComb); + combOutput = Materials.Osmium.getNuggets(1); + fluidInput = volt.getFluidAccordingToCombTier(); + fluidOutput = Materials.Osmium.getMolten(288); + durationTicks = volt.getComplexTime() * 17; + eut = volt.getChemicalEnergy(); + requiresCleanroom = volt.compareTo(Voltage.IV) > 0; + } + case PLATINUM -> { + combInput = GT_Utility.copyAmount(4, tComb); + combOutput = Materials.Platinum.getNuggets(1); + fluidInput = volt.getFluidAccordingToCombTier(); + fluidOutput = Materials.Platinum.getMolten(288); + durationTicks = volt.getComplexTime() * 10; + eut = volt.getChemicalEnergy(); + requiresCleanroom = volt.compareTo(Voltage.HV) > 0; + } + case IRIDIUM -> { + combInput = GT_Utility.copyAmount(4, tComb); + combOutput = Materials.Iridium.getNuggets(1); + fluidInput = volt.getFluidAccordingToCombTier(); + fluidOutput = Materials.Iridium.getMolten(288); + durationTicks = volt.getComplexTime() * 14; + eut = volt.getChemicalEnergy(); + requiresCleanroom = volt.compareTo(Voltage.EV) > 0; + } + default -> { + combInput = GT_Utility.copyAmount(4, tComb); + combOutput = GT_OreDictUnificator.get(OrePrefixes.crushedPurified, materials, 4); + fluidInput = volt.getFluidAccordingToCombTier(); + fluidOutput = null; + durationTicks = volt.getComplexTime(); + eut = volt.getChemicalEnergy(); + requiresCleanroom = volt.compareTo(Voltage.IV) > 0; + } + } + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + recipeBuilder.itemInputs(combInput) + .itemOutputs(combOutput) + .fluidInputs(fluidInput); + if (fluidOutput != null) { + recipeBuilder.fluidOutputs(fluidOutput); + } + recipeBuilder.duration(durationTicks) + .eut(eut) + .metadata(CLEANROOM, requiresCleanroom) + .addTo(UniversalChemical); + } + } + } + + /** + * this method only adds Centrifuge based on Material. If volt is lower than MV than it will also adds forestry + * centrifuge recipe. + * + * @param comb BeeComb + * @param aMaterial resulting Material of processing. can be more than 6. but over 6 will be ignored in Gregtech + * Centrifuge. + * @param chance chance to get result, 10000 == 100% + * @param volt required Voltage Tier for this recipe, this also affect the duration, amount of UU-Matter, and + * needed liquid type and amount for chemical reactor + * @param stackSize This parameter can be null, in that case stack size will be just 1. This handle the stackSize of + * the resulting Item, and Also the Type of Item. if this value is multiple of 9, than related + * Material output will be dust, if this value is multiple of 4 than output will be Small dust, + * else the output will be Tiny dust + * @param beeWax if this is null, then the comb will product default Bee wax. But if aMaterial is more than 5, + * beeWax will be ignored in Gregtech Centrifuge. + * @param waxChance have same format like "chance" + **/ + public void addCentrifugeToMaterial(CombType comb, Materials[] aMaterial, int[] chance, int[] stackSize, + Voltage volt, ItemStack beeWax, int waxChance) { + addCentrifugeToMaterial(comb, aMaterial, chance, stackSize, volt, volt.getSimpleTime(), beeWax, waxChance); + } + + public void addCentrifugeToMaterial(CombType comb, Materials[] aMaterial, int[] chance, int[] stackSize, + Voltage volt, int duration, ItemStack beeWax, int waxChance) { + ItemStack[] aOutPut = new ItemStack[aMaterial.length + 1]; + stackSize = Arrays.copyOf(stackSize, aMaterial.length); + chance = Arrays.copyOf(chance, aOutPut.length); + chance[chance.length - 1] = waxChance; + for (int i = 0; i < (aMaterial.length); i++) { + if (chance[i] == 0) { + continue; + } + if (Math.max(1, stackSize[i]) % 9 == 0) { + aOutPut[i] = GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial[i], (Math.max(1, stackSize[i]) / 9)); + } else if (Math.max(1, stackSize[i]) % 4 == 0) { + aOutPut[i] = GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial[i], (Math.max(1, stackSize[i]) / 4)); + } else { + aOutPut[i] = GT_OreDictUnificator.get(OrePrefixes.dust, aMaterial[i], Math.max(1, stackSize[i])); + } + } + if (beeWax != NI) { + aOutPut[aOutPut.length - 1] = beeWax; + } else { + aOutPut[aOutPut.length - 1] = ItemList.FR_Wax.get(1); + } + + addCentrifugeToItemStack(comb, aOutPut, chance, volt, duration); + } + + /** + * @param volt required Tier of system. If it's lower than MV, it will also add forestry centrifuge. + * @param aItem can be more than 6. but Over 6 will be ignored in Gregtech Centrifuge. + **/ + public void addCentrifugeToItemStack(CombType comb, ItemStack[] aItem, int[] chance, Voltage volt) { + addCentrifugeToItemStack(comb, aItem, chance, volt, volt.getSimpleTime()); + } + + public void addCentrifugeToItemStack(CombType comb, ItemStack[] aItem, int[] chance, Voltage volt, int duration) { + ItemStack tComb = getStackForType(comb); + Builder<ItemStack, Float> Product = new ImmutableMap.Builder<>(); + for (int i = 0; i < aItem.length; i++) { + if (aItem[i] == NI) { + continue; + } + Product.put(aItem[i], chance[i] / 10000.0f); + } + + if (volt.compareTo(Voltage.MV) < 0 || !GT_Mod.gregtechproxy.mNerfedCombs) { + RecipeManagers.centrifugeManager.addRecipe(40, tComb, Product.build()); + } + + GT_Values.RA.stdBuilder() + .itemInputs(tComb) + .itemOutputs(aItem) + .outputChances(chance) + .duration(duration) + .eut(volt.getSimpleEnergy()) + .addTo(centrifugeRecipes); + } + + public void registerOreDict() { + for (CombType comb : CombType.values()) { + ItemStack tComb = getStackForType(comb); + GT_OreDictUnificator.registerOre(OrePrefixes.beeComb.name(), tComb); + OrePrefixes.beeComb.add(tComb); + if (comb.voltage != null) GT_OreDictUnificator.registerOre("comb" + comb.voltage.name(), tComb); + } + } + + enum Voltage { + + ULV, + LV, + MV, + HV, + EV, + IV, + LuV, + ZPM, + UV, + UHV, + UEV, + UIV, + UMV, + UXV, + MAX; + + public int getVoltage() { + return (int) V[this.ordinal()]; + } + + /** @return aEU/t needed for chemical and autoclave process related to the Tier **/ + public int getVoltageFromEU() { + return (int) Math.max(Math.floor(Math.log(2 * this.getVoltage()) / Math.log(4) - 1), 0); + } + + /** @return Voltage tier according to EU provided. 0 = ULV, 1 = LV, 2 = MV ... **/ + public int getChemicalEnergy() { + return this.getVoltage() * 3 / 4; + } + + public int getAutoClaveEnergy() { + return (int) ((this.getVoltage() * 3 / 4) * (Math.max(1, Math.pow(2, 5 - this.ordinal())))); + } + + /** @return FluidStack needed for chemical process related to the Tier **/ + public FluidStack getComplexChemical() { + if (this.compareTo(Voltage.MV) < 0) { + return Materials.HydrofluoricAcid.getFluid((this.compareTo(Voltage.ULV) > 0) ? 1000 : 500); + } else if (this.compareTo(Voltage.HV) < 0) { + return GT_ModHandler.getDistilledWater(1000L); + } else if (this.compareTo(Voltage.LuV) < 0) { + return Materials.HydrofluoricAcid.getFluid((long) (Math.pow(2, this.compareTo(Voltage.HV)) * L)); + } else if (this.compareTo(Voltage.UHV) < 0) { + return FluidRegistry.getFluidStack("mutagen", (int) (Math.pow(2, this.compareTo(Voltage.LuV)) * L)); + } else { + return NF; + } + } + + /** @return FluidStack needed for chemical process related to the Tier **/ + public FluidStack getFluidAccordingToCombTier() { + // checking what Voltage tier the Comb is + // cascading from IV to UMV since all recipes use HydrofluiricAcid + // for later tiers, just add the corresponding tier to a case + int fluidAmount = this.getFluidAmount(); + return switch (this.getVoltageFromEU()) { + case 0 -> + /* ULV */ + Materials.Water.getFluid(fluidAmount); + case 1 -> + /* LV */ + Materials.SulfuricAcid.getFluid(fluidAmount); + case 2 -> + /* MV */ + Materials.HydrochloricAcid.getFluid(fluidAmount); + case 3 -> + /* HV */ + Materials.PhosphoricAcid.getFluid(fluidAmount); + case 4 -> + /* EV */ + Materials.HydrofluoricAcid.getFluid(this.getFluidAmount()); + default -> Materials.PhthalicAcid.getFluid(fluidAmount); + }; + } + + /** @return additional required UU-Matter amount for Autoclave process related to the Tier **/ + public int getUUAmplifier() { + return 9 * ((this.compareTo(Voltage.MV) < 0) ? 1 : this.compareTo(Voltage.MV)); + } + + /** @return duration needed for Chemical process related to the Tier **/ + public int getComplexTime() { + return 64 + this.ordinal() * 32; + } + + /** @return Fluid amount needed for Chemical process related to the Tier **/ + public int getFluidAmount() { + return 9 * this.getSimpleTime() / 3; + } + + /** @return duration needed for Centrifuge process related to the Tier **/ + public int getSimpleTime() { + if (!GT_Mod.gregtechproxy.mNerfedCombs) { + return 96 + this.ordinal() * 32; + } else { + // ULV, LV needs 128ticks, MV need 256 ticks, HV need 384 ticks, EV need 512 ticks, IV need 640 ticks + return 128 * (Math.max(1, this.ordinal())); + } + } + + /** @return aEU/t needed for Centrifuge process related to the Tier **/ + public int getSimpleEnergy() { + if (this == Voltage.ULV) { + return 5; + } else { + return (this.getVoltage() / 16) * 15; + } + } + } +} diff --git a/src/main/java/gregtech/common/items/ItemDrop.java b/src/main/java/gregtech/common/items/ItemDrop.java new file mode 100644 index 0000000000..5aab9dff48 --- /dev/null +++ b/src/main/java/gregtech/common/items/ItemDrop.java @@ -0,0 +1,241 @@ +package gregtech.common.items; + +import static gregtech.api.enums.Mods.ExtraBees; +import static gregtech.api.enums.Mods.Forestry; +import static gregtech.api.enums.Mods.GregTech; +import static gregtech.api.enums.Mods.HardcoreEnderExpansion; +import static gregtech.api.enums.Mods.MagicBees; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +import java.util.List; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import forestry.api.core.Tabs; +import forestry.api.recipes.RecipeManagers; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_RecipeBuilder; + +public class ItemDrop extends Item { + + @SideOnly(Side.CLIENT) + private IIcon secondIcon; + + public ItemDrop() { + super(); + this.setCreativeTab(Tabs.tabApiculture); + this.setHasSubtypes(true); + this.setUnlocalizedName("gt.drop"); + GameRegistry.registerItem(this, "gt.drop", GregTech.ID); + } + + public ItemStack getStackForType(DropType type) { + return new ItemStack(this, 1, type.ordinal()); + } + + public ItemStack getStackForType(DropType type, int count) { + return new ItemStack(this, count, type.ordinal()); + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item item, CreativeTabs tabs, List<ItemStack> list) { + for (DropType type : DropType.values()) { + if (type.showInList) { + list.add(this.getStackForType(type)); + } + } + } + + @Override + @SideOnly(Side.CLIENT) + public boolean requiresMultipleRenderPasses() { + return true; + } + + @Override + public int getRenderPasses(int meta) { + return 2; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister iconRegister) { + this.itemIcon = iconRegister.registerIcon("forestry:honeyDrop.0"); + this.secondIcon = iconRegister.registerIcon("forestry:honeyDrop.1"); + } + + @Override + public IIcon getIcon(ItemStack stack, int pass) { + return (pass == 0) ? itemIcon : secondIcon; + } + + @Override + @SideOnly(Side.CLIENT) + public int getColorFromItemStack(ItemStack stack, int pass) { + int meta = Math.max(0, Math.min(DropType.values().length - 1, stack.getItemDamage())); + int colour = DropType.values()[meta].getColours()[0]; + + if (pass >= 1) { + colour = DropType.values()[meta].getColours()[1]; + } + + return colour; + } + + @Override + public String getItemStackDisplayName(ItemStack stack) { + return DropType.values()[stack.getItemDamage()].getName(); + } + + public void initDropsRecipes() { + ItemStack tDrop; + + tDrop = getStackForType(DropType.OIL); + addProcessLV( + tDrop, + Materials.OilHeavy.getFluid(100L), + GT_ModHandler.getModItem(Forestry.ID, "propolis", 1L, 0), + 3000, + 8); + RecipeManagers.squeezerManager.addRecipe( + 40, + new ItemStack[] { tDrop }, + Materials.OilHeavy.getFluid(100L), + GT_ModHandler.getModItem(Forestry.ID, "propolis", 1L, 0), + 30); + tDrop = getStackForType(DropType.COOLANT); + addProcessLV( + tDrop, + new FluidStack(FluidRegistry.getFluid("ic2coolant"), 100), + GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1L, 0), + 3000, + 8); + RecipeManagers.squeezerManager.addRecipe( + 40, + new ItemStack[] { tDrop }, + new FluidStack(FluidRegistry.getFluid("ic2coolant"), 100), + GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1L, 0), + 30); + tDrop = getStackForType(DropType.HOT_COOLANT); + addProcessLV( + tDrop, + new FluidStack(FluidRegistry.getFluid("ic2hotcoolant"), 100), + GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1L, 2), + 3000, + 8); + RecipeManagers.squeezerManager.addRecipe( + 40, + new ItemStack[] { tDrop }, + new FluidStack(FluidRegistry.getFluid("ic2hotcoolant"), 100), + GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1L, 2), + 30); + tDrop = getStackForType(DropType.SNOW_QUEEN); + addProcessMV( + tDrop, + Materials.FierySteel.getFluid(200L), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.SnowQueenBloodDrop", 1L, 0), + 1500, + 48); + tDrop = getStackForType(DropType.LAPIS); + addProcessLV( + tDrop, + new FluidStack(FluidRegistry.getFluid("ic2coolant"), 200), + GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1L, 3), + 5000, + 1200, + 2); + RecipeManagers.squeezerManager.addRecipe( + 400, + new ItemStack[] { tDrop }, + new FluidStack(FluidRegistry.getFluid("ic2coolant"), 100), + GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1L, 3), + 30); + tDrop = getStackForType(DropType.HYDRA); + addProcessMV( + tDrop, + Materials.FierySteel.getFluid(50L), + GT_ModHandler.getModItem(MagicBees.ID, "propolis", 1L, 2), + 3000, + 8); + tDrop = getStackForType(DropType.OXYGEN); + addProcessLV( + tDrop, + new FluidStack(FluidRegistry.getFluid("liquidoxygen"), 100), + GT_ModHandler.getModItem(ExtraBees.ID, "propolis", 1L, 2), + 250, + 1200, + 8); + RecipeManagers.squeezerManager.addRecipe( + 400, + new ItemStack[] { tDrop }, + new FluidStack(FluidRegistry.getFluid("ic2coolant"), 100), + GT_ModHandler.getModItem(ExtraBees.ID, "propolis", 1L, 2), + 30); + tDrop = getStackForType(DropType.ENDERGOO); + if (HardcoreEnderExpansion.isModLoaded()) + addProcessHV(tDrop, new FluidStack(FluidRegistry.getFluid("endergoo"), 500), GT_Values.NI, 1000); + } + + public void addProcessLV(ItemStack tDrop, FluidStack aOutput, ItemStack aOutput2, int aChance, int aEUt) { + GT_Values.RA.stdBuilder() + .itemInputs(tDrop) + .itemOutputs(aOutput2) + .outputChances(aChance) + .fluidOutputs(aOutput) + .duration(1 * SECONDS + 12 * TICKS) + .eut(aEUt) + .addTo(fluidExtractionRecipes); + } + + public void addProcessLV(ItemStack tDrop, FluidStack aOutput, ItemStack aOutput2, int aChance, int aDuration, + int aEUt) { + GT_Values.RA.stdBuilder() + .itemInputs(tDrop) + .itemOutputs(aOutput2) + .outputChances(aChance) + .fluidOutputs(aOutput) + .duration(aDuration) + .eut(aEUt) + .addTo(fluidExtractionRecipes); + } + + public void addProcessMV(ItemStack tDrop, FluidStack aOutput, ItemStack aOutput2, int aChance, int aEUt) { + GT_Values.RA.stdBuilder() + .itemInputs(tDrop) + .itemOutputs(aOutput2) + .outputChances(aChance) + .fluidOutputs(aOutput) + .duration(6 * SECONDS + 8 * TICKS) + .eut(aEUt) + .addTo(fluidExtractionRecipes); + } + + public void addProcessHV(ItemStack tDrop, FluidStack aOutput, ItemStack aOutput2, int aChance) { + GT_RecipeBuilder recipeBuilder = GT_Values.RA.stdBuilder(); + recipeBuilder.itemInputs(tDrop); + if (aOutput2 != GT_Values.NI) { + recipeBuilder.itemOutputs(aOutput2) + .outputChances(aChance); + } + recipeBuilder.fluidOutputs(aOutput) + .duration(24 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(fluidExtractionRecipes); + } +} diff --git a/src/main/java/gregtech/common/items/ItemPollen.java b/src/main/java/gregtech/common/items/ItemPollen.java new file mode 100644 index 0000000000..70e2d64514 --- /dev/null +++ b/src/main/java/gregtech/common/items/ItemPollen.java @@ -0,0 +1,89 @@ +package gregtech.common.items; + +import static gregtech.api.enums.Mods.GregTech; + +import java.util.List; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import forestry.api.core.Tabs; + +public class ItemPollen extends Item { + + @SideOnly(Side.CLIENT) + private IIcon secondIcon; + + public ItemPollen() { + super(); + this.setCreativeTab(Tabs.tabApiculture); + this.setHasSubtypes(true); + this.setUnlocalizedName("gt.pollen"); + GameRegistry.registerItem(this, "gt.pollen", GregTech.ID); + } + + public ItemStack getStackForType(PollenType type) { + return new ItemStack(this, 1, type.ordinal()); + } + + public ItemStack getStackForType(PollenType type, int count) { + return new ItemStack(this, count, type.ordinal()); + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item item, CreativeTabs tabs, List<ItemStack> list) { + for (PollenType type : PollenType.values()) { + if (type.showInList) { + list.add(this.getStackForType(type)); + } + } + } + + @Override + @SideOnly(Side.CLIENT) + public boolean requiresMultipleRenderPasses() { + return true; + } + + @Override + public int getRenderPasses(int meta) { + return 2; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister iconRegister) { + this.itemIcon = iconRegister.registerIcon("forestry:pollen.0"); + this.secondIcon = iconRegister.registerIcon("forestry:pollen.1"); + } + + @Override + public IIcon getIcon(ItemStack stack, int pass) { + return (pass == 0) ? itemIcon : secondIcon; + } + + @Override + @SideOnly(Side.CLIENT) + public int getColorFromItemStack(ItemStack stack, int pass) { + int meta = Math.max(0, Math.min(PollenType.values().length - 1, stack.getItemDamage())); + int colour = PollenType.values()[meta].getColours()[0]; + + if (pass >= 1) { + colour = PollenType.values()[meta].getColours()[1]; + } + + return colour; + } + + @Override + public String getItemStackDisplayName(ItemStack stack) { + return PollenType.values()[stack.getItemDamage()].getName(); + } +} diff --git a/src/main/java/gregtech/common/items/ItemPropolis.java b/src/main/java/gregtech/common/items/ItemPropolis.java new file mode 100644 index 0000000000..1c0d727bda --- /dev/null +++ b/src/main/java/gregtech/common/items/ItemPropolis.java @@ -0,0 +1,141 @@ +package gregtech.common.items; + +import static gregtech.api.enums.Mods.GregTech; +import static gregtech.api.enums.Mods.HardcoreEnderExpansion; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.recipe.RecipeMaps.fluidExtractionRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeBuilder.TICKS; + +import java.util.List; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraftforge.fluids.FluidRegistry; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import forestry.api.core.Tabs; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; + +public class ItemPropolis extends Item { + + @SideOnly(Side.CLIENT) + private IIcon secondIcon; + + public ItemPropolis() { + super(); + this.setCreativeTab(Tabs.tabApiculture); + this.setHasSubtypes(true); + this.setUnlocalizedName("gt.propolis"); + GameRegistry.registerItem(this, "gt.propolis", GregTech.ID); + } + + public ItemStack getStackForType(PropolisType type) { + return new ItemStack(this, 1, type.ordinal()); + } + + public ItemStack getStackForType(PropolisType type, int count) { + return new ItemStack(this, count, type.ordinal()); + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item item, CreativeTabs tabs, List<ItemStack> list) { + for (PropolisType type : PropolisType.values()) { + if (type.showInList) { + list.add(this.getStackForType(type)); + } + } + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister iconRegister) { + this.itemIcon = iconRegister.registerIcon("forestry:propolis.0"); + } + + @Override + public IIcon getIcon(ItemStack stack, int pass) { + return itemIcon; + } + + @Override + @SideOnly(Side.CLIENT) + public int getColorFromItemStack(ItemStack stack, int pass) { + int meta = Math.max(0, Math.min(PropolisType.values().length - 1, stack.getItemDamage())); + return PropolisType.values()[meta].getColours(); + } + + @Override + public String getItemStackDisplayName(ItemStack stack) { + return PropolisType.values()[stack.getItemDamage()].getName(); + } + + public void initPropolisRecipes() { + ItemStack tPropolis; + + tPropolis = getStackForType(PropolisType.End); + addProcessHV(tPropolis, GT_ModHandler.getModItem(HardcoreEnderExpansion.ID, "end_powder", 1, 0)); + tPropolis = getStackForType(PropolisType.Stardust); + addProcessHV(tPropolis, GT_ModHandler.getModItem(HardcoreEnderExpansion.ID, "stardust", 1, 0)); + tPropolis = getStackForType(PropolisType.Ectoplasma); + addProcessEV(tPropolis, GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EctoplasmaChip", 1, 0)); + tPropolis = getStackForType(PropolisType.Arcaneshard); + addProcessEV(tPropolis, GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.ArcaneShardChip", 1, 0)); + tPropolis = getStackForType(PropolisType.Dragonessence); + addProcessIV(tPropolis, GT_ModHandler.getModItem(HardcoreEnderExpansion.ID, "essence", 16, 0)); + tPropolis = getStackForType(PropolisType.Enderman); + addProcessIV(tPropolis, GT_ModHandler.getModItem(HardcoreEnderExpansion.ID, "enderman_head", 1, 0)); + tPropolis = getStackForType(PropolisType.Silverfish); + addProcessEV(tPropolis, GT_ModHandler.getModItem(HardcoreEnderExpansion.ID, "silverfish_blood", 1, 0)); + tPropolis = getStackForType(PropolisType.Endium); + addProcessHV(tPropolis, GT_OreDictUnificator.get(OrePrefixes.dustSmall, Materials.HeeEndium, 1)); + tPropolis = getStackForType(PropolisType.Fireessence); + addProcessIV(tPropolis, GT_ModHandler.getModItem(HardcoreEnderExpansion.ID, "essence", 16, 1)); + + // addRecipe(tDrop, aOutput, aOutput2, aChance, aDuration, aEUt); + } + + public void addProcessHV(ItemStack tPropolis, ItemStack aOutput2) { + GT_Values.RA.stdBuilder() + .itemInputs(tPropolis) + .itemOutputs(aOutput2) + .outputChances(5000) + .fluidOutputs(FluidRegistry.getFluidStack("endergoo", 100)) + .duration(2 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_HV) + .addTo(fluidExtractionRecipes); + } + + public void addProcessEV(ItemStack tPropolis, ItemStack aOutput2) { + GT_Values.RA.stdBuilder() + .itemInputs(tPropolis) + .itemOutputs(aOutput2) + .outputChances(2500) + .fluidOutputs(FluidRegistry.getFluidStack("endergoo", 200)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(fluidExtractionRecipes); + } + + public void addProcessIV(ItemStack tPropolis, ItemStack aOutput2) { + GT_Values.RA.stdBuilder() + .itemInputs(tPropolis) + .itemOutputs(aOutput2) + .outputChances(1500) + .fluidOutputs(FluidRegistry.getFluidStack("endergoo", 300)) + .duration(7 * SECONDS + 10 * TICKS) + .eut(TierEU.RECIPE_IV) + .addTo(fluidExtractionRecipes); + } +} diff --git a/src/main/java/gregtech/common/items/PollenType.java b/src/main/java/gregtech/common/items/PollenType.java new file mode 100644 index 0000000000..3cd9484b69 --- /dev/null +++ b/src/main/java/gregtech/common/items/PollenType.java @@ -0,0 +1,35 @@ +package gregtech.common.items; + +import gregtech.api.enums.Materials; +import gregtech.api.util.GT_LanguageManager; + +public enum PollenType { + + MATRIX("matrix", true); + + private static final int[][] colours = new int[][] { { 0x19191B, 0x303032 }, }; + public boolean showInList; + public Materials material; + public int chance; + private final String name; + + PollenType(String pName, boolean show) { + this.name = pName; + this.showInList = show; + } + + public void setHidden() { + this.showInList = false; + } + + public String getName() { + return GT_LanguageManager.addStringLocalization( + "pollen." + this.name, + this.name.substring(0, 1) + .toUpperCase() + this.name.substring(1) + " Pollen"); + } + + public int[] getColours() { + return colours[this.ordinal()]; + } +} diff --git a/src/main/java/gregtech/common/items/PropolisType.java b/src/main/java/gregtech/common/items/PropolisType.java new file mode 100644 index 0000000000..e6f08b0cfa --- /dev/null +++ b/src/main/java/gregtech/common/items/PropolisType.java @@ -0,0 +1,46 @@ +package gregtech.common.items; + +import gregtech.api.enums.Materials; +import gregtech.api.util.GT_LanguageManager; + +public enum PropolisType { + + End("End", true), + Ectoplasma("Ectoplasma", true), + Arcaneshard("Arcaneshard", true), + Stardust("Stardust", true), + Dragonessence("Dragonessence", true), + Enderman("Enderman", true), + Silverfish("Silverfish", true), + Endium("Endium", true), + Fireessence("Fireessence", true); + + private static final int[] colours = new int[] { 0xCC00FA, 0xDCB0E5, 0x9010AD, 0xFFFF00, 0x911ECE, 0x161616, + 0xEE053D, 0xa0ffff, 0xD41238 }; + + public boolean showInList; + public Materials material; + public int chance; + private final String name; + + PropolisType(String pName, boolean show) { + this.name = pName; + this.showInList = show; + } + + public void setHidden() { + this.showInList = false; + } + + public String getName() { + // return "gt.comb."+this.name; + return GT_LanguageManager.addStringLocalization( + "propolis." + this.name, + this.name.substring(0, 1) + .toUpperCase() + this.name.substring(1) + " Propolis"); + } + + public int getColours() { + return colours[this.ordinal()]; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Arrow.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Arrow.java new file mode 100644 index 0000000000..8005009d14 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Arrow.java @@ -0,0 +1,141 @@ +package gregtech.common.items.behaviors; + +import net.minecraft.block.BlockDispenser; +import net.minecraft.dispenser.IBlockSource; +import net.minecraft.dispenser.IPosition; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.projectile.EntityArrow; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.World; + +import gregtech.api.enums.SubTag; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_Utility; +import gregtech.common.entities.GT_Entity_Arrow; + +public class Behaviour_Arrow extends Behaviour_None { + + public static Behaviour_Arrow DEFAULT_WOODEN = new Behaviour_Arrow(GT_Entity_Arrow.class, 1.0F, 6.0F); + public static Behaviour_Arrow DEFAULT_PLASTIC = new Behaviour_Arrow(GT_Entity_Arrow.class, 1.5F, 6.0F); + private final int mLevel; + private final Enchantment mEnchantment; + private final float mSpeedMultiplier; + private final float mPrecision; + private final Class<? extends GT_Entity_Arrow> mArrow; + + public Behaviour_Arrow(Class<? extends GT_Entity_Arrow> aArrow, float aSpeed, float aPrecision) { + this(aArrow, aSpeed, aPrecision, null, 0); + } + + public Behaviour_Arrow(Class<? extends GT_Entity_Arrow> aArrow, float aSpeed, float aPrecision, + Enchantment aEnchantment, int aLevel) { + this.mArrow = aArrow; + this.mSpeedMultiplier = aSpeed; + this.mPrecision = aPrecision; + this.mEnchantment = aEnchantment; + this.mLevel = aLevel; + } + + @Override + public boolean onLeftClickEntity(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, Entity aEntity) { + if ((aEntity instanceof EntityLivingBase)) { + GT_Utility.GT_EnchantmentHelper.applyBullshitA((EntityLivingBase) aEntity, aPlayer, aStack); + GT_Utility.GT_EnchantmentHelper.applyBullshitB(aPlayer, aEntity, aStack); + if (!aPlayer.capabilities.isCreativeMode) { + aStack.stackSize -= 1; + } + if (aStack.stackSize <= 0) { + aPlayer.destroyCurrentEquippedItem(); + } + return false; + } + return false; + } + + @Override + public boolean isItemStackUsable(GT_MetaBase_Item aItem, ItemStack aStack) { + if ((this.mEnchantment != null) && (this.mLevel > 0)) { + NBTTagCompound tNBT = GT_Utility.ItemNBT.getNBT(aStack); + if (!tNBT.getBoolean("GT.HasBeenUpdated")) { + tNBT.setBoolean("GT.HasBeenUpdated", true); + GT_Utility.ItemNBT.setNBT(aStack, tNBT); + GT_Utility.ItemNBT.addEnchantment(aStack, this.mEnchantment, this.mLevel); + } + } + return true; + } + + @Override + public boolean canDispense(GT_MetaBase_Item aItem, IBlockSource aSource, ItemStack aStack) { + return true; + } + + @Override + public ItemStack onDispense(GT_MetaBase_Item aItem, IBlockSource aSource, ItemStack aStack) { + World aWorld = aSource.getWorld(); + IPosition tPosition = BlockDispenser.func_149939_a(aSource); + EnumFacing tFacing = BlockDispenser.func_149937_b(aSource.getBlockMetadata()); + GT_Entity_Arrow tEntityArrow = (GT_Entity_Arrow) getProjectile( + aItem, + SubTag.PROJECTILE_ARROW, + aStack, + aWorld, + tPosition.getX(), + tPosition.getY(), + tPosition.getZ()); + if (tEntityArrow != null) { + tEntityArrow.setThrowableHeading( + tFacing.getFrontOffsetX(), + tFacing.getFrontOffsetY() + 0.1F, + tFacing.getFrontOffsetZ(), + this.mSpeedMultiplier * 1.1F, + this.mPrecision); + tEntityArrow.setArrowItem(aStack); + tEntityArrow.canBePickedUp = 1; + aWorld.spawnEntityInWorld(tEntityArrow); + if (aStack.stackSize < 100) { + aStack.stackSize -= 1; + } + return aStack; + } + return super.onDispense(aItem, aSource, aStack); + } + + @Override + public boolean hasProjectile(GT_MetaBase_Item aItem, SubTag aProjectileType, ItemStack aStack) { + return aProjectileType == SubTag.PROJECTILE_ARROW; + } + + @Override + public EntityArrow getProjectile(GT_MetaBase_Item aItem, SubTag aProjectileType, ItemStack aStack, World aWorld, + double aX, double aY, double aZ) { + if (!hasProjectile(aItem, aProjectileType, aStack)) { + return null; + } + GT_Entity_Arrow rArrow = (GT_Entity_Arrow) GT_Utility + .callConstructor(this.mArrow.getName(), -1, null, true, new Object[] { aWorld, aX, aY, aZ }); + rArrow.setArrowItem(aStack); + return rArrow; + } + + @Override + public EntityArrow getProjectile(GT_MetaBase_Item aItem, SubTag aProjectileType, ItemStack aStack, World aWorld, + EntityLivingBase aEntity, float aSpeed) { + if (!hasProjectile(aItem, aProjectileType, aStack)) { + return null; + } + GT_Entity_Arrow rArrow = (GT_Entity_Arrow) GT_Utility.callConstructor( + this.mArrow.getName(), + -1, + null, + true, + new Object[] { aWorld, aEntity, this.mSpeedMultiplier * aSpeed }); + rArrow.setArrowItem(aStack); + return rArrow; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Arrow_Potion.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Arrow_Potion.java new file mode 100644 index 0000000000..3643de7b77 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Arrow_Potion.java @@ -0,0 +1,71 @@ +package gregtech.common.items.behaviors; + +import net.minecraft.enchantment.Enchantment; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.projectile.EntityArrow; +import net.minecraft.item.ItemStack; +import net.minecraft.potion.PotionEffect; +import net.minecraft.world.World; + +import gregtech.api.enums.SubTag; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.common.entities.GT_Entity_Arrow_Potion; + +public class Behaviour_Arrow_Potion extends Behaviour_Arrow { + + private final int[] mPotions; + + public Behaviour_Arrow_Potion(float aSpeed, float aPrecision, int... aPotions) { + super(GT_Entity_Arrow_Potion.class, aSpeed, aPrecision); + this.mPotions = aPotions; + } + + public Behaviour_Arrow_Potion(float aSpeed, float aPrecision, Enchantment aEnchantment, int aLevel, + int... aPotions) { + super(GT_Entity_Arrow_Potion.class, aSpeed, aPrecision, aEnchantment, aLevel); + this.mPotions = aPotions; + } + + @Override + public boolean onLeftClickEntity(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, Entity aEntity) { + if ((aEntity instanceof EntityLivingBase)) { + for (int i = 3; i < this.mPotions.length; i += 4) { + if (aEntity.worldObj.rand.nextInt(100) < this.mPotions[i]) { + ((EntityLivingBase) aEntity).addPotionEffect( + new PotionEffect( + this.mPotions[(i - 3)], + this.mPotions[(i - 2)], + this.mPotions[(i - 1)], + false)); + } + } + } + return super.onLeftClickEntity(aItem, aStack, aPlayer, aEntity); + } + + @Override + public EntityArrow getProjectile(GT_MetaBase_Item aItem, SubTag aProjectileType, ItemStack aStack, World aWorld, + double aX, double aY, double aZ) { + if (!hasProjectile(aItem, aProjectileType, aStack)) { + return null; + } + GT_Entity_Arrow_Potion rArrow = new GT_Entity_Arrow_Potion(aWorld, aX, aY, aZ); + rArrow.setArrowItem(aStack); + rArrow.setPotions(this.mPotions); + return rArrow; + } + + @Override + public EntityArrow getProjectile(GT_MetaBase_Item aItem, SubTag aProjectileType, ItemStack aStack, World aWorld, + EntityLivingBase aEntity, float aSpeed) { + if (!hasProjectile(aItem, aProjectileType, aStack)) { + return null; + } + GT_Entity_Arrow_Potion rArrow = new GT_Entity_Arrow_Potion(aWorld, aEntity, aSpeed); + rArrow.setArrowItem(aStack); + rArrow.setPotions(this.mPotions); + return rArrow; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Cover_Tool.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Cover_Tool.java new file mode 100644 index 0000000000..4241e07e4b --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Cover_Tool.java @@ -0,0 +1,193 @@ +package gregtech.common.items.behaviors; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.SoundResource; +import gregtech.api.interfaces.IItemBehaviour; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_CoverBehaviorBase; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.ISerializableObject; + +public class Behaviour_Cover_Tool extends Behaviour_None { + + public static final IItemBehaviour<GT_MetaBase_Item> INSTANCE = new Behaviour_Cover_Tool(); + private final String mTooltip = GT_LanguageManager + .addStringLocalization("gt.behaviour.cover_copy_paste", "Can copy/paste cover data."); + + private ISerializableObject mStoredData = GregTech_API.sNoBehavior.createDataObject(); + private int mCoverType; + private int mTickRateAddition = 0; + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + if (aWorld.isRemote) { + return false; + } + final NBTTagCompound tNBT = aStack.getTagCompound(); + final TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + final boolean isCopyMode = aPlayer.isSneaking(); + initDataFromNBT(tNBT); + if (((aPlayer instanceof EntityPlayerMP)) && (aItem.canUse(aStack, 100.0D))) { + if (isCopyMode) { + ArrayList<String> tList = new ArrayList<>(); + doCopy(tTileEntity, aWorld, aX, aY, aZ, side, hitX, hitY, hitZ, tList); + aItem.discharge(aStack, 100.0D, Integer.MAX_VALUE, true, false, false); + writeListToNBT(tList, tNBT, aPlayer); + saveDataToNBT(tNBT); + } else { + doPaste(tTileEntity, side, hitX, hitY, hitZ, aPlayer); + aItem.discharge(aStack, 25.0D, Integer.MAX_VALUE, true, false, false); + } + } + GT_Utility.doSoundAtClient(SoundResource.IC2_TOOLS_OD_SCANNER, 1, 1.0F, aX, aY, aZ); + return aPlayer instanceof EntityPlayerMP; + } + + private void initDataFromNBT(NBTTagCompound aNBT) { + if (aNBT != null) { + mCoverType = aNBT.getInteger("mCoverType"); + GT_CoverBehaviorBase<?> tBehavior = GregTech_API.getCoverBehaviorNew(mCoverType); + NBTBase tData = aNBT.getTag("mCoverData"); + if (tData != null) mStoredData = tBehavior.createDataObject(tData); + else mStoredData = GregTech_API.sNoBehavior.createDataObject(); + mTickRateAddition = aNBT.hasKey("mTickRateAddition") ? aNBT.getInteger("mTickRateAddition") : 0; + } + } + + private void saveDataToNBT(NBTTagCompound aNBT) { + aNBT.setInteger("mCoverType", mCoverType); + if (mStoredData == null) mStoredData = GregTech_API.sNoBehavior.createDataObject(); + aNBT.setTag("mCoverData", mStoredData.saveDataToNBT()); + aNBT.setInteger("mTickRateAddition", mTickRateAddition); + } + + @SuppressWarnings("rawtypes") + private void writeListToNBT(List aList, NBTTagCompound aNBT, EntityPlayer aPlayer) { + if (aList != null && aNBT != null) { + int tSize = aList.size(); + aNBT.setInteger("dataLinesCount", tSize); + for (int i = 0; i < tSize; i++) { + aNBT.setString("dataLines" + i, (String) aList.get(i)); + GT_Utility.sendChatToPlayer(aPlayer, (String) aList.get(i)); + } + } + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + private void doCopy(TileEntity aTileEntity, World aWorld, int aX, int aY, int aZ, ForgeDirection side, float hitX, + float hitY, float hitZ, List aList) { + aList.add( + "----- X: " + EnumChatFormatting.AQUA + + GT_Utility.formatNumbers(aX) + + EnumChatFormatting.RESET + + " Y: " + + EnumChatFormatting.AQUA + + GT_Utility.formatNumbers(aY) + + EnumChatFormatting.RESET + + " Z: " + + EnumChatFormatting.AQUA + + GT_Utility.formatNumbers(aZ) + + EnumChatFormatting.RESET + + " D: " + + EnumChatFormatting.AQUA + + aWorld.provider.dimensionId + + EnumChatFormatting.RESET + + " -----"); + if (aTileEntity instanceof ICoverable tCoverable) { + final ForgeDirection tSide = tCoverable.getCoverItemAtSide(side) != null ? side + : tCoverable.getCoverItemAtSide(GT_Utility.determineWrenchingSide(side, hitX, hitY, hitZ)) != null + ? GT_Utility.determineWrenchingSide(side, hitX, hitY, hitZ) + : ForgeDirection.UNKNOWN; + if (tSide != ForgeDirection.UNKNOWN) { + if (tCoverable.getCoverBehaviorAtSideNew(tSide) + .allowsCopyPasteTool()) { + mStoredData = tCoverable.getComplexCoverDataAtSide(tSide); + mCoverType = tCoverable.getCoverIDAtSide(tSide); + mTickRateAddition = tCoverable.getCoverInfoAtSide(tSide) + .getTickRateAddition(); + + aList.add("Block Side: " + EnumChatFormatting.AQUA + tSide.name() + EnumChatFormatting.RESET); + aList.add( + "Cover Type: " + EnumChatFormatting.GREEN + + tCoverable.getCoverItemAtSide(tSide) + .getDisplayName() + + EnumChatFormatting.RESET); + } else { + mStoredData = GregTech_API.sNoBehavior.createDataObject(); + mCoverType = 0; + mTickRateAddition = 0; + aList.add("Copy unavailable for this cover type"); + } + } else { + mStoredData = GregTech_API.sNoBehavior.createDataObject(); + mCoverType = 0; + mTickRateAddition = 0; + aList.add("No Cover Found"); + } + } else { + mStoredData = GregTech_API.sNoBehavior.createDataObject(); + mCoverType = 0; + mTickRateAddition = 0; + aList.add("No Cover Found"); + } + } + + private void doPaste(TileEntity aTileEntity, ForgeDirection side, float hitX, float hitY, float hitZ, + EntityPlayer aPlayer) { + if (aTileEntity instanceof ICoverable tCoverable) { + if (mCoverType == 0 || mStoredData == null) { + GT_Utility.sendChatToPlayer(aPlayer, "Please Copy a Valid Cover First."); + return; + } + final ForgeDirection tSide = tCoverable.getCoverItemAtSide(side) != null ? side + : tCoverable.getCoverItemAtSide(GT_Utility.determineWrenchingSide(side, hitX, hitY, hitZ)) != null + ? GT_Utility.determineWrenchingSide(side, hitX, hitY, hitZ) + : ForgeDirection.UNKNOWN; + if (tSide != ForgeDirection.UNKNOWN) { + int tCoverID = tCoverable.getCoverIDAtSide(tSide); + if (tCoverID == mCoverType) { + tCoverable.setCoverDataAtSide(tSide, mStoredData); + tCoverable.getCoverInfoAtSide(tSide) + .setTickRateAddition(mTickRateAddition); + GT_Utility.sendChatToPlayer(aPlayer, "Cover Data Pasted."); + } else { + GT_Utility.sendChatToPlayer(aPlayer, "Not Matched Cover."); + } + } else { + GT_Utility.sendChatToPlayer(aPlayer, "No Cover Found."); + } + } + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + try { + final NBTTagCompound tNBT = aStack.getTagCompound(); + final int tSize = tNBT.getInteger("dataLinesCount"); + if (tSize < 1) throw new Exception(); + aList.add(EnumChatFormatting.BLUE + "Stored Cover Data:"); + for (int i = 0; i < tSize; i++) { + aList.add(EnumChatFormatting.RESET + tNBT.getString("dataLines" + i)); + } + } catch (Exception e) { + aList.add(this.mTooltip); + } + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Crowbar.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Crowbar.java new file mode 100644 index 0000000000..97d3da4ca3 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Crowbar.java @@ -0,0 +1,61 @@ +package gregtech.common.items.behaviors; + +import static gregtech.api.enums.Mods.Railcraft; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.SoundResource; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Utility; + +public class Behaviour_Crowbar extends Behaviour_None { + + private final int mVanillaCosts; + private final int mEUCosts; + + public Behaviour_Crowbar(int aVanillaCosts, int aEUCosts) { + this.mVanillaCosts = aVanillaCosts; + this.mEUCosts = aEUCosts; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + if (aWorld.isRemote) { + return false; + } + if (GT_ModHandler.getModItem(Railcraft.ID, "fluid.creosote.bucket", 1L) != null) { + return false; + } + Block aBlock = aWorld.getBlock(aX, aY, aZ); + if (aBlock == null) { + return false; + } + byte aMeta = (byte) aWorld.getBlockMetadata(aX, aY, aZ); + if (aBlock == Blocks.rail) { + if (GT_ModHandler.damageOrDechargeItem(aStack, this.mVanillaCosts, this.mEUCosts, aPlayer)) { + aWorld.isRemote = true; + aWorld.setBlock(aX, aY, aZ, aBlock, (aMeta + 1) % 10, 0); + aWorld.isRemote = false; + GT_Utility.sendSoundToPlayers(aWorld, SoundResource.RANDOM_BREAK, 1.0F, -1.0F, aX, aY, aZ); + } + return true; + } + if ((aBlock == Blocks.detector_rail) || (aBlock == Blocks.activator_rail) || (aBlock == Blocks.golden_rail)) { + if (GT_ModHandler.damageOrDechargeItem(aStack, this.mVanillaCosts, this.mEUCosts, aPlayer)) { + aWorld.isRemote = true; + aWorld.setBlock(aX, aY, aZ, aBlock, aMeta / 8 * 8 + (aMeta % 8 + 1) % 6, 0); + aWorld.isRemote = false; + GT_Utility.sendSoundToPlayers(aWorld, SoundResource.RANDOM_BREAK, 1.0F, -1.0F, aX, aY, aZ); + } + return true; + } + return false; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_DataOrb.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_DataOrb.java new file mode 100644 index 0000000000..ae0627446c --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_DataOrb.java @@ -0,0 +1,105 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; + +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_Utility; + +public class Behaviour_DataOrb extends Behaviour_None { + + public static void copyInventory(ItemStack[] aInventory, ItemStack[] aNewContent, int aIndexlength) { + for (int i = 0; i < aIndexlength; i++) { + if (aNewContent[i] == null) { + aInventory[i] = null; + } else { + aInventory[i] = GT_Utility.copyOrNull(aNewContent[i]); + } + } + } + + public static String getDataName(ItemStack aStack) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + return ""; + } + return tNBT.getString("mDataName"); + } + + public static String getDataTitle(ItemStack aStack) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + return ""; + } + return tNBT.getString("mDataTitle"); + } + + public static NBTTagCompound setDataName(ItemStack aStack, String aDataName) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + tNBT = new NBTTagCompound(); + } + tNBT.setString("mDataName", aDataName); + aStack.setTagCompound(tNBT); + return tNBT; + } + + public static NBTTagCompound setDataTitle(ItemStack aStack, String aDataTitle) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + tNBT = new NBTTagCompound(); + } + tNBT.setString("mDataTitle", aDataTitle); + aStack.setTagCompound(tNBT); + return tNBT; + } + + public static ItemStack[] getNBTInventory(ItemStack aStack) { + ItemStack[] tInventory = new ItemStack[256]; + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + return tInventory; + } + NBTTagList tNBT_ItemList = tNBT.getTagList("Inventory", 10); + for (int i = 0; i < tNBT_ItemList.tagCount(); i++) { + NBTTagCompound tag = tNBT_ItemList.getCompoundTagAt(i); + byte slot = tag.getByte("Slot"); + if (slot >= 0) { + tInventory[slot] = GT_Utility.loadItem(tag); + } + } + return tInventory; + } + + public static NBTTagCompound setNBTInventory(ItemStack aStack, ItemStack[] aInventory) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + tNBT = new NBTTagCompound(); + } + NBTTagList tNBT_ItemList = new NBTTagList(); + for (int i = 0; i < aInventory.length; i++) { + ItemStack stack = aInventory[i]; + if (stack != null) { + NBTTagCompound tag = new NBTTagCompound(); + tag.setByte("Slot", (byte) i); + stack.writeToNBT(tag); + tNBT_ItemList.appendTag(tag); + } + } + tNBT.setTag("Inventory", tNBT_ItemList); + aStack.setTagCompound(tNBT); + return tNBT; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + if (!(getDataTitle(aStack).length() == 0)) { + aList.add(getDataTitle(aStack)); + aList.add(getDataName(aStack)); + } + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_DataStick.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_DataStick.java new file mode 100644 index 0000000000..e9db3195c2 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_DataStick.java @@ -0,0 +1,52 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.item.ItemStack; + +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_Utility; + +public class Behaviour_DataStick extends Behaviour_None { + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + String tString = GT_Utility.ItemNBT.getBookTitle(aStack); + if (GT_Utility.isStringValid(tString)) { + aList.add(tString); + } + tString = GT_Utility.ItemNBT.getBookAuthor(aStack); + if (GT_Utility.isStringValid(tString)) { + aList.add("by " + tString); + } + short tMapID = GT_Utility.ItemNBT.getMapID(aStack); + if (tMapID >= 0) { + aList.add("Map ID: " + tMapID); + } + tString = GT_Utility.ItemNBT.getPunchCardData(aStack); + if (GT_Utility.isStringValid(tString)) { + aList.add("Punch Card Data"); + int i = 0; + int j = tString.length(); + for (; i < j; i += 64) { + aList.add(tString.substring(i, Math.min(i + 64, j))); + } + } + short sTier = GT_Utility.ItemNBT.getNBT(aStack) + .getShort("rocket_tier"); + if (sTier > 0 && sTier < 100) { + aList.add("Rocket Schematic Tier: " + sTier); + } else if (sTier >= 100) { + switch (sTier) { + case 100 -> aList.add("Moonbuggy Schematic"); + case 101 -> aList.add("Cargo-Rocket Schematic"); + case 102 -> aList.add("Astro-Miner Schematic"); + } + } + long lastUpdate = GT_Utility.ItemNBT.getNBT(aStack) + .getLong("lastUpdate"); + if (lastUpdate != 0) aList.add(String.format("Last update at: %tc", lastUpdate)); + + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Hoe.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Hoe.java new file mode 100644 index 0000000000..167eccdf49 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Hoe.java @@ -0,0 +1,72 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.entity.player.UseHoeEvent; + +import cpw.mods.fml.common.eventhandler.Event; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.WorldSpawnedEventBuilder; + +public class Behaviour_Hoe extends Behaviour_None { + + private final int mCosts; + private final String mTooltip = GT_LanguageManager.addStringLocalization("gt.behaviour.hoe", "Can till Dirt"); + + public Behaviour_Hoe(int aCosts) { + this.mCosts = aCosts; + } + + @Override + public boolean onItemUse(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, int ordinalSide, float hitX, float hitY, float hitZ) { + if (!aPlayer.canPlayerEdit(aX, aY, aZ, ordinalSide, aStack)) { + return false; + } + UseHoeEvent event = new UseHoeEvent(aPlayer, aStack, aWorld, aX, aY, aZ); + if (MinecraftForge.EVENT_BUS.post(event)) { + return false; + } + if (event.getResult() == Event.Result.ALLOW) { + if (!aPlayer.capabilities.isCreativeMode) { + ((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts); + } + return true; + } + Block aBlock = aWorld.getBlock(aX, aY, aZ); + if ((ordinalSide != 0) && (GT_Utility.isBlockAir(aWorld, aX, aY + 1, aZ)) + && ((aBlock == Blocks.grass) || (aBlock == Blocks.dirt))) { + new WorldSpawnedEventBuilder.SoundEventBuilder() + .setVolume((Blocks.farmland.stepSound.getVolume() + 1.0F) / 2.0F) + .setPitch(Blocks.farmland.stepSound.getPitch() * 0.8F) + .setIdentifier(Blocks.farmland.stepSound.getStepResourcePath()) + .setPosition(aX + 0.5F, aY + 0.5F, aZ + 0.5F) + .setWorld(aWorld) + .run(); + if (aWorld.isRemote) { + return true; + } + aWorld.setBlock(aX, aY, aZ, Blocks.farmland); + if (!aPlayer.capabilities.isCreativeMode) { + ((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts); + } + return true; + } + return false; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + aList.add(this.mTooltip); + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Lighter.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Lighter.java new file mode 100644 index 0000000000..a4c26e2254 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Lighter.java @@ -0,0 +1,140 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.monster.EntityCreeper; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import codechicken.lib.math.MathHelper; +import gregtech.api.enums.SoundResource; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; + +public class Behaviour_Lighter extends Behaviour_None { + + private final ItemStack mEmptyLighter; + private final ItemStack mUsedLighter; + private final ItemStack mFullLighter; + private final long mFuelAmount; + private final String mTooltip = GT_LanguageManager + .addStringLocalization("gt.behaviour.lighter.tooltip", "Can light things on Fire"); + private final String mTooltipUses = GT_LanguageManager + .addStringLocalization("gt.behaviour.lighter.uses", "Remaining Uses:"); + private final String mTooltipUnstackable = GT_LanguageManager + .addStringLocalization("gt.behaviour.unstackable", "Not usable when stacked!"); + + public Behaviour_Lighter(ItemStack aEmptyLighter, ItemStack aUsedLighter, ItemStack aFullLighter, + long aFuelAmount) { + this.mFullLighter = aFullLighter; + this.mUsedLighter = aUsedLighter; + this.mEmptyLighter = aEmptyLighter; + this.mFuelAmount = aFuelAmount; + } + + @Override + public boolean onLeftClickEntity(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, Entity aEntity) { + if ((aPlayer.worldObj.isRemote) || (aStack.stackSize != 1)) { + return false; + } + boolean rOutput = false; + if ((aEntity instanceof EntityCreeper)) { + prepare(aStack); + long tFuelAmount = GT_Utility.ItemNBT.getLighterFuel(aStack); + if (GT_Utility.areStacksEqual(aStack, this.mUsedLighter, true)) { + GT_Utility.sendSoundToPlayers( + aPlayer.worldObj, + SoundResource.FIRE_IGNITE, + 1.0F, + 1.0F, + MathHelper.floor_double(aEntity.posX), + MathHelper.floor_double(aEntity.posY), + MathHelper.floor_double(aEntity.posZ)); + ((EntityCreeper) aEntity).func_146079_cb(); + if (!aPlayer.capabilities.isCreativeMode) { + tFuelAmount -= 1L; + } + rOutput = true; + } + GT_Utility.ItemNBT.setLighterFuel(aStack, tFuelAmount); + if (tFuelAmount <= 0L) { + useUp(aStack); + } + } + return rOutput; + } + + @Override + public boolean onItemUse(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, int ordinalSide, float hitX, float hitY, float hitZ) { + return false; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + if ((aWorld.isRemote) || (aStack.stackSize != 1)) { + return false; + } + boolean rOutput = false; + + aX += side.offsetX; + aY += side.offsetY; + aZ += side.offsetZ; + if ((!GT_Utility.isBlockAir(aWorld, aX, aY, aZ)) + || (!aPlayer.canPlayerEdit(aX, aY, aZ, side.ordinal(), aStack))) { + return false; + } + prepare(aStack); + long tFuelAmount = GT_Utility.ItemNBT.getLighterFuel(aStack); + if (GT_Utility.areStacksEqual(aStack, this.mUsedLighter, true)) { + GT_Utility.sendSoundToPlayers(aWorld, SoundResource.FIRE_IGNITE, 1.0F, 1.0F, aX, aY, aZ); + aWorld.setBlock(aX, aY, aZ, Blocks.fire); + if (!aPlayer.capabilities.isCreativeMode) { + tFuelAmount -= 1L; + } + rOutput = true; + } + GT_Utility.ItemNBT.setLighterFuel(aStack, tFuelAmount); + if (tFuelAmount <= 0L) { + useUp(aStack); + } + return rOutput; + } + + private void prepare(ItemStack aStack) { + if (GT_Utility.areStacksEqual(aStack, this.mFullLighter, true)) { + aStack.func_150996_a(this.mUsedLighter.getItem()); + Items.feather.setDamage(aStack, Items.feather.getDamage(this.mUsedLighter)); + GT_Utility.ItemNBT.setLighterFuel(aStack, this.mFuelAmount); + } + } + + private void useUp(ItemStack aStack) { + if (this.mEmptyLighter == null) { + aStack.stackSize -= 1; + } else { + aStack.func_150996_a(this.mEmptyLighter.getItem()); + Items.feather.setDamage(aStack, Items.feather.getDamage(this.mEmptyLighter)); + } + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + aList.add(this.mTooltip); + NBTTagCompound tNBT = aStack.getTagCompound(); + long tFuelAmount = tNBT == null ? this.mFuelAmount + : GT_Utility.areStacksEqual(aStack, this.mFullLighter, true) ? this.mFuelAmount + : tNBT.getLong("GT.LighterFuel"); + aList.add(this.mTooltipUses + " " + tFuelAmount); + aList.add(this.mTooltipUnstackable); + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_None.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_None.java new file mode 100644 index 0000000000..4ce7f60da0 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_None.java @@ -0,0 +1,96 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.block.BlockDispenser; +import net.minecraft.dispenser.BehaviorDefaultDispenseItem; +import net.minecraft.dispenser.IBlockSource; +import net.minecraft.dispenser.IPosition; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.projectile.EntityArrow; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.SubTag; +import gregtech.api.interfaces.IItemBehaviour; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_Utility; + +public class Behaviour_None implements IItemBehaviour<GT_MetaBase_Item> { + + @Override + public boolean onLeftClickEntity(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, Entity aEntity) { + return false; + } + + @Override + public boolean onItemUse(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, int ordinalSide, float hitX, float hitY, float hitZ) { + return false; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + return false; + } + + @Override + public ItemStack onItemRightClick(GT_MetaBase_Item aItem, ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + return aStack; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + return aList; + } + + @Override + public void onUpdate(GT_MetaBase_Item aItem, ItemStack aStack, World aWorld, Entity aPlayer, int aTimer, + boolean aIsInHand) {} + + @Override + public boolean isItemStackUsable(GT_MetaBase_Item aItem, ItemStack aStack) { + return true; + } + + @Override + public boolean canDispense(GT_MetaBase_Item aItem, IBlockSource aSource, ItemStack aStack) { + return false; + } + + @Override + public ItemStack onDispense(GT_MetaBase_Item aItem, IBlockSource aSource, ItemStack aStack) { + EnumFacing enumfacing = BlockDispenser.func_149937_b(aSource.getBlockMetadata()); + IPosition iposition = BlockDispenser.func_149939_a(aSource); + ItemStack itemstack1 = aStack.splitStack(1); + BehaviorDefaultDispenseItem.doDispense(aSource.getWorld(), itemstack1, 6, enumfacing, iposition); + return aStack; + } + + @Override + public boolean hasProjectile(GT_MetaBase_Item aItem, SubTag aProjectileType, ItemStack aStack) { + return false; + } + + @Override + public EntityArrow getProjectile(GT_MetaBase_Item aItem, SubTag aProjectileType, ItemStack aStack, World aWorld, + double aX, double aY, double aZ) { + return null; + } + + @Override + public EntityArrow getProjectile(GT_MetaBase_Item aItem, SubTag aProjectileType, ItemStack aStack, World aWorld, + EntityLivingBase aEntity, float aSpeed) { + return null; + } + + @Deprecated + public String trans(String aKey, String aEnglish) { + return GT_Utility.trans(aKey, aEnglish); + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Essentia.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Essentia.java new file mode 100644 index 0000000000..867eb25103 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Essentia.java @@ -0,0 +1,54 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.SoundResource; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; +import thaumcraft.api.aspects.IEssentiaTransport; + +public class Behaviour_Plunger_Essentia extends Behaviour_None { + + private final int mCosts; + private final String mTooltip = GT_LanguageManager + .addStringLocalization("gt.behaviour.plunger.essentia", "Clears Essentia from Containers and Tubes"); + + public Behaviour_Plunger_Essentia(int aCosts) { + this.mCosts = aCosts; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + if (aWorld.isRemote) { + return false; + } + TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (((aTileEntity instanceof IEssentiaTransport)) && ((aPlayer.capabilities.isCreativeMode) + || (((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts)))) { + GT_Utility.sendSoundToPlayers(aWorld, SoundResource.IC2_TOOLS_RUBBER_TRAMPOLINE, 1.0F, -1.0F, aX, aY, aZ); + for (ForgeDirection tDirection : ForgeDirection.VALID_DIRECTIONS) { + ((IEssentiaTransport) aTileEntity).takeEssentia( + ((IEssentiaTransport) aTileEntity).getEssentiaType(tDirection), + ((IEssentiaTransport) aTileEntity).getEssentiaAmount(tDirection), + tDirection); + } + return true; + } + return false; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + aList.add(this.mTooltip); + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Fluid.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Fluid.java new file mode 100644 index 0000000000..c62cb5c4e5 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Fluid.java @@ -0,0 +1,75 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.IFluidHandler; + +import gregtech.api.enums.SoundResource; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; + +public class Behaviour_Plunger_Fluid extends Behaviour_None { + + private final int mCosts; + private final String mTooltip = GT_LanguageManager + .addStringLocalization("gt.behaviour.plunger.fluid", "Clears 1000 Liters of Fluid from Tanks"); + + public Behaviour_Plunger_Fluid(int aCosts) { + this.mCosts = aCosts; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + if (aWorld.isRemote) { + return false; + } + TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if ((aTileEntity instanceof IFluidHandler)) { + for (ForgeDirection tDirection : ForgeDirection.VALID_DIRECTIONS) { + if (((IFluidHandler) aTileEntity).drain(tDirection, 1000, false) != null) { + if ((aPlayer.capabilities.isCreativeMode) + || (((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts))) { + ((IFluidHandler) aTileEntity).drain(tDirection, 1000, true); + GT_Utility.sendSoundToPlayers( + aWorld, + SoundResource.IC2_TOOLS_RUBBER_TRAMPOLINE, + 1.0F, + -1.0F, + aX, + aY, + aZ); + return true; + } + } + } + } + if (aTileEntity instanceof IGregTechTileEntity tTileEntity) { + IMetaTileEntity mTileEntity = tTileEntity.getMetaTileEntity(); + if (mTileEntity instanceof GT_MetaTileEntity_BasicTank machine) { + if (machine.mFluid != null && machine.mFluid.amount > 0) + machine.mFluid.amount = machine.mFluid.amount - Math.min(machine.mFluid.amount, 1000); + GT_Utility + .sendSoundToPlayers(aWorld, SoundResource.IC2_TOOLS_RUBBER_TRAMPOLINE, 1.0F, -1.0F, aX, aY, aZ); + return true; + } + } + return false; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + aList.add(this.mTooltip); + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Item.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Item.java new file mode 100644 index 0000000000..a5fa868a00 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Plunger_Item.java @@ -0,0 +1,88 @@ +package gregtech.common.items.behaviors; + +import java.util.HashMap; +import java.util.List; + +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.SoundResource; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.metatileentity.IMetaTileEntityItemPipe; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; + +public class Behaviour_Plunger_Item extends Behaviour_None { + + private final int mCosts; + private final String mTooltip = GT_LanguageManager + .addStringLocalization("gt.behaviour.plunger.item", "Clears Items from Pipes"); + + public Behaviour_Plunger_Item(int aCosts) { + this.mCosts = aCosts; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + if (aWorld.isRemote) { + return false; + } + TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (aTileEntity instanceof IGregTechTileEntity gtTE) { + IMetaTileEntity tMetaTileEntity = gtTE.getMetaTileEntity(); + if ((tMetaTileEntity instanceof IMetaTileEntityItemPipe)) { + for (IMetaTileEntityItemPipe tTileEntity : GT_Utility + .sortMapByValuesAcending( + IMetaTileEntityItemPipe.Util + .scanPipes((IMetaTileEntityItemPipe) tMetaTileEntity, new HashMap<>(), 0L, false, true)) + .keySet()) { + int i = 0; + for (int j = tTileEntity.getSizeInventory(); i < j; i++) { + if (tTileEntity.isValidSlot(i)) { + if ((tTileEntity.getStackInSlot(i) != null) && ((aPlayer.capabilities.isCreativeMode) + || (((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts)))) { + final ItemStack tStack = tTileEntity.decrStackSize(i, 64); + if (tStack != null) { + final EntityItem tEntity = new EntityItem( + aWorld, + gtTE.getOffsetX(side, 1) + 0.5D, + gtTE.getOffsetY(side, 1) + 0.5D, + gtTE.getOffsetZ(side, 1) + 0.5D, + tStack); + tEntity.motionX = 0.0D; + tEntity.motionY = 0.0D; + tEntity.motionZ = 0.0D; + aWorld.spawnEntityInWorld(tEntity); + GT_Utility.sendSoundToPlayers( + aWorld, + SoundResource.IC2_TOOLS_RUBBER_TRAMPOLINE, + 1.0F, + -1.0F, + aX, + aY, + aZ); + } + return true; + } + } + } + } + } + } + return false; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + aList.add(this.mTooltip); + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_PrintedPages.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_PrintedPages.java new file mode 100644 index 0000000000..e3c4d58525 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_PrintedPages.java @@ -0,0 +1,39 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_Utility; + +public class Behaviour_PrintedPages extends Behaviour_None { + + public static String getTitle(ItemStack aStack) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + return ""; + } + return tNBT.getString("title"); + } + + public static String getAuthor(ItemStack aStack) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + return ""; + } + return tNBT.getString("author"); + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + if (GT_Utility.isStringValid(getTitle(aStack))) { + aList.add(getTitle(aStack)); + } + if (GT_Utility.isStringValid(getAuthor(aStack))) { + aList.add("by " + getAuthor(aStack)); + } + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Prospecting.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Prospecting.java new file mode 100644 index 0000000000..e64722fb87 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Prospecting.java @@ -0,0 +1,159 @@ +package gregtech.common.items.behaviors; + +import java.util.List; +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockLiquid; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.IFluidBlock; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.Materials; +import gregtech.api.enums.SoundResource; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.objects.ItemData; +import gregtech.api.objects.XSTR; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import gregtech.common.blocks.GT_Block_Ores_Abstract; +import gregtech.common.blocks.GT_TileEntity_Ores; + +public class Behaviour_Prospecting extends Behaviour_None { + + private final int mVanillaCosts; + private final int mEUCosts; + private final String mTooltip = GT_LanguageManager + .addStringLocalization("gt.behaviour.prospecting", "Usable for Prospecting"); + + public Behaviour_Prospecting(int aVanillaCosts, int aEUCosts) { + this.mVanillaCosts = aVanillaCosts; + this.mEUCosts = aEUCosts; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + if (aWorld.isRemote) { + return false; + } + Block aBlock = aWorld.getBlock(aX, aY, aZ); + if (aBlock == null) { + return false; + } + byte aMeta = (byte) aWorld.getBlockMetadata(aX, aY, aZ); + + ItemData tAssociation = GT_OreDictUnificator.getAssociation(new ItemStack(aBlock, 1, aMeta)); + if (tAssociation != null && tAssociation.mPrefix != null + && tAssociation.mMaterial != null + && tAssociation.mPrefix.toString() + .startsWith("ore")) { + GT_Utility.sendChatToPlayer( + aPlayer, + GT_Utility.trans("100", "This is ") + tAssociation.mMaterial.mMaterial.mDefaultLocalName + + GT_Utility.trans("101", " Ore.")); + GT_Utility.sendSoundToPlayers(aWorld, SoundResource.RANDOM_ANVIL_USE, 1.0F, -1.0F, aX, aY, aZ); + return true; + } + + if (aBlock.isReplaceableOreGen(aWorld, aX, aY, aZ, Blocks.stone) + || aBlock.isReplaceableOreGen(aWorld, aX, aY, aZ, Blocks.netherrack) + || aBlock.isReplaceableOreGen(aWorld, aX, aY, aZ, Blocks.end_stone) + || aBlock.isReplaceableOreGen(aWorld, aX, aY, aZ, GregTech_API.sBlockStones) + || aBlock.isReplaceableOreGen(aWorld, aX, aY, aZ, GregTech_API.sBlockGranites) + || aBlock == GregTech_API.sBlockOresUb1 + || aBlock == GregTech_API.sBlockOresUb2 + || aBlock == GregTech_API.sBlockOresUb3 + || aBlock == GregTech_API.sBlockOres1) { + if (GT_ModHandler.damageOrDechargeItem(aStack, this.mVanillaCosts, this.mEUCosts, aPlayer)) { + GT_Utility.sendSoundToPlayers(aWorld, SoundResource.RANDOM_ANVIL_USE, 1.0F, -1.0F, aX, aY, aZ); + int tMetaID; + int tQuality = aItem instanceof GT_MetaGenerated_Tool ? aItem.getHarvestLevel(aStack, "") : 0; + int tX = aX, tY = aY, tZ = aZ; + Block tBlock; + for (int i = 0, j = 6 + tQuality; i < j; i++) { + tX -= side.offsetX; + tY -= side.offsetY; + tZ -= side.offsetZ; + + tBlock = aWorld.getBlock(tX, tY, tZ); + if (tBlock == Blocks.lava || tBlock == Blocks.flowing_lava) { + GT_Utility + .sendChatToPlayer(aPlayer, GT_Utility.trans("102", "There is Lava behind this Rock.")); + break; + } + if (tBlock instanceof BlockLiquid || tBlock instanceof IFluidBlock) { + GT_Utility + .sendChatToPlayer(aPlayer, GT_Utility.trans("103", "There is a Liquid behind this Rock.")); + break; + } + if (tBlock == Blocks.monster_egg || !GT_Utility.hasBlockHitBox(aWorld, tX, tY, tZ)) { + GT_Utility.sendChatToPlayer( + aPlayer, + GT_Utility.trans("104", "There is an Air Pocket behind this Rock.")); + break; + } + if (tBlock != aBlock) { + if (i < 4) GT_Utility.sendChatToPlayer( + aPlayer, + GT_Utility.trans("105", "Material is changing behind this Rock.")); + break; + } + } + + final Random tRandom = new XSTR(aX ^ aY ^ aZ ^ side.ordinal()); + for (int i = 0, j = 9 + 2 * tQuality; i < j; i++) { + tX = aX - 4 - tQuality + tRandom.nextInt(j); + tY = aY - 4 - tQuality + tRandom.nextInt(j); + tZ = aZ - 4 - tQuality + tRandom.nextInt(j); + tBlock = aWorld.getBlock(tX, tY, tZ); + if (tBlock instanceof GT_Block_Ores_Abstract) { + final TileEntity tTileEntity = aWorld.getTileEntity(tX, tY, tZ); + if (tTileEntity instanceof GT_TileEntity_Ores) { + final Materials tMaterial = GregTech_API.sGeneratedMaterials[((GT_TileEntity_Ores) tTileEntity).mMetaData + % 1000]; + if (tMaterial != null && tMaterial != Materials._NULL) { + GT_Utility.sendChatToPlayer( + aPlayer, + GT_Utility.trans("106", "Found traces of ") + tMaterial.mDefaultLocalName + + GT_Utility.trans("101", " Ore.")); + return true; + } + } + } else { + tMetaID = aWorld.getBlockMetadata(tX, tY, tZ); + tAssociation = GT_OreDictUnificator.getAssociation(new ItemStack(tBlock, 1, tMetaID)); + if (tAssociation != null && tAssociation.mPrefix != null + && tAssociation.mMaterial != null + && tAssociation.mPrefix.toString() + .startsWith("ore")) { + GT_Utility.sendChatToPlayer( + aPlayer, + GT_Utility.trans("106", "Found traces of ") + + tAssociation.mMaterial.mMaterial.mDefaultLocalName + + GT_Utility.trans("101", " Ore.")); + return true; + } + } + } + GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("107", "No Ores found.")); + return true; + } + } + return false; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + aList.add(this.mTooltip); + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Scanner.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Scanner.java new file mode 100644 index 0000000000..22b708e384 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Scanner.java @@ -0,0 +1,65 @@ +package gregtech.common.items.behaviors; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.SoundResource; +import gregtech.api.interfaces.IItemBehaviour; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; + +public class Behaviour_Scanner extends Behaviour_None { + + public static final IItemBehaviour<GT_MetaBase_Item> INSTANCE = new Behaviour_Scanner(); + private final String mTooltip = GT_LanguageManager + .addStringLocalization("gt.behaviour.scanning", "Can scan Blocks in World"); + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + final NBTTagCompound tNBT = aStack.getTagCompound(); + if (((aPlayer instanceof EntityPlayerMP)) && (aItem.canUse(aStack, 20000.0D))) { + final ArrayList<String> tList = new ArrayList<>(); + if (aItem.use( + aStack, + GT_Utility.getCoordinateScan(tList, aPlayer, aWorld, 1, aX, aY, aZ, side, hitX, hitY, hitZ), + aPlayer)) { + final int tList_sS = tList.size(); + tNBT.setInteger("dataLinesCount", tList_sS); + for (int i = 0; i < tList_sS; i++) { + tNBT.setString("dataLines" + i, tList.get(i)); + GT_Utility.sendChatToPlayer(aPlayer, tList.get(i)); + } + } + return true; + } + GT_Utility.doSoundAtClient(SoundResource.IC2_TOOLS_OD_SCANNER, 1, 1.0F, aX, aY, aZ); + // doGuiAtClient() + return aPlayer instanceof EntityPlayerMP; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + try { + NBTTagCompound tNBT = aStack.getTagCompound(); + int lines = tNBT.getInteger("dataLinesCount"); + if (lines < 1) throw new Exception(); + aList.add(EnumChatFormatting.BLUE + "Block scan data result:"); + for (int i = 0; i < lines; i++) { + aList.add(EnumChatFormatting.RESET + tNBT.getString("dataLines" + i)); + } + } catch (Exception e) { + aList.add(this.mTooltip); + } + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Scoop.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Scoop.java new file mode 100644 index 0000000000..65be65a96d --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Scoop.java @@ -0,0 +1,63 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; + +import forestry.api.lepidopterology.EnumFlutterType; +import forestry.api.lepidopterology.IButterfly; +import forestry.api.lepidopterology.IEntityButterfly; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.util.GT_LanguageManager; + +public class Behaviour_Scoop extends Behaviour_None { + + private final int mCosts; + private final String mTooltip = GT_LanguageManager + .addStringLocalization("gt.behaviour.scoop", "Catches Butterflies on Leftclick"); + + public Behaviour_Scoop(int aCosts) { + this.mCosts = aCosts; + } + + @Override + public boolean onLeftClickEntity(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, Entity aEntity) { + if ((aEntity instanceof IEntityButterfly)) { + if (aPlayer.worldObj.isRemote) { + return true; + } + if ((aPlayer.capabilities.isCreativeMode) + || (((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts))) { + IButterfly tButterfly = ((IEntityButterfly) aEntity).getButterfly(); + tButterfly.getGenome() + .getPrimary() + .getRoot() + .getBreedingTracker(aEntity.worldObj, aPlayer.getGameProfile()) + .registerCatch(tButterfly); + aPlayer.worldObj.spawnEntityInWorld( + new EntityItem( + aPlayer.worldObj, + aEntity.posX, + aEntity.posY, + aEntity.posZ, + tButterfly.getGenome() + .getPrimary() + .getRoot() + .getMemberStack(tButterfly.copy(), EnumFlutterType.BUTTERFLY.ordinal()))); + aEntity.setDead(); + } + return true; + } + return false; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + aList.add(this.mTooltip); + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Screwdriver.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Screwdriver.java new file mode 100644 index 0000000000..d940226b84 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Screwdriver.java @@ -0,0 +1,52 @@ +package gregtech.common.items.behaviors; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.SoundResource; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Utility; + +public class Behaviour_Screwdriver extends Behaviour_None { + + private final int mVanillaCosts; + private final int mEUCosts; + + public Behaviour_Screwdriver(int aVanillaCosts, int aEUCosts) { + this.mVanillaCosts = aVanillaCosts; + this.mEUCosts = aEUCosts; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + if (aWorld.isRemote) { + return false; + } + Block aBlock = aWorld.getBlock(aX, aY, aZ); + if (aBlock == null) { + return false; + } + byte aMeta = (byte) aWorld.getBlockMetadata(aX, aY, aZ); + if ((aBlock == Blocks.unpowered_repeater) || (aBlock == Blocks.powered_repeater)) { + if (GT_ModHandler.damageOrDechargeItem(aStack, this.mVanillaCosts, this.mEUCosts, aPlayer)) { + aWorld.setBlockMetadataWithNotify(aX, aY, aZ, aMeta / 4 * 4 + (aMeta % 4 + 1) % 4, 3); + GT_Utility.sendSoundToPlayers(aWorld, SoundResource.IC2_TOOLS_WRENCH, 1.0F, -1.0F, aX, aY, aZ); + } + return true; + } + if ((aBlock == Blocks.unpowered_comparator) || (aBlock == Blocks.powered_comparator)) { + if (GT_ModHandler.damageOrDechargeItem(aStack, this.mVanillaCosts, this.mEUCosts, aPlayer)) { + aWorld.setBlockMetadataWithNotify(aX, aY, aZ, aMeta / 4 * 4 + (aMeta % 4 + 1) % 4, 3); + GT_Utility.sendSoundToPlayers(aWorld, SoundResource.IC2_TOOLS_WRENCH, 1.0F, -1.0F, aX, aY, aZ); + } + return true; + } + return false; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Sense.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Sense.java new file mode 100644 index 0000000000..b2ab0031ad --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Sense.java @@ -0,0 +1,56 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.util.GT_LanguageManager; +import ic2.api.crops.ICropTile; + +public class Behaviour_Sense extends Behaviour_None { + + private final int mCosts; + private final String mTooltip = GT_LanguageManager + .addStringLocalization("gt.behaviour.sense", "Rightclick to harvest Crop Sticks"); + + public Behaviour_Sense(int aCosts) { + this.mCosts = aCosts; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + if (aWorld.isRemote) { + return false; + } + TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if ((tTileEntity instanceof ICropTile)) { + for (int i = -2; i < 3; i++) { + for (int j = -2; j < 3; j++) { + for (int k = -2; k < 3; k++) { + if ((aStack.stackSize > 0) + && (((tTileEntity = aWorld.getTileEntity(aX + i, aY + j, aZ + k)) instanceof ICropTile)) + && (((ICropTile) tTileEntity).harvest(true)) + && (!aPlayer.capabilities.isCreativeMode)) { + ((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts / 20); + } + } + } + } + return true; + } + return false; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + aList.add(this.mTooltip); + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_SensorKit.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_SensorKit.java new file mode 100644 index 0000000000..b12159d058 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_SensorKit.java @@ -0,0 +1,56 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.ItemList; +import gregtech.api.interfaces.tileentity.IGregTechDeviceInformation; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; + +public class Behaviour_SensorKit extends Behaviour_None { + + private final String mTooltip = GT_LanguageManager.addStringLocalization( + "gt.behaviour.sensorkit.tooltip", + "Used to display Information using the Mod Nuclear Control"); + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + if ((aPlayer instanceof EntityPlayerMP)) { + TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (((tTileEntity instanceof IInventory)) && (!((IInventory) tTileEntity).isUseableByPlayer(aPlayer))) { + return false; + } + if (((tTileEntity instanceof IGregTechDeviceInformation)) + && (((IGregTechDeviceInformation) tTileEntity).isGivingInformation())) { + GT_Utility.setStack(aStack, ItemList.NC_SensorCard.get(aStack.stackSize)); + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + tNBT = new NBTTagCompound(); + } + tNBT.setInteger("x", aX); + tNBT.setInteger("y", aY); + tNBT.setInteger("z", aZ); + aStack.setTagCompound(tNBT); + } + return true; + } + return false; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + aList.add(this.mTooltip); + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_SoftHammer.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_SoftHammer.java new file mode 100644 index 0000000000..159a0c4b27 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_SoftHammer.java @@ -0,0 +1,131 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.SoundResource; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; + +public class Behaviour_SoftHammer extends Behaviour_None { + + private final int mCosts; + private final String mTooltip = GT_LanguageManager + .addStringLocalization("gt.behaviour.softhammer", "Activates and Deactivates Machines"); + + public Behaviour_SoftHammer(int aCosts) { + this.mCosts = aCosts; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + if (aWorld.isRemote) { + return false; + } + Block aBlock = aWorld.getBlock(aX, aY, aZ); + if (aBlock == null) { + return false; + } + byte aMeta = (byte) aWorld.getBlockMetadata(aX, aY, aZ); + if (aBlock == Blocks.lit_redstone_lamp) { + if ((aPlayer.capabilities.isCreativeMode) + || (((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts))) { + aWorld.isRemote = true; + aWorld.setBlock(aX, aY, aZ, Blocks.redstone_lamp, 0, 0); + aWorld.isRemote = false; + GT_Utility + .sendSoundToPlayers(aWorld, SoundResource.IC2_TOOLS_RUBBER_TRAMPOLINE, 1.0F, -1.0F, aX, aY, aZ); + } + return true; + } + if (aBlock == Blocks.redstone_lamp) { + if ((aPlayer.capabilities.isCreativeMode) + || (((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts))) { + aWorld.isRemote = true; + aWorld.setBlock(aX, aY, aZ, Blocks.lit_redstone_lamp, 0, 0); + aWorld.isRemote = false; + GT_Utility + .sendSoundToPlayers(aWorld, SoundResource.IC2_TOOLS_RUBBER_TRAMPOLINE, 1.0F, -1.0F, aX, aY, aZ); + } + return true; + } + if (aBlock == Blocks.golden_rail) { + if ((aPlayer.capabilities.isCreativeMode) + || (((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts))) { + aWorld.isRemote = true; + aWorld.setBlock(aX, aY, aZ, aBlock, (aMeta + 8) % 16, 0); + aWorld.isRemote = false; + GT_Utility + .sendSoundToPlayers(aWorld, SoundResource.IC2_TOOLS_RUBBER_TRAMPOLINE, 1.0F, -1.0F, aX, aY, aZ); + } + return true; + } + if (aBlock == Blocks.activator_rail) { + if ((aPlayer.capabilities.isCreativeMode) + || (((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts))) { + aWorld.isRemote = true; + aWorld.setBlock(aX, aY, aZ, aBlock, (aMeta + 8) % 16, 0); + aWorld.isRemote = false; + GT_Utility + .sendSoundToPlayers(aWorld, SoundResource.IC2_TOOLS_RUBBER_TRAMPOLINE, 1.0F, -1.0F, aX, aY, aZ); + } + return true; + } + if ((aBlock == Blocks.log) || (aBlock == Blocks.log2) || (aBlock == Blocks.hay_block)) { + if ((aPlayer.capabilities.isCreativeMode) + || (((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts))) { + aWorld.setBlockMetadataWithNotify(aX, aY, aZ, (aMeta + 4) % 12, 3); + } + return true; + } + if ((aBlock == Blocks.piston) || (aBlock == Blocks.sticky_piston) + || (aBlock == Blocks.dispenser) + || (aBlock == Blocks.dropper)) { + if ((aPlayer.capabilities.isCreativeMode) + || (((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts))) { + aWorld.setBlockMetadataWithNotify(aX, aY, aZ, (aMeta + 1) % 6, 3); + GT_Utility + .sendSoundToPlayers(aWorld, SoundResource.IC2_TOOLS_RUBBER_TRAMPOLINE, 1.0F, -1.0F, aX, aY, aZ); + } + return true; + } + if ((aBlock == Blocks.pumpkin) || (aBlock == Blocks.lit_pumpkin) + || (aBlock == Blocks.furnace) + || (aBlock == Blocks.lit_furnace) + || (aBlock == Blocks.chest) + || (aBlock == Blocks.trapped_chest)) { + if ((aPlayer.capabilities.isCreativeMode) + || (((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts))) { + aWorld.setBlockMetadataWithNotify(aX, aY, aZ, (aMeta - 1) % 4 + 2, 3); + GT_Utility + .sendSoundToPlayers(aWorld, SoundResource.IC2_TOOLS_RUBBER_TRAMPOLINE, 1.0F, -1.0F, aX, aY, aZ); + } + return true; + } + if (aBlock == Blocks.hopper) { + if ((aPlayer.capabilities.isCreativeMode) + || (((GT_MetaGenerated_Tool) aItem).doDamage(aStack, this.mCosts))) { + aWorld.setBlockMetadataWithNotify(aX, aY, aZ, (aMeta + 1) % 6 != 1 ? (aMeta + 1) % 6 : 2, 3); + GT_Utility + .sendSoundToPlayers(aWorld, SoundResource.IC2_TOOLS_RUBBER_TRAMPOLINE, 1.0F, -1.0F, aX, aY, aZ); + } + return true; + } + return false; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + aList.add(this.mTooltip); + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Sonictron.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Sonictron.java new file mode 100644 index 0000000000..dbab764507 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Sonictron.java @@ -0,0 +1,135 @@ +package gregtech.common.items.behaviors; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.GT_Values; +import gregtech.api.interfaces.IItemBehaviour; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_Utility; + +public class Behaviour_Sonictron extends Behaviour_None { + + public static final IItemBehaviour<GT_MetaBase_Item> INSTANCE = new Behaviour_Sonictron(); + + public static int getCurrentIndex(ItemStack aStack) { + NBTTagCompound tNBTTagCompound = aStack.getTagCompound(); + if (tNBTTagCompound == null) { + tNBTTagCompound = new NBTTagCompound(); + } + return tNBTTagCompound.getInteger("mCurrentIndex"); + } + + public static int getTickTimer(ItemStack aStack) { + NBTTagCompound tNBTTagCompound = aStack.getTagCompound(); + if (tNBTTagCompound == null) { + tNBTTagCompound = new NBTTagCompound(); + } + return tNBTTagCompound.getInteger("mTickTimer"); + } + + public static NBTTagCompound setCurrentIndex(ItemStack aStack, int aIndex) { + NBTTagCompound tNBTTagCompound = aStack.getTagCompound(); + if (tNBTTagCompound == null) { + tNBTTagCompound = new NBTTagCompound(); + } + tNBTTagCompound.setInteger("mCurrentIndex", aIndex); + return tNBTTagCompound; + } + + public static NBTTagCompound setTickTimer(ItemStack aStack, int aTime) { + NBTTagCompound tNBTTagCompound = aStack.getTagCompound(); + if (tNBTTagCompound == null) { + tNBTTagCompound = new NBTTagCompound(); + } + tNBTTagCompound.setInteger("mTickTimer", aTime); + return tNBTTagCompound; + } + + public static ItemStack[] getNBTInventory(ItemStack aStack) { + ItemStack[] tInventory = new ItemStack[64]; + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + return tInventory; + } + NBTTagList tNBT_ItemList = tNBT.getTagList("Inventory", 10); + for (int i = 0; i < tNBT_ItemList.tagCount(); i++) { + NBTTagCompound tag = tNBT_ItemList.getCompoundTagAt(i); + byte slot = tag.getByte("Slot"); + if ((slot >= 0) && (slot < tInventory.length)) { + tInventory[slot] = GT_Utility.loadItem(tag); + } + } + return tInventory; + } + + public static NBTTagCompound setNBTInventory(ItemStack aStack, ItemStack[] aInventory) { + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + tNBT = new NBTTagCompound(); + } + NBTTagList tNBT_ItemList = new NBTTagList(); + for (int i = 0; i < aInventory.length; i++) { + ItemStack stack = aInventory[i]; + if (stack != null) { + NBTTagCompound tag = new NBTTagCompound(); + tag.setByte("Slot", (byte) i); + stack.writeToNBT(tag); + tNBT_ItemList.appendTag(tag); + } + } + tNBT.setTag("Inventory", tNBT_ItemList); + aStack.setTagCompound(tNBT); + return tNBT; + } + + public static void copyInventory(ItemStack[] aInventory, ItemStack[] aNewContent, int aIndexlength) { + for (int i = 0; i < aIndexlength; i++) { + if (aNewContent[i] == null) { + aInventory[i] = null; + } else { + aInventory[i] = GT_Utility.copyOrNull(aNewContent[i]); + } + } + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + setCurrentIndex(aStack, -1); + return false; + } + + @Override + public ItemStack onItemRightClick(GT_MetaBase_Item aItem, ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + setCurrentIndex(aStack, 0); + return aStack; + } + + @Override + public void onUpdate(GT_MetaBase_Item aItem, ItemStack aStack, World aWorld, Entity aPlayer, int aTimer, + boolean aIsInHand) { + int tTickTimer = getTickTimer(aStack); + int tCurrentIndex = getCurrentIndex(aStack); + if ((tTickTimer++ % 2 == 0) && (tCurrentIndex > -1)) { + ItemStack[] tInventory = getNBTInventory(aStack); + GT_Values.GT.doSonictronSound( + tInventory[tCurrentIndex], + aPlayer.worldObj, + aPlayer.posX, + aPlayer.posY, + aPlayer.posZ); + tCurrentIndex++; + if (tCurrentIndex > 63) { + tCurrentIndex = -1; + } + } + setTickTimer(aStack, tTickTimer); + setCurrentIndex(aStack, tCurrentIndex); + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Spray_Color.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Spray_Color.java new file mode 100644 index 0000000000..cbc698d474 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Spray_Color.java @@ -0,0 +1,222 @@ +package gregtech.common.items.behaviors; + +import java.util.Arrays; +import java.util.Collection; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockColored; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.Vec3; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import appeng.api.implementations.tiles.IColorableTile; +import appeng.api.util.AEColor; +import appeng.block.networking.BlockCableBus; +import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.Dyes; +import gregtech.api.enums.SoundResource; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; + +public class Behaviour_Spray_Color extends Behaviour_None { + + private final ItemStack mEmpty; + private final ItemStack mUsed; + private final ItemStack mFull; + private final long mUses; + private final byte mColor; + private final Collection<Block> mAllowedVanillaBlocks = Arrays.asList( + Blocks.glass, + Blocks.glass_pane, + Blocks.stained_glass, + Blocks.stained_glass_pane, + Blocks.carpet, + Blocks.hardened_clay); + protected String mTooltip; + private final String mTooltipUses = GT_LanguageManager + .addStringLocalization("gt.behaviour.paintspray.uses", "Remaining Uses:"); + private final String mTooltipUnstackable = GT_LanguageManager + .addStringLocalization("gt.behaviour.unstackable", "Not usable when stacked!"); + private final String mTooltipChain = GT_LanguageManager.addStringLocalization( + "gt.behaviour.paintspray.chain", + "If used while sneaking it will spray a chain of blocks"); + + private final String mTooltipChainAmount = GT_LanguageManager.addStringLocalization( + "gt.behaviour.paintspray.chain", + "Sprays up to %d blocks, in the direction you're looking at"); + + public Behaviour_Spray_Color(ItemStack aEmpty, ItemStack aUsed, ItemStack aFull, long aUses, int aColor) { + this.mEmpty = aEmpty; + this.mUsed = aUsed; + this.mFull = aFull; + this.mUses = aUses; + this.mColor = ((byte) aColor); + this.mTooltip = GT_LanguageManager.addStringLocalization( + "gt.behaviour.paintspray." + this.mColor + ".tooltip", + "Can Color things in " + Dyes.get(this.mColor).mName); + } + + public Behaviour_Spray_Color(ItemStack aEmpty, ItemStack aUsed, ItemStack aFull, long aUses) { + this.mEmpty = aEmpty; + this.mUsed = aUsed; + this.mFull = aFull; + this.mUses = aUses; + this.mColor = 0; + mTooltip = ""; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + if ((aWorld.isRemote) || (aStack.stackSize != 1)) { + return false; + } + boolean rOutput = false; + if (!aPlayer.canPlayerEdit(aX, aY, aZ, side.ordinal(), aStack)) { + return false; + } + NBTTagCompound tNBT = aStack.getTagCompound(); + if (tNBT == null) { + tNBT = new NBTTagCompound(); + } + long tUses = tNBT.getLong("GT.RemainingPaint"); + if (GT_Utility.areStacksEqual(aStack, this.mFull, true)) { + aStack.func_150996_a(this.mUsed.getItem()); + Items.feather.setDamage(aStack, Items.feather.getDamage(this.mUsed)); + tUses = this.mUses; + } + int painted = 0; + int maxPainted = GregTech_API.sSpecialFile.get(ConfigCategories.general, "SprayCanChainRange", 256); + ForgeDirection lookSide; + Vec3 look = aPlayer.getLookVec(); + double absX = Math.abs(look.xCoord); + double absY = Math.abs(look.yCoord); + double absZ = Math.abs(look.zCoord); + if (absX > absY && absX > absZ) { + lookSide = look.xCoord > 0 ? ForgeDirection.EAST : ForgeDirection.WEST; + } else if (absY > absX && absY > absZ) { + lookSide = look.yCoord > 0 ? ForgeDirection.UP : ForgeDirection.DOWN; + } else { + lookSide = look.zCoord > 0 ? ForgeDirection.SOUTH : ForgeDirection.NORTH; + } + Block initialBlock = aWorld.getBlock(aX, aY, aZ); + int initialBlockMeta = aWorld.getBlockMetadata(aX, aY, aZ); + TileEntity initialTE = aWorld.getTileEntity(aX, aY, aZ); + while ((GT_Utility.areStacksEqual(aStack, this.mUsed, true)) && (colorize(aWorld, aX, aY, aZ, side, aPlayer))) { + GT_Utility.sendSoundToPlayers(aWorld, SoundResource.IC2_TOOLS_PAINTER, 1.0F, 1.0F, aX, aY, aZ); + if (!aPlayer.capabilities.isCreativeMode) { + tUses -= 1L; + } + rOutput = true; + painted++; + if (painted >= maxPainted && maxPainted != -1) break; + if (!aPlayer.isSneaking() || tUses <= 0) break; + switch (lookSide) { + case UP -> aY += 1; + case DOWN -> aY -= 1; + case NORTH -> aZ -= 1; + case SOUTH -> aZ += 1; + case WEST -> aX -= 1; + case EAST -> aX += 1; + default -> throw new IllegalArgumentException("Unexpected value: " + lookSide); + } + + if (aWorld.getBlock(aX, aY, aZ) != initialBlock) break; + if (aWorld.getBlockMetadata(aX, aY, aZ) != initialBlockMeta) break; + + /* + * Check if the initial block had a TE and if the next one does, check if its the same kind. + * else one does and the other doesnt, thus stop checking. + */ + TileEntity targetTE = aWorld.getTileEntity(aX, aY, aZ); + if (initialTE == null ^ targetTE == null) break; + if (initialTE != null && targetTE != null) { + if (!initialTE.getClass() + .isInstance(targetTE)) break; + + if (initialTE instanceof IGregTechTileEntity currentGTTile + && targetTE instanceof IGregTechTileEntity targetGTTile) { + if (currentGTTile.getMetaTileID() != targetGTTile.getMetaTileID()) break; + } + } + } + tNBT.removeTag("GT.RemainingPaint"); + if (tUses > 0L) { + tNBT.setLong("GT.RemainingPaint", tUses); + } + if (tNBT.hasNoTags()) { + aStack.setTagCompound(null); + } else { + aStack.setTagCompound(tNBT); + } + if (tUses <= 0L) { + if (this.mEmpty == null) { + aStack.stackSize -= 1; + } else { + aStack.func_150996_a(this.mEmpty.getItem()); + Items.feather.setDamage(aStack, Items.feather.getDamage(this.mEmpty)); + } + } + return rOutput; + } + + protected boolean colorize(World aWorld, int aX, int aY, int aZ, ForgeDirection side, EntityPlayer player) { + final Block aBlock = aWorld.getBlock(aX, aY, aZ); + if (aBlock != Blocks.air) { + if (this.mAllowedVanillaBlocks.contains(aBlock) || aBlock instanceof BlockColored) { + if (aBlock == Blocks.hardened_clay) { + aWorld.setBlock(aX, aY, aZ, Blocks.stained_hardened_clay, (~this.mColor) & 0xF, 3); + return true; + } + if (aBlock == Blocks.glass_pane) { + aWorld.setBlock(aX, aY, aZ, Blocks.stained_glass_pane, (~this.mColor) & 0xF, 3); + return true; + } + if (aBlock == Blocks.glass) { + aWorld.setBlock(aX, aY, aZ, Blocks.stained_glass, (~this.mColor) & 0xF, 3); + return true; + } + if (aWorld.getBlockMetadata(aX, aY, aZ) == ((~this.mColor) & 0xF)) { + return false; + } + aWorld.setBlockMetadataWithNotify(aX, aY, aZ, (~this.mColor) & 0xF, 3); + return true; + } + + if (aBlock instanceof IColorableTile) { + return ((IColorableTile) aBlock).recolourBlock(side, AEColor.values()[(~this.mColor) & 0xF], player); + } + + if (aBlock instanceof BlockCableBus) { + return ((BlockCableBus) aBlock).recolourBlock(aWorld, aX, aY, aZ, side, (~this.mColor) & 0xF, player); + } + } + return aBlock.recolourBlock(aWorld, aX, aY, aZ, side, (~this.mColor) & 0xF); + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + aList.add(this.mTooltip); + aList.add(this.mTooltipChain); + aList.add( + String.format( + this.mTooltipChainAmount, + GregTech_API.sSpecialFile.get(ConfigCategories.general, "SprayCanChainRange", 256))); + NBTTagCompound tNBT = aStack.getTagCompound(); + long tRemainingPaint = tNBT == null ? this.mUses + : GT_Utility.areStacksEqual(aStack, this.mFull, true) ? this.mUses : tNBT.getLong("GT.RemainingPaint"); + aList.add(this.mTooltipUses + " " + tRemainingPaint); + aList.add(this.mTooltipUnstackable); + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Spray_Color_Remover.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Spray_Color_Remover.java new file mode 100644 index 0000000000..0b73b4f7fc --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Spray_Color_Remover.java @@ -0,0 +1,48 @@ +package gregtech.common.items.behaviors; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import appeng.api.implementations.tiles.IColorableTile; +import appeng.api.util.AEColor; +import appeng.block.networking.BlockCableBus; +import gregtech.api.interfaces.tileentity.IColoredTileEntity; +import gregtech.api.util.GT_LanguageManager; + +public class Behaviour_Spray_Color_Remover extends Behaviour_Spray_Color { + + public Behaviour_Spray_Color_Remover(ItemStack aEmpty, ItemStack aUsed, ItemStack aFull, long aUses) { + super(aEmpty, aUsed, aFull, aUses); + this.mTooltip = GT_LanguageManager + .addStringLocalization("gt.behaviour.paintspray.solvent.tooltip", "Can remove paint from things"); + } + + @Override + protected boolean colorize(World aWorld, int aX, int aY, int aZ, ForgeDirection side, EntityPlayer player) { + final Block aBlock = aWorld.getBlock(aX, aY, aZ); + if (aBlock != Blocks.air) { + if (aBlock instanceof IColorableTile) { + return ((IColorableTile) aBlock).recolourBlock(side, AEColor.Transparent, player); + } + + if (aBlock instanceof BlockCableBus) { + return ((BlockCableBus) aBlock) + .recolourBlock(aWorld, aX, aY, aZ, side, AEColor.Transparent.ordinal(), player); + } + + TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ); + if (tTileEntity instanceof IColoredTileEntity gte) { + if (gte.getColorization() >= 0) { + gte.setColorization((byte) -1); + return true; + } + } + } + return false; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Switch_Metadata.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Switch_Metadata.java new file mode 100644 index 0000000000..03cf29b9dd --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Switch_Metadata.java @@ -0,0 +1,67 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.items.GT_Generic_Block; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_Util; +import gregtech.api.util.GT_Utility; + +public class Behaviour_Switch_Metadata extends Behaviour_None { + + public final int mSwitchIndex; + public final boolean mCheckTarget, mShowModeSwitchTooltip; + + public Behaviour_Switch_Metadata(int aSwitchIndex) { + this(aSwitchIndex, false); + } + + public Behaviour_Switch_Metadata(int aSwitchIndex, boolean aCheckTarget) { + this(aSwitchIndex, aCheckTarget, false); + } + + public Behaviour_Switch_Metadata(int aSwitchIndex, boolean aCheckTarget, boolean aShowModeSwitchTooltip) { + mSwitchIndex = aSwitchIndex; + mCheckTarget = aCheckTarget; + mShowModeSwitchTooltip = aShowModeSwitchTooltip; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + if (mShowModeSwitchTooltip) aList.add(GT_Utility.trans("330", "Sneak Rightclick to switch Mode")); + return aList; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float aHitX, float aHitY, float aHitZ) { + if (aStack != null && (aPlayer == null || aPlayer.isSneaking()) && !aWorld.isRemote) { + if (mCheckTarget) { + Block aBlock = aWorld.blockExists(aX, aY, aZ) ? aWorld.getBlock(aX, aY, aZ) : Blocks.air; + if (aBlock instanceof GT_Generic_Block) { + Items.feather.setDamage(aStack, (short) mSwitchIndex); + GT_Utility.updateItemStack(aStack); + return true; + } + if (GT_Util.getTileEntity(aWorld, aX, aY, aZ, true) == null) { + Items.feather.setDamage(aStack, (short) mSwitchIndex); + GT_Utility.updateItemStack(aStack); + return true; + } + return false; + } + Items.feather.setDamage(aStack, (short) mSwitchIndex); + GT_Utility.updateItemStack(aStack); + return true; + } + return false; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Switch_Mode.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Switch_Mode.java new file mode 100644 index 0000000000..1e93362882 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Switch_Mode.java @@ -0,0 +1,53 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.world.World; + +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.util.GT_Utility; + +public class Behaviour_Switch_Mode extends Behaviour_None { + + public Behaviour_Switch_Mode() {} + + @Override + public ItemStack onItemRightClick(GT_MetaBase_Item aItem, ItemStack aStack, World aWorld, EntityPlayer aPlayer) { + if (aStack != null && (aPlayer == null || aPlayer.isSneaking()) && !aWorld.isRemote) { + + GT_MetaGenerated_Tool itemTool = (GT_MetaGenerated_Tool) aItem; + final byte maxMode = itemTool.getToolMaxMode(aStack); + if (maxMode == 1) { + return aStack; + } + + MovingObjectPosition mop = GT_Utility.getPlayerLookingTarget(); + if (mop == null) { + byte currentMode = itemTool.getToolMode(aStack); + currentMode = (byte) ((currentMode + 1) % maxMode); + itemTool.setToolMode(aStack, currentMode); + } + return aStack; + } + return aStack; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + super.getAdditionalToolTips(aItem, aList, aStack); + if ((aItem instanceof GT_MetaGenerated_Tool)) { + GT_MetaGenerated_Tool itemTool = (GT_MetaGenerated_Tool) aItem; + final int maxMode = itemTool.getToolMaxMode(aStack); + if (maxMode > 1) { + aList.add("Shift+Rclick to change mode"); + } + } + + return aList; + } + +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_Wrench.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_Wrench.java new file mode 100644 index 0000000000..16c5c3f948 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_Wrench.java @@ -0,0 +1,278 @@ +package gregtech.common.items.behaviors; + +import java.util.Arrays; +import java.util.List; +import java.util.function.BooleanSupplier; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.oredict.OreDictionary; + +import appeng.api.parts.IPartHost; +import appeng.api.util.IOrientable; +import appeng.tile.misc.TileInterface; +import gregtech.api.enums.SoundResource; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.items.GT_MetaGenerated_Tool; +import gregtech.api.util.GT_LanguageManager; +import gregtech.api.util.GT_Utility; +import ic2.api.tile.IWrenchable; + +public class Behaviour_Wrench extends Behaviour_None { + + private final int mCosts; + private final String mTooltip = GT_LanguageManager + .addStringLocalization("gt.behaviour.wrench", "Rotates Blocks on Rightclick"); + + public Behaviour_Wrench(int aCosts) { + this.mCosts = aCosts; + } + + @Override + public boolean onItemUseFirst(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, ForgeDirection side, float hitX, float hitY, float hitZ) { + final Block aBlock = aWorld.getBlock(aX, aY, aZ); + if (aBlock == null) { + return false; + } + final int aMeta = aWorld.getBlockMetadata(aX, aY, aZ); + final short targetSideOrdinal = (short) GT_Utility.determineWrenchingSide(side, hitX, hitY, hitZ) + .ordinal(); + final TileEntity aTileEntity = aWorld.getTileEntity(aX, aY, aZ); + + final WrenchHandler handler = new WrenchHandler( + aBlock, + aMeta, + targetSideOrdinal, + aTileEntity, + aPlayer, + aWorld, + aX, + aY, + aZ, + aStack, + (GT_MetaGenerated_Tool) aItem, + mCosts); + + try { + return handler.handle() && !aWorld.isRemote; + } catch (Throwable ignored) {} + return false; + } + + /** + * <p> + * A class to simplify wrenching operation, + * stopping "checking creative", "trying to damage tool", + * "doing the logic" and "playing sound" again and again. + * This should have been a record, but it's not available in Java 8. + * </p> + * <p> + * {@link WrenchHandler#handle()} is the entry point of main logic. + * </p> + */ + private static class WrenchHandler { + + boolean handle() { + ForgeDirection direction = ForgeDirection.getOrientation(targetSideOrdinal); + + // AE2 logic + // default to change the up facing + // sneak to change the forward facing + if (tileEntity instanceof IOrientable orientable) { + if (!orientable.canBeRotated()) return false; + ForgeDirection front = orientable.getForward(); + ForgeDirection up = orientable.getUp(); + + // mainly for me-interfaces, whose initial orientation is UNKNOWN + if (front == ForgeDirection.UNKNOWN) { + if (direction == ForgeDirection.UP || direction == ForgeDirection.DOWN) + front = ForgeDirection.NORTH; + else front = ForgeDirection.UP; + } + + ForgeDirection back = front.getOpposite(); + ForgeDirection down = up.getOpposite(); + + if (tileEntity instanceof TileInterface) { + if (player.isSneaking()) return false; + if (direction == down) { + return doWrenchOperation(costs, () -> { + orientable.setOrientation(ForgeDirection.UNKNOWN, ForgeDirection.UNKNOWN); + return true; + }); + } + // interface's up-side is opposite to the arrow on texture + // make it intuitive by rotating it to the opposite side. + direction = direction.getOpposite(); + up = up.getOpposite(); + } else if (direction == up || direction == front) { + // rotate around the direction axis + final var tempFront = front; + final var tempUp = up; + if (!player.isSneaking() && direction == up) return doWrenchOperation(costs, () -> { + orientable.setOrientation(tempFront.getRotation(tempUp), tempUp); + return true; + }); + if (player.isSneaking() && direction == front) return doWrenchOperation(costs, () -> { + orientable.setOrientation( + tempFront, + tempUp.getRotation(tempFront) + .getRotation(tempFront)); + return true; + }); + } + + if (player.isSneaking()) { + if (direction == up || direction == down) { + orientable.setOrientation(direction, down.getRotation(front.getRotation(direction))); + } else orientable.setOrientation(direction, up); + } else { + if (direction == front || direction == back) { + orientable.setOrientation(back.getRotation(up.getRotation(direction)), direction); + } else orientable.setOrientation(front, direction); + } + + return damageWrench(costs); + } + if (world.isRemote) return false; + // IC2 Wrenchable + if (tileEntity instanceof IWrenchable wrenchable) { + if (wrenchable.wrenchCanSetFacing(player, targetSideOrdinal)) { + return doWrenchOperation(costs, () -> { + wrenchable.setFacing(targetSideOrdinal); + return true; + }); + } + return false; + } + + if (block == Blocks.powered_repeater || block == Blocks.unpowered_repeater + || block == Blocks.powered_comparator + || block == Blocks.unpowered_comparator) return setBlockMeta(costs, meta / 4 * 4 + (meta % 4 + 1) % 4); + + // hopper cannot face sky + if (block == Blocks.hopper && targetSideOrdinal != 1) return setBlockMeta(costs, targetSideOrdinal); + + if (isVanillaAllSideRotatable(block)) if (meta < 6) return setBlockMeta(costs, targetSideOrdinal); + + // blocks like chests and furnaces have only four directions + if (isVanillaCantFaceAxisY(block)) { + if (targetSideOrdinal > 1) return setBlockMeta(costs, targetSideOrdinal); + else return false; + } + if (tileEntity instanceof IPartHost) return false; + + final int logWoodId = OreDictionary.getOreID("logWood"); + if (Arrays.stream(OreDictionary.getOreIDs(new ItemStack(block))) + .anyMatch(id -> id == logWoodId)) { + // The meta just work + return setBlockMeta(costs, (meta + 4) % 12); + } + + // vanilla block rotate logic + if ((Arrays.asList(block.getValidRotations(world, x, y, z)) + .contains(direction))) return rotateBlock(costs, direction); + return false; + + // GT blocks' rotations are done by blocks themselves after this returning false + } + + private final Block block; + private final short targetSideOrdinal; + private final TileEntity tileEntity; + private final EntityPlayer player; + private final World world; + private final int x, y, z, meta; + private final ItemStack stack; + + private final GT_MetaGenerated_Tool item; + private final int costs; + + public WrenchHandler(Block block, int meta, short targetSideOrdinal, TileEntity tileEntity, EntityPlayer player, + World world, int x, int y, int z, ItemStack stack, GT_MetaGenerated_Tool item, int costs) { + this.block = block; + this.meta = meta; + this.targetSideOrdinal = targetSideOrdinal; + this.tileEntity = tileEntity; + this.player = player; + this.world = world; + this.x = x; + this.y = y; + this.z = z; + this.stack = stack; + this.item = item; + this.costs = costs; + } + + /** + * this will run the operation, damage the tool and play the sound if possible (creative mode or + * {@link GT_MetaGenerated_Tool#canWrench(EntityPlayer, int, int, int)}) + * + * @param damage damage to be applied to the wrench + * @param operation the real operation of the click + * @return true if the operation was successful + * @see #setBlockMeta(int, int) + * @see #rotateBlock(int, ForgeDirection) + * @see #rotateBlock(int, ForgeDirection) + */ + boolean doWrenchOperation(int damage, BooleanSupplier operation) { + if (player.capabilities.isCreativeMode || item.canWrench(player, x, y, z)) { + if (operation.getAsBoolean()) { + item.doDamage(stack, damage); + GT_Utility.sendSoundToPlayers(world, SoundResource.IC2_TOOLS_WRENCH, 1.0F, -1.0F, x, y, z); + return true; + } + } + return false; + } + + boolean setBlockMeta(int damage, int newMeta) { + return doWrenchOperation(damage, () -> setBlockMetadataWithNotify(newMeta)); + } + + boolean rotateBlock(int damage, ForgeDirection direction) { + return doWrenchOperation(damage, () -> block.rotateBlock(world, x, y, z, direction)); + } + + boolean damageWrench(int damage) { + return doWrenchOperation(damage, () -> true); + } + + private boolean setBlockMetadataWithNotify(int newMeta) { + return world.setBlockMetadataWithNotify(x, y, z, newMeta, 3); + } + + } + + public static boolean isVanillaRotatable(Block block) { + return isVanillaCantFaceAxisY(block) || isVanillaAllSideRotatable(block) || block == Blocks.hopper; + } + + public static boolean isVanillaCantFaceAxisY(Block block) { + return GT_Utility.arrayContains( + block, + Blocks.pumpkin, + Blocks.lit_pumpkin, + Blocks.furnace, + Blocks.lit_furnace, + Blocks.chest, + Blocks.trapped_chest, + Blocks.ender_chest); + } + + public static boolean isVanillaAllSideRotatable(Block block) { + return GT_Utility.arrayContains(block, Blocks.piston, Blocks.sticky_piston, Blocks.dispenser, Blocks.dropper); + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + aList.add(this.mTooltip); + return aList; + } +} diff --git a/src/main/java/gregtech/common/items/behaviors/Behaviour_WrittenBook.java b/src/main/java/gregtech/common/items/behaviors/Behaviour_WrittenBook.java new file mode 100644 index 0000000000..0f645a93a9 --- /dev/null +++ b/src/main/java/gregtech/common/items/behaviors/Behaviour_WrittenBook.java @@ -0,0 +1,40 @@ +package gregtech.common.items.behaviors; + +import java.util.List; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.client.gui.GuiScreenBook; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.util.GT_Utility; + +public class Behaviour_WrittenBook extends Behaviour_None { + + @Override + @SideOnly(Side.CLIENT) + public boolean onItemUse(GT_MetaBase_Item aItem, ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, + int aY, int aZ, int ordinalSide, float hitX, float hitY, float hitZ) { + if ((GT_Utility.isStringValid(GT_Utility.ItemNBT.getBookTitle(aStack))) + && ((aPlayer instanceof EntityPlayerSP))) { + Minecraft.getMinecraft() + .displayGuiScreen(new GuiScreenBook(aPlayer, aStack, false)); + } + return true; + } + + @Override + public List<String> getAdditionalToolTips(GT_MetaBase_Item aItem, List<String> aList, ItemStack aStack) { + String tTitle = GT_Utility.ItemNBT.getBookTitle(aStack); + if (GT_Utility.isStringValid(tTitle)) { + aList.add(tTitle); + aList.add("by " + GT_Utility.ItemNBT.getBookAuthor(aStack)); + } + return aList; + } +} |