From 92cedd818ccdb57085b14c8ed735e903479ac581 Mon Sep 17 00:00:00 2001 From: Draknyte1 Date: Mon, 20 Jun 2016 02:01:03 +1000 Subject: +Added New Circuits & Components along with recipes. +Added A complete set of Machine components up to MAX voltage along with recipes. +Started Initial work on multiblock items (Similar to the turbine rotor needed in Large turbines) +Added better support for future recipe additions. --- .../creative/tabs/MiscUtilCreativeTabMachines.java | 7 +- src/Java/miscutil/core/handler/COMPAT_HANDLER.java | 3 + .../handler/registration/RegistrationHandler.java | 2 + src/Java/miscutil/core/item/ModItems.java | 20 +- src/Java/miscutil/core/lib/CORE.java | 5 + .../miscutil/core/recipe/RECIPES_GREGTECH.java | 12 +- .../core/recipe/RECIPES_LaserEngraver.java | 32 + .../core/recipe/RECIPES_MachineComponents.java | 351 ++++++++++ .../gregtech/api/enums/GregtechItemList.java | 10 +- .../gregtech/api/enums/GregtechOreDictNames.java | 30 +- .../gregtech/api/enums/GregtechOrePrefixes.java | 744 +++++++++++++++++++++ .../gregtech/api/enums/GregtechTextureSet.java | 144 ++++ .../gregtech/api/enums/GregtechTextures.java | 96 ++- .../internal/Interface_OreRecipeRegistrator.java | 16 + .../interfaces/internal/Interface_ToolStats.java | 155 +++++ .../gregtech/api/items/Gregtech_MetaItem_Base.java | 85 --- .../gregtech/api/items/Gregtech_MetaTool.java | 605 +++++++++++++++++ .../gregtech/api/objects/GregtechItemData.java | 131 ++++ .../miscutil/gregtech/api/util/GregtechRecipe.java | 35 +- .../gregtech/common/GregtechRecipeAdder.java | 1 + .../common/items/MetaGeneratedGregtechItems.java | 48 +- .../common/items/MetaGeneratedGregtechTools.java | 24 + .../gregtech/common/tools/TOOL_Gregtech_Base.java | 168 +++++ .../tools/TOOL_Gregtech_BaseMultiblockItem.java | 49 ++ .../TOOL_Gregtech_MaxEfficiencyMultiBlockItem.java | 27 + 25 files changed, 2677 insertions(+), 123 deletions(-) create mode 100644 src/Java/miscutil/core/recipe/RECIPES_LaserEngraver.java create mode 100644 src/Java/miscutil/core/recipe/RECIPES_MachineComponents.java create mode 100644 src/Java/miscutil/gregtech/api/enums/GregtechOrePrefixes.java create mode 100644 src/Java/miscutil/gregtech/api/enums/GregtechTextureSet.java create mode 100644 src/Java/miscutil/gregtech/api/interfaces/internal/Interface_OreRecipeRegistrator.java create mode 100644 src/Java/miscutil/gregtech/api/interfaces/internal/Interface_ToolStats.java create mode 100644 src/Java/miscutil/gregtech/api/items/Gregtech_MetaTool.java create mode 100644 src/Java/miscutil/gregtech/api/objects/GregtechItemData.java create mode 100644 src/Java/miscutil/gregtech/common/items/MetaGeneratedGregtechTools.java create mode 100644 src/Java/miscutil/gregtech/common/tools/TOOL_Gregtech_Base.java create mode 100644 src/Java/miscutil/gregtech/common/tools/TOOL_Gregtech_BaseMultiblockItem.java create mode 100644 src/Java/miscutil/gregtech/common/tools/TOOL_Gregtech_MaxEfficiencyMultiBlockItem.java (limited to 'src/Java') diff --git a/src/Java/miscutil/core/creative/tabs/MiscUtilCreativeTabMachines.java b/src/Java/miscutil/core/creative/tabs/MiscUtilCreativeTabMachines.java index 6bc433b93a..21cacd8dab 100644 --- a/src/Java/miscutil/core/creative/tabs/MiscUtilCreativeTabMachines.java +++ b/src/Java/miscutil/core/creative/tabs/MiscUtilCreativeTabMachines.java @@ -1,18 +1,19 @@ package miscutil.core.creative.tabs; +import miscutil.core.item.ModItems; import net.minecraft.creativetab.CreativeTabs; -import net.minecraft.init.Items; import net.minecraft.item.Item; public class MiscUtilCreativeTabMachines extends CreativeTabs { + public MiscUtilCreativeTabMachines(String lable) { super(lable); } @Override - public Item getTabIconItem() { - return Items.experience_bottle; + public Item getTabIconItem() { + return ModItems.itemPLACEHOLDER_Circuit; } } diff --git a/src/Java/miscutil/core/handler/COMPAT_HANDLER.java b/src/Java/miscutil/core/handler/COMPAT_HANDLER.java index 078c3984ac..4ab66d3099 100644 --- a/src/Java/miscutil/core/handler/COMPAT_HANDLER.java +++ b/src/Java/miscutil/core/handler/COMPAT_HANDLER.java @@ -31,6 +31,7 @@ import miscutil.core.item.ModItems; import miscutil.core.lib.CORE; import miscutil.core.lib.LoadedMods; import miscutil.core.recipe.RECIPES_GREGTECH; +import miscutil.core.recipe.RECIPES_LaserEngraver; import miscutil.core.recipe.ShapedRecipeObject; import miscutil.core.util.Utils; import miscutil.core.util.item.UtilsItems; @@ -74,6 +75,8 @@ public class COMPAT_HANDLER { public static void registerGregtechMachines() { if (Gregtech) { new MetaGeneratedGregtechItems(); + new RECIPES_LaserEngraver(); + //new MetaGeneratedGregtechTools(); GregtechEnergyBuffer.run(); GregtechConduits.run(); GregtechSteamCondenser.run(); diff --git a/src/Java/miscutil/core/handler/registration/RegistrationHandler.java b/src/Java/miscutil/core/handler/registration/RegistrationHandler.java index ce7f24c2aa..1992a084c9 100644 --- a/src/Java/miscutil/core/handler/registration/RegistrationHandler.java +++ b/src/Java/miscutil/core/handler/registration/RegistrationHandler.java @@ -1,6 +1,7 @@ package miscutil.core.handler.registration; import miscutil.core.handler.COMPAT_HANDLER; +import miscutil.core.recipe.RECIPES_MachineComponents; import miscutil.core.recipe.RECIPES_Machines; import miscutil.core.recipe.RECIPES_Shapeless; import miscutil.core.recipe.RECIPES_Tools; @@ -19,6 +20,7 @@ public class RegistrationHandler { RECIPES_Tools.RECIPES_LOAD(); RECIPES_Machines.RECIPES_LOAD(); RECIPES_Shapeless.RECIPES_LOAD(); + RECIPES_MachineComponents.RECIPES_LOAD(); //RECIPES_MTWRAPPER.run(); Utils.LOG_INFO("Loaded: "+recipesSuccess+" Failed: "+recipesFailed); COMPAT_HANDLER.areInitItemsLoaded = true; diff --git a/src/Java/miscutil/core/item/ModItems.java b/src/Java/miscutil/core/item/ModItems.java index 6da428c924..aa0a95e07f 100644 --- a/src/Java/miscutil/core/item/ModItems.java +++ b/src/Java/miscutil/core/item/ModItems.java @@ -1,4 +1,5 @@ package miscutil.core.item; +import static miscutil.core.creative.AddToCreativeTab.tabMachines; import static miscutil.core.creative.AddToCreativeTab.tabMisc; import static miscutil.core.lib.CORE.LOAD_ALL_CONTENT; import miscutil.core.creative.AddToCreativeTab; @@ -98,7 +99,7 @@ Gold Tool: 22*/ public static Item itemIngotBatteryAlloy; public static Item itemPlateBatteryAlloy; public static Item itemHeliumBlob; - public static Item item_PLEASE_FACTOR_ME_4; + public static Item itemPLACEHOLDER_Circuit; public static Item FuelRod_Empty; public static Item FuelRod_Thorium; @@ -269,26 +270,23 @@ Gold Tool: 22*/ Item itemBufferCore; for(int i=1; i<=10; i++){ //Utils.LOG_INFO(""+i); - itemBufferCore = new BufferCore("itemBufferCore", i).setCreativeTab(AddToCreativeTab.tabMisc); + itemBufferCore = new BufferCore("itemBufferCore", i).setCreativeTab(AddToCreativeTab.tabMachines); GameRegistry.registerItem(itemBufferCore, itemBufferCore.getUnlocalizedName()+i); //System.out.println("Buffer Core registration count is: "+i); } - //Dev Items - itemStickyRubber = new Item().setUnlocalizedName("itemStickyRubber").setCreativeTab(tabMisc).setTextureName(CORE.MODID + ":itemStickyRubber"); + itemStickyRubber = new Item().setUnlocalizedName("itemStickyRubber").setCreativeTab(tabMachines).setTextureName(CORE.MODID + ":itemStickyRubber"); GameRegistry.registerItem(itemStickyRubber, "itemStickyRubber"); //Battery Alloy For cheap Niggers - itemIngotBatteryAlloy = new Item().setUnlocalizedName("itemIngotBatteryAlloy").setCreativeTab(tabMisc).setTextureName(CORE.MODID + ":itemIngotBatteryAlloy"); + itemIngotBatteryAlloy = new Item().setUnlocalizedName("itemIngotBatteryAlloy").setCreativeTab(tabMachines).setTextureName(CORE.MODID + ":itemIngotBatteryAlloy"); GameRegistry.registerItem(itemIngotBatteryAlloy, "itemIngotBatteryAlloy"); - itemPlateBatteryAlloy = new Item().setUnlocalizedName("itemPlateBatteryAlloy").setCreativeTab(tabMisc).setTextureName(CORE.MODID + ":itemPlateBatteryAlloy"); + itemPlateBatteryAlloy = new Item().setUnlocalizedName("itemPlateBatteryAlloy").setCreativeTab(tabMachines).setTextureName(CORE.MODID + ":itemPlateBatteryAlloy"); GameRegistry.registerItem(itemPlateBatteryAlloy, "itemPlateBatteryAlloy"); itemHeliumBlob = new Item().setUnlocalizedName("itemHeliumBlob").setCreativeTab(tabMisc).setTextureName(CORE.MODID + ":itemHeliumBlob"); GameRegistry.registerItem(itemHeliumBlob, "itemHeliumBlob"); - - - /* - item_PLEASE_FACTOR_ME_4 = new Item().setUnlocalizedName("unlocalName4").setCreativeTab(tabMisc).setTextureName(CORE.MODID + ":itemDefault"); - GameRegistry.registerItem(item_PLEASE_FACTOR_ME_4, "localName4");*/ + + itemPLACEHOLDER_Circuit = new Item().setUnlocalizedName("itemPLACEHOLDER_Circuit").setTextureName(CORE.MODID + ":itemPLACEHOLDER_Circuit"); + GameRegistry.registerItem(itemPLACEHOLDER_Circuit, "itemPLACEHOLDER_Circuit"); //Try some New Tools from GT //GT_Tool_Item x = null; //x = GregTech_API.constructHardHammerItem("rockBelter", "Sandstone Hammer", 5000 /**Max Damage**/,50 /**Entity Damage**/); diff --git a/src/Java/miscutil/core/lib/CORE.java b/src/Java/miscutil/core/lib/CORE.java index 1e9f9b90dc..8473ff3bcc 100644 --- a/src/Java/miscutil/core/lib/CORE.java +++ b/src/Java/miscutil/core/lib/CORE.java @@ -5,6 +5,7 @@ import java.util.List; import java.util.Map; import miscutil.core.creative.AddToCreativeTab; +import miscutil.gregtech.api.enums.GregtechOrePrefixes.GT_Materials; import miscutil.gregtech.api.interfaces.internal.IGregtech_RecipeAdder; import net.minecraft.client.renderer.texture.IIconRegister; import cpw.mods.fml.relauncher.Side; @@ -28,6 +29,10 @@ public class CORE { public static IIconRegister GT_BlockIcons, GT_ItemIcons; public static List GT_BlockIconload = new ArrayList(); public static final Class TAB = AddToCreativeTab.class; + /** + * A List containing all the Materials, which are somehow in use by GT and therefor receive a specific Set of Items. + */ + public static final GT_Materials[] sMU_GeneratedMaterials = new GT_Materials[1000]; //GUIS public enum GUI_ENUM diff --git a/src/Java/miscutil/core/recipe/RECIPES_GREGTECH.java b/src/Java/miscutil/core/recipe/RECIPES_GREGTECH.java index 7ff30f03d7..128e4046cb 100644 --- a/src/Java/miscutil/core/recipe/RECIPES_GREGTECH.java +++ b/src/Java/miscutil/core/recipe/RECIPES_GREGTECH.java @@ -2,7 +2,6 @@ package miscutil.core.recipe; import gregtech.api.enums.Materials; import gregtech.api.enums.OrePrefixes; -import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import miscutil.core.lib.CORE; import miscutil.core.util.Utils; @@ -57,7 +56,7 @@ public class RECIPES_GREGTECH { CORE.RA.addCokeOvenRecipe( GT_OreDictUnificator.get(OrePrefixes.log, Materials.Wood, 2L), //Input 1 GT_OreDictUnificator.get(OrePrefixes.log, Materials.Wood, 1L), //Input 2 - Materials.SaltWater.getFluid(85L), //Fluid Input + Materials.Oxygen.getFluid(85L), //Fluid Input Materials.Creosote.getFluid(145L), //Fluid Output GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Charcoal, 2L), //Item Output 1200, //Time in ticks @@ -70,7 +69,7 @@ public class RECIPES_GREGTECH { CORE.RA.addCokeOvenRecipe( GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Coal, 2L), //Input 1 GT_OreDictUnificator.get(OrePrefixes.gem, Materials.Coal, 1L), //Input 2 - Materials.SaltWater.getFluid(185L), //Fluid Input + Materials.Oxygen.getFluid(185L), //Fluid Input Materials.Creosote.getFluid(200L), //Fluid Output UtilsItems.getItemStack("Railcraft:fuel.coke", 2), //Item Output 900, //Time in ticks @@ -86,8 +85,9 @@ public class RECIPES_GREGTECH { private static void addFuels(){ Utils.LOG_INFO("Registering New Fuels."); - CORE.RA.addFuel(GT_ModHandler.getModItem("EnderIO", "bucketRocket_fuel", 1L, 1), null, 2800, 0); - CORE.RA.addFuel(GT_ModHandler.getModItem("EnderIO", "bucketHootch", 1L, 1), null, 2800, 0); - CORE.RA.addFuel(GT_ModHandler.getModItem("EnderIO", "bucketFire_water", 1L, 1), null, 2800, 0); + //CORE.RA.addFuel(GT_ModHandler.getModItem("EnderIO", "bucketRocket_fuel", 1L, 1), null, 2800, 0); + //CORE.RA.addFuel(GT_ModHandler.getModItem("EnderIO", "bucketHootch", 1L, 1), null, 2800, 0); + //CORE.RA.addFuel(GT_ModHandler.getModItem("EnderIO", "bucketFire_water", 1L, 1), null, 2800, 0); + //System.exit(1); } } \ No newline at end of file diff --git a/src/Java/miscutil/core/recipe/RECIPES_LaserEngraver.java b/src/Java/miscutil/core/recipe/RECIPES_LaserEngraver.java new file mode 100644 index 0000000000..3d8f7862ee --- /dev/null +++ b/src/Java/miscutil/core/recipe/RECIPES_LaserEngraver.java @@ -0,0 +1,32 @@ +package miscutil.core.recipe; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OreDictNames; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.interfaces.IOreRecipeRegistrator; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import miscutil.gregtech.api.enums.GregtechItemList; +import net.minecraft.item.ItemStack; + +public class RECIPES_LaserEngraver implements IOreRecipeRegistrator { + public RECIPES_LaserEngraver() { + OrePrefixes.crafting.add(this); + } + + @Override + public void registerOre(OrePrefixes aPrefix, Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) { + if (aOreDictName.equals(OreDictNames.craftingLensBlue.toString())) { + GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.foil, Materials.YttriumBariumCuprate, 2L), GT_Utility.copyAmount(0L, new Object[]{aStack}), GregtechItemList.Circuit_Parts_Wiring_IV.get(1L, new Object[0]), 64, 480); + } else if (aOreDictName.equals(OreDictNames.craftingLensYellow.toString())) { + GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Osmium, 2L), GT_Utility.copyAmount(0L, new Object[]{aStack}), GregtechItemList.Circuit_Parts_Wiring_LuV.get(1L, new Object[0]), 64, 1024); + } else if (aOreDictName.equals(OreDictNames.craftingLensCyan.toString())) { + } else if (aOreDictName.equals(OreDictNames.craftingLensRed.toString())) { + } else if (aOreDictName.equals(OreDictNames.craftingLensGreen.toString())) { + GT_Values.RA.addLaserEngraverRecipe(GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Naquadah, 2L), GT_Utility.copyAmount(0L, new Object[]{aStack}), GregtechItemList.Circuit_Parts_Wiring_ZPM.get(1L, new Object[0]), 64, 2000); + } else if (aOreDictName.equals(OreDictNames.craftingLensWhite.toString())) { + + } + } +} diff --git a/src/Java/miscutil/core/recipe/RECIPES_MachineComponents.java b/src/Java/miscutil/core/recipe/RECIPES_MachineComponents.java new file mode 100644 index 0000000000..1cefaadd1e --- /dev/null +++ b/src/Java/miscutil/core/recipe/RECIPES_MachineComponents.java @@ -0,0 +1,351 @@ +package miscutil.core.recipe; + +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.util.GT_OreDictUnificator; +import miscutil.core.util.Utils; +import miscutil.core.util.recipe.UtilsRecipe; +import miscutil.gregtech.api.enums.GregtechItemList; +import net.minecraft.item.ItemStack; + +public class RECIPES_MachineComponents { + + //Outputs + static ItemStack RECIPE_Circuit_IV = GregtechItemList.Circuit_IV.get(1); + static ItemStack RECIPE_Circuit_LuV = GregtechItemList.Circuit_LuV.get(1); + static ItemStack RECIPE_Circuit_ZPM = GregtechItemList.Circuit_ZPM.get(1); + static ItemStack RECIPE_Circuit_Board_IV = GregtechItemList.Circuit_Board_IV.get(1); + static ItemStack RECIPE_Circuit_Board_LuV = GregtechItemList.Circuit_Board_LuV.get(1); + static ItemStack RECIPE_Circuit_Board_ZPM = GregtechItemList.Circuit_Board_ZPM.get(1); + static ItemStack RECIPE_Circuit_Parts_Crystal_Chip_IV = GregtechItemList.Circuit_Parts_Crystal_Chip_IV.get(1); + static ItemStack RECIPE_Circuit_Parts_Crystal_Chip_LuV = GregtechItemList.Circuit_Parts_Crystal_Chip_LuV.get(1); + static ItemStack RECIPE_Circuit_Parts_Crystal_Chip_ZPM = GregtechItemList.Circuit_Parts_Crystal_Chip_ZPM.get(1); + static ItemStack RECIPE_Circuit_Parts_IV = GregtechItemList.Circuit_Parts_IV.get(1); + static ItemStack RECIPE_Circuit_Parts_LuV = GregtechItemList.Circuit_Parts_LuV.get(1); + static ItemStack RECIPE_Circuit_Parts_ZPM = GregtechItemList.Circuit_Parts_ZPM.get(1); + + //Wire + static String wireTier6 = "wireGt08NiobiumTitanium"; + static String wireTier7 = "wireGt08Osmium"; + static String wireTier8 = "wireGt08Naquadah"; + static String wireTier9 = "wireGt08Superconductor"; + static String wireTier10 = "wireGt16Superconductor"; + + //Wire + static String cableTier6 = "cableGt04Tungsten"; + static String cableTier7 = "cableGt04NiobiumTitanium"; + static String cableTier8 = "cableGt04Osmium"; + static String cableTier9 = "cableGt04Naquadah"; + static String cableTier10 = "wireGt08Superconductor"; + + //Plates + static String plateTier7 = "plateChrome"; + static String plateTier8 = "plateIridium"; + static String plateTier9 = "plateOsmium"; + static String plateTier10 = "plateNeutronium"; + + //rods + static String rodTier7a = "stickChrome"; + static String rodTier8a = "stickIridium"; + static String rodTier9a = "stickOsmium"; + static String rodTier10a = "stickNeutronium"; + static String rodTier7b = "stickPlatinum"; + static String rodTier8b = "stickChrome"; + static String rodTier9b = "stickIridium"; + static String rodTier10b = "stickOsmium"; + static String rodTier7c = "stickTitanium"; + static String rodTier8c = "stickTungstenSteel"; + static String rodTier9c = "stickNaquadah"; + static String rodTier10c = "stickOsmium"; + + //Screws + static String screwTier7 = "screwChrome"; + static String screwTier8 = "screwIridium"; + static String screwTier9 = "screwOsmium"; + static String screwTier10 = "screwNeutronium"; + + //Rotors + static String rotorTier7 = "rotorChrome"; + static String rotorTier8 = "rotorIridium"; + static String rotorTier9 = "rotorOsmium"; + static String rotorTier10 = "rotorNeutronium"; + + //Fluid Pipe + static String pipeTier7 = "pipeHugeSteel"; + static String pipeTier8 = "pipeHugeStainlessSteel"; + static String pipeTier9 = "pipeHugeTitanium"; + static String pipeTier10 = "pipeHugeTungstenSteel"; + + //Rubber Ring/Plate + static String itemRubberRing = "ringRubber"; + static String plateRubber = "plateRubber"; + + //Circuits + static String circuitTier6 = "circuitMaster"; + static String circuitTier7 = "circuitUltimate"; + static String circuitTier8 = "circuitSymbiotic"; + static String circuitTier9 = "circuitNeutronic"; + static String circuitTier10 = "circuitQuantum"; + + //small gears + static String smallGearTier7 = "gearGtSmallChrome"; + static String smallGearTier8 = "gearGtSmallIridium"; + static String smallGearTier9 = "gearGtSmallOsmium"; + static String smallGearTier10 = "gearGtSmallNeutronium"; + + //Crafting Tools + static String craftingToolWrench = "craftingToolWrench"; + static String craftingToolScrewdriver = "craftingToolScrewdriver"; + + //Machine Components + static ItemStack electricMotor_LuV = GregtechItemList.Electric_Motor_LuV.get(1); + static ItemStack electricMotor_ZPM = GregtechItemList.Electric_Motor_ZPM.get(1); + static ItemStack electricMotor_UV = GregtechItemList.Electric_Motor_UV.get(1); + static ItemStack electricMotor_MAX = GregtechItemList.Electric_Motor_MAX.get(1); + + static ItemStack electricPump_LuV = GregtechItemList.Electric_Pump_LuV.get(1); + static ItemStack electricPump_ZPM = GregtechItemList.Electric_Pump_ZPM.get(1); + static ItemStack electricPump_UV = GregtechItemList.Electric_Pump_UV.get(1); + static ItemStack electricPump_MAX = GregtechItemList.Electric_Pump_MAX.get(1); + + static ItemStack electricPiston_LuV = GregtechItemList.Electric_Piston_LuV.get(1); + static ItemStack electricPiston_ZPM = GregtechItemList.Electric_Piston_ZPM.get(1); + static ItemStack electricPiston_UV = GregtechItemList.Electric_Piston_UV.get(1); + static ItemStack electricPiston_MAX = GregtechItemList.Electric_Piston_MAX.get(1); + + static ItemStack robotArm_LuV = GregtechItemList.Robot_Arm_LuV.get(1); + static ItemStack robotArm_ZPM = GregtechItemList.Robot_Arm_ZPM.get(1); + static ItemStack robotArm_UV = GregtechItemList.Robot_Arm_UV.get(1); + static ItemStack robotArm_MAX = GregtechItemList.Robot_Arm_MAX.get(1); + + static ItemStack conveyorModule_LuV = GregtechItemList.Conveyor_Module_LuV.get(1); + static ItemStack conveyorModule_ZPM = GregtechItemList.Conveyor_Module_ZPM.get(1); + static ItemStack conveyorModule_UV = GregtechItemList.Conveyor_Module_UV.get(1); + static ItemStack conveyorModule_MAX = GregtechItemList.Conveyor_Module_MAX.get(1); + + static ItemStack emitter_LuV = GregtechItemList.Emitter_LuV.get(1); + static ItemStack emitter_ZPM = GregtechItemList.Emitter_ZPM.get(1); + static ItemStack emitter_UV = GregtechItemList.Emitter_UV.get(1); + static ItemStack emitter_MAX = GregtechItemList.Emitter_MAX.get(1); + + static ItemStack fieldGenerator_LuV = GregtechItemList.Field_Generator_LuV.get(1); + static ItemStack fieldGenerator_ZPM = GregtechItemList.Field_Generator_ZPM.get(1); + static ItemStack fieldGenerator_UV = GregtechItemList.Field_Generator_UV.get(1); + static ItemStack fieldGenerator_MAX = GregtechItemList.Field_Generator_MAX.get(1); + + static ItemStack sensor_LuV = GregtechItemList.Sensor_LuV.get(1); + static ItemStack sensor_ZPM = GregtechItemList.Sensor_ZPM.get(1); + static ItemStack sensor_UV = GregtechItemList.Sensor_UV.get(1); + static ItemStack sensor_MAX = GregtechItemList.Sensor_MAX.get(1); + + public static final void RECIPES_LOAD(){ + run(); + Utils.LOG_INFO("Loading Recipes for the Various Circuits and their components."); + } + + private static void run(){ + //Electric Motors + UtilsRecipe.recipeBuilder( + cableTier7, wireTier7, rodTier7a, + wireTier7, rodTier7b, wireTier7, + rodTier7a, wireTier7, cableTier7, + electricMotor_LuV); + UtilsRecipe.recipeBuilder( + cableTier8, wireTier8, rodTier8a, + wireTier8, rodTier8b, wireTier8, + rodTier8a, wireTier8, cableTier8, + electricMotor_ZPM); + UtilsRecipe.recipeBuilder( + cableTier9, wireTier9, rodTier9a, + wireTier9, rodTier9b, wireTier9, + rodTier9a, wireTier9, cableTier9, + electricMotor_UV); + UtilsRecipe.recipeBuilder( + cableTier10, wireTier10, rodTier10a, + wireTier10, rodTier10b, wireTier10, + rodTier10a, wireTier10, cableTier10, + electricMotor_MAX); + + //Electric Pump + UtilsRecipe.recipeBuilder( + cableTier7, rotorTier7, itemRubberRing, + craftingToolScrewdriver, pipeTier7, craftingToolWrench, + itemRubberRing, electricMotor_LuV, cableTier7, + electricPump_LuV); + UtilsRecipe.recipeBuilder( + cableTier8, rotorTier8, itemRubberRing, + craftingToolScrewdriver, pipeTier8, craftingToolWrench, + itemRubberRing, electricMotor_ZPM, cableTier8, + electricPump_ZPM); + UtilsRecipe.recipeBuilder( + cableTier9, rotorTier9, itemRubberRing, + craftingToolScrewdriver, pipeTier9, craftingToolWrench, + itemRubberRing, electricMotor_UV, cableTier9, + electricPump_UV); + UtilsRecipe.recipeBuilder( + cableTier10, rotorTier10, itemRubberRing, + craftingToolScrewdriver, pipeTier10, craftingToolWrench, + itemRubberRing, electricMotor_MAX, cableTier10, + electricPump_MAX); + + //Electric Pump + UtilsRecipe.recipeBuilder( + plateTier7, plateTier7, plateTier7, + cableTier7, rodTier7a, rodTier7a, + cableTier7, electricMotor_LuV, smallGearTier7, + electricPiston_LuV); + UtilsRecipe.recipeBuilder( + plateTier8, plateTier8, plateTier8, + cableTier8, rodTier8a, rodTier8a, + cableTier8, electricMotor_ZPM, smallGearTier8, + electricPiston_ZPM); + UtilsRecipe.recipeBuilder( + plateTier9, plateTier9, plateTier9, + cableTier9, rodTier9a, rodTier9a, + cableTier9, electricMotor_UV, smallGearTier9, + electricPiston_UV); + UtilsRecipe.recipeBuilder( + plateTier10, plateTier10, plateTier10, + cableTier10, rodTier10a, rodTier10a, + cableTier10, electricMotor_MAX, smallGearTier10, + electricPiston_MAX); + + //Robot Arms + UtilsRecipe.recipeBuilder( + cableTier7, cableTier7, cableTier7, + electricMotor_LuV, rodTier7a, electricMotor_LuV, + electricPiston_LuV, circuitTier7, rodTier7a, + robotArm_LuV); + UtilsRecipe.recipeBuilder( + cableTier8, cableTier8, cableTier8, + electricMotor_ZPM, rodTier8a, electricMotor_ZPM, + electricPiston_ZPM, circuitTier8, rodTier8a, + robotArm_ZPM); + UtilsRecipe.recipeBuilder( + cableTier9, cableTier9, cableTier9, + electricMotor_UV, rodTier9a, electricMotor_UV, + electricPiston_UV, circuitTier9, rodTier9a, + robotArm_UV); + UtilsRecipe.recipeBuilder( + cableTier10, cableTier10, cableTier10, + electricMotor_MAX, rodTier10a, electricMotor_MAX, + electricPiston_MAX, circuitTier10, rodTier10a, + robotArm_MAX); + + //Conveyor Modules + UtilsRecipe.recipeBuilder( + plateRubber, plateRubber, plateRubber, + electricMotor_LuV, cableTier7, electricMotor_LuV, + plateRubber, plateRubber, plateRubber, + conveyorModule_LuV); + UtilsRecipe.recipeBuilder( + plateRubber, plateRubber, plateRubber, + electricMotor_ZPM, cableTier8, electricMotor_ZPM, + plateRubber, plateRubber, plateRubber, + conveyorModule_ZPM); + UtilsRecipe.recipeBuilder( + plateRubber, plateRubber, plateRubber, + electricMotor_UV, cableTier9, electricMotor_UV, + plateRubber, plateRubber, plateRubber, + conveyorModule_UV); + UtilsRecipe.recipeBuilder( + plateRubber, plateRubber, plateRubber, + electricMotor_MAX, cableTier10, electricMotor_MAX, + plateRubber, plateRubber, plateRubber, + conveyorModule_MAX); + + //Emitter Modules + UtilsRecipe.recipeBuilder( + rodTier7c, rodTier7c, circuitTier7, + cableTier7, circuitTier6, rodTier7c, + circuitTier7, cableTier7, rodTier7c, + emitter_LuV); + UtilsRecipe.recipeBuilder( + rodTier8c, rodTier8c, circuitTier8, + cableTier8, circuitTier7, rodTier8c, + circuitTier8, cableTier8, rodTier8c, + emitter_ZPM); + UtilsRecipe.recipeBuilder( + rodTier9c, rodTier9c, circuitTier9, + cableTier9, circuitTier8, rodTier9c, + circuitTier9, cableTier9, rodTier9c, + emitter_UV); + UtilsRecipe.recipeBuilder( + rodTier10c, rodTier10c, circuitTier10, + cableTier10, circuitTier9, rodTier10c, + circuitTier10, cableTier10, rodTier10c, + emitter_MAX); + + //Field Generator Modules + UtilsRecipe.recipeBuilder( + wireTier7, circuitTier7, wireTier7, + circuitTier7, circuitTier6, circuitTier7, + wireTier7, circuitTier7, wireTier7, + fieldGenerator_LuV); + UtilsRecipe.recipeBuilder( + wireTier8, circuitTier8, wireTier8, + circuitTier8, circuitTier7, circuitTier8, + wireTier8, circuitTier8, wireTier8, + fieldGenerator_ZPM); + UtilsRecipe.recipeBuilder( + wireTier9, circuitTier9, wireTier9, + circuitTier9, circuitTier8, circuitTier9, + wireTier9, circuitTier9, wireTier9, + fieldGenerator_UV); + UtilsRecipe.recipeBuilder( + wireTier10, circuitTier10, wireTier10, + circuitTier10, circuitTier9, circuitTier10, + wireTier10, circuitTier10, wireTier10, + fieldGenerator_MAX); + + //Sensor Modules + UtilsRecipe.recipeBuilder( + plateTier7, null, circuitTier6, + plateTier7, rodTier7c, null, + circuitTier7, plateTier7, plateTier7, + sensor_LuV); + UtilsRecipe.recipeBuilder( + plateTier8, null, circuitTier7, + plateTier8, rodTier8c, null, + circuitTier8, plateTier8, plateTier8, + sensor_ZPM); + UtilsRecipe.recipeBuilder( + plateTier9, null, circuitTier8, + plateTier9, rodTier9c, null, + circuitTier9, plateTier9, plateTier9, + sensor_UV); + UtilsRecipe.recipeBuilder( + plateTier10, null, circuitTier9, + plateTier10, rodTier10c, null, + circuitTier10, plateTier10, plateTier10, + sensor_MAX); + + Utils.LOG_INFO("Done loading recipes for the Various circuit content."); + GregtechMachinePhase(); + } + + private static void GregtechMachinePhase(){ + Utils.LOG_INFO("Adding Gregtech machine recipes for the components."); + GT_Values.RA.addFormingPressRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Silicon, 1L), GregtechItemList.Circuit_Parts_Wiring_IV.get(4L, new Object[0]), GregtechItemList.Circuit_Board_IV.get(1L, new Object[0]), 32, 256); + GT_Values.RA.addFormingPressRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Silicon, 1L), GregtechItemList.Circuit_Parts_Wiring_LuV.get(4L, new Object[0]), GregtechItemList.Circuit_Board_LuV.get(1L, new Object[0]), 64, 512); + GT_Values.RA.addFormingPressRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Silicon, 2L), GregtechItemList.Circuit_Parts_Wiring_ZPM.get(4L, new Object[0]), GregtechItemList.Circuit_Board_ZPM.get(1L, new Object[0]), 96, 1024); + GT_Values.RA.addFormingPressRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Lazurite, 1L), GregtechItemList.Circuit_Parts_Crystal_Chip_IV.get(3L, new Object[0]), GregtechItemList.Circuit_Parts_IV.get(1L, new Object[0]), 32, 512); + GT_Values.RA.addFormingPressRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Lazurite, 1L), GregtechItemList.Circuit_Parts_Crystal_Chip_LuV.get(3L, new Object[0]), GregtechItemList.Circuit_Parts_LuV.get(1L, new Object[0]), 64, 1024); + GT_Values.RA.addFormingPressRecipe(GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Lazurite, 1L), GregtechItemList.Circuit_Parts_Crystal_Chip_ZPM.get(3L, new Object[0]), GregtechItemList.Circuit_Parts_ZPM.get(1L, new Object[0]), 96, 2048); + GT_Values.RA.addForgeHammerRecipe(ItemList.Circuit_Master.get(1L, new Object[0]), GregtechItemList.Circuit_Parts_Crystal_Chip_IV.get(5L, new Object[0]), 32, 256); + GT_Values.RA.addForgeHammerRecipe(GregtechItemList.Circuit_IV.get(1L, new Object[0]), GregtechItemList.Circuit_Parts_Crystal_Chip_LuV.get(5L, new Object[0]), 64, 512); + GT_Values.RA.addForgeHammerRecipe(GregtechItemList.Circuit_LuV.get(1L, new Object[0]), GregtechItemList.Circuit_Parts_Crystal_Chip_ZPM.get(5L, new Object[0]), 128, 1024); + for (Materials tMat : Materials.VALUES) { + if ((tMat.mStandardMoltenFluid != null) && (tMat.contains(SubTag.SOLDERING_MATERIAL))) { + int tMultiplier = tMat.contains(SubTag.SOLDERING_MATERIAL_GOOD) ? 1 : tMat.contains(SubTag.SOLDERING_MATERIAL_BAD) ? 4 : 2; + GT_Values.RA.addAssemblerRecipe(GregtechItemList.Circuit_Board_IV.get(1L, new Object[0]), GregtechItemList.Circuit_Parts_IV.get(1L, new Object[0]), tMat.getMolten(144L * tMultiplier / 4L), GregtechItemList.Circuit_IV.get(1L, new Object[0]), 32, 512); + GT_Values.RA.addAssemblerRecipe(GregtechItemList.Circuit_Board_LuV.get(1L, new Object[0]), GregtechItemList.Circuit_Parts_LuV.get(1L, new Object[0]), tMat.getMolten(144L * tMultiplier / 4L), GregtechItemList.Circuit_LuV.get(1L, new Object[0]), 64, 1024); + GT_Values.RA.addAssemblerRecipe(GregtechItemList.Circuit_Board_ZPM.get(1L, new Object[0]), GregtechItemList.Circuit_Parts_ZPM.get(1L, new Object[0]), tMat.getMolten(144L * tMultiplier / 4L), GregtechItemList.Circuit_ZPM.get(1L, new Object[0]), 96, 2048); + + } + } + } +} diff --git a/src/Java/miscutil/gregtech/api/enums/GregtechItemList.java b/src/Java/miscutil/gregtech/api/enums/GregtechItemList.java index 784f521765..6db2a06be7 100644 --- a/src/Java/miscutil/gregtech/api/enums/GregtechItemList.java +++ b/src/Java/miscutil/gregtech/api/enums/GregtechItemList.java @@ -69,8 +69,16 @@ public enum GregtechItemList implements GregtechItemContainer { Field_Generator_LuV, Field_Generator_ZPM, Field_Generator_UV, Field_Generator_MAX, Emitter_LuV, Emitter_ZPM, Emitter_UV, Emitter_MAX, Sensor_LuV, Sensor_ZPM, Sensor_UV, Sensor_MAX, + + //Circuits Circuit_Primitive, Circuit_Basic, Circuit_Good, Circuit_Advanced, - Circuit_Data, Circuit_Elite, Circuit_Master; + Circuit_Data, Circuit_Elite, Circuit_Master, Tool_DataOrb, Circuit_Ultimate, Tool_DataStick, + Circuit_IV, Circuit_LuV, Circuit_ZPM, + //Circuit Parts + Circuit_Board_IV, Circuit_Board_LuV, Circuit_Board_ZPM, + Circuit_Parts_Crystal_Chip_IV, Circuit_Parts_Crystal_Chip_LuV, Circuit_Parts_Crystal_Chip_ZPM, + Circuit_Parts_IV, Circuit_Parts_LuV, Circuit_Parts_ZPM, + Circuit_Parts_Wiring_IV, Circuit_Parts_Wiring_LuV, Circuit_Parts_Wiring_ZPM; public static final GregtechItemList[] DYE_ONLY_ITEMS = { diff --git a/src/Java/miscutil/gregtech/api/enums/GregtechOreDictNames.java b/src/Java/miscutil/gregtech/api/enums/GregtechOreDictNames.java index 56079d38c1..7720ed8c0f 100644 --- a/src/Java/miscutil/gregtech/api/enums/GregtechOreDictNames.java +++ b/src/Java/miscutil/gregtech/api/enums/GregtechOreDictNames.java @@ -1,8 +1,34 @@ package miscutil.gregtech.api.enums; - +/* Electric Components. +* +* usual Materials for this are: +* Primitive (Tier 1) +* Basic (Tier 2) as used by UE as well : IC2 Circuit and RE-Battery +* Good (Tier 3) +* Advanced (Tier 4) as used by UE as well : Advanced Circuit, Advanced Battery and Lithium Battery +* Data (Tier 5) : Data Storage Circuit +* Elite (Tier 6) as used by UE as well : Energy Crystal and Data Control Circuit +* Master (Tier 7) : Energy Flow Circuit and Lapotron Crystal +* Ultimate (Tier 8) : Data Orb and Lapotronic Energy Orb +* Infinite (Cheaty) +* +Circuits + Circuit_Primitive, Circuit_Basic, Circuit_Good, Circuit_Advanced, + Circuit_Data, Circuit_Elite, Circuit_Master, Tool_DataOrb, Circuit_Ultimate, Tool_DataStick, + Circuit_IV, Circuit_LuV, Circuit_ZPM, +Circuit Parts + Circuit_Board_IV, Circuit_Board_LuV, Circuit_Board_ZPM, + Circuit_Parts_Crystal_Chip_IV, Circuit_Parts_Crystal_Chip_LuV, Circuit_Parts_Crystal_Chip_ZPM, + Circuit_Parts_IV, Circuit_Parts_LuV, Circuit_Parts_ZPM, + Circuit_Parts_Wiring_IV, Circuit_Parts_Wiring_LuV, Circuit_Parts_Wiring_ZPM; +*/ public enum GregtechOreDictNames { - buffer_core, itemGregConduit; + buffer_core, itemGregConduit, Circuit_IV, Circuit_LuV, Circuit_ZPM, + Circuit_Board_IV, Circuit_Board_LuV, Circuit_Board_ZPM, + Circuit_Parts_Crystal_Chip_IV, Circuit_Parts_Crystal_Chip_LuV, Circuit_Parts_Crystal_Chip_ZPM, + Circuit_Parts_IV, Circuit_Parts_LuV, Circuit_Parts_ZPM, + Circuit_Parts_Wiring_IV, Circuit_Parts_Wiring_LuV, Circuit_Parts_Wiring_ZPM; public String unlocalisedName; diff --git a/src/Java/miscutil/gregtech/api/enums/GregtechOrePrefixes.java b/src/Java/miscutil/gregtech/api/enums/GregtechOrePrefixes.java new file mode 100644 index 0000000000..305f248345 --- /dev/null +++ b/src/Java/miscutil/gregtech/api/enums/GregtechOrePrefixes.java @@ -0,0 +1,744 @@ +package miscutil.gregtech.api.enums; + +import static gregtech.api.enums.GT_Values.D2; +import static gregtech.api.enums.GT_Values.M; +import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.Dyes; +import gregtech.api.enums.Element; +import gregtech.api.enums.Materials; +import gregtech.api.enums.SubTag; +import gregtech.api.enums.TC_Aspects; +import gregtech.api.enums.TC_Aspects.TC_AspectStack; +import gregtech.api.enums.TextureSet; +import gregtech.api.interfaces.IColorModulationContainer; +import gregtech.api.interfaces.ICondition; +import gregtech.api.interfaces.ISubTagContainer; +import gregtech.api.objects.GT_FluidStack; +import gregtech.api.objects.MaterialStack; +import gregtech.api.util.GT_Config; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_Utility; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; + +import miscutil.core.lib.CORE; +import miscutil.gregtech.api.interfaces.internal.Interface_OreRecipeRegistrator; +import miscutil.gregtech.api.objects.GregtechItemData; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; + +public enum GregtechOrePrefixes { + /* Electric Components. + * + * usual Materials for this are: + * Primitive (Tier 1) + * Basic (Tier 2) as used by UE as well : IC2 Circuit and RE-Battery + * Good (Tier 3) + * Advanced (Tier 4) as used by UE as well : Advanced Circuit, Advanced Battery and Lithium Battery + * Data (Tier 5) : Data Storage Circuit + * Elite (Tier 6) as used by UE as well : Energy Crystal and Data Control Circuit + * Master (Tier 7) : Energy Flow Circuit and Lapotron Crystal + * Ultimate (Tier 8) : Data Orb and Lapotronic Energy Orb + * Infinite (Cheaty) + */ + batterySingleuse("Single Use Batteries", "", "", false, true, false, false, false, false, false, false, false, false, 0, -1, 64, -1), + battery("Reusable Batteries", "", "", false, true, false, false, false, false, false, false, false, false, 0, -1, 64, -1), // Introduced by Calclavia + circuit("Circuits", "", "", true, true, false, false, false, false, false, false, false, false, 0, -1, 64, -1), // Introduced by Calclavia + chipset("Chipsets", "", "", true, true, false, false, false, false, false, false, false, false, 0, -1, 64, -1), // Introduced by Buildcraft + computer("Computers", "", "", true, true, false, false, true, false, false, false, false, false, 0, -1, 64, -1); // A whole Computer. "computerMaster" = ComputerCube + + //public static volatile int VERSION = 508; + + public final ArrayList mPrefixedItems = new ArrayList(); + public final short mTextureIndex; + public final String mRegularLocalName, mLocalizedMaterialPre, mLocalizedMaterialPost; + public final boolean mIsUsedForOreProcessing, mIsEnchantable, mIsUnificatable, mIsMaterialBased, mIsSelfReferencing, mIsContainer, mDontUnificateActively, mIsUsedForBlocks, mAllowNormalRecycling, mGenerateDefaultItem; + public final List mAspects = new ArrayList(); + public final Collection mFamiliarPrefixes = new HashSet(); + /** + * Used to determine the amount of Material this Prefix contains. + * Multiply or Divide GregTech_API.MATERIAL_UNIT to get the Amounts in comparision to one Ingot. + * 0 = Null + * Negative = Undefined Amount + */ + public final long mMaterialAmount; + private final Collection mNotGeneratedItems = new HashSet(), mIgnoredMaterials = new HashSet(), mGeneratedItems = new HashSet(); + private final ArrayList mOreProcessing = new ArrayList(); + public ItemStack mContainerItem = null; + public ICondition mCondition = null; + public byte mDefaultStackSize = 64; + public MaterialStack mSecondaryMaterial = null; + public GregtechOrePrefixes mPrefixInto = this; + public float mHeatDamage = 0.0F; // Negative for Frost Damage + /** + * Yes this Value can be changed to add Bits for the MetaGenerated-Item-Check. + */ + public int mMaterialGenerationBits = 0; + private GregtechOrePrefixes(String aRegularLocalName, String aLocalizedMaterialPre, String aLocalizedMaterialPost, boolean aIsUnificatable, boolean aIsMaterialBased, boolean aIsSelfReferencing, boolean aIsContainer, boolean aDontUnificateActively, boolean aIsUsedForBlocks, boolean aAllowNormalRecycling, boolean aGenerateDefaultItem, boolean aIsEnchantable, boolean aIsUsedForOreProcessing, int aMaterialGenerationBits, long aMaterialAmount, int aDefaultStackSize, int aTextureindex) { + mIsUnificatable = aIsUnificatable; + mIsMaterialBased = aIsMaterialBased; + mIsSelfReferencing = aIsSelfReferencing; + mIsContainer = aIsContainer; + mDontUnificateActively = aDontUnificateActively; + mIsUsedForBlocks = aIsUsedForBlocks; + mAllowNormalRecycling = aAllowNormalRecycling; + mGenerateDefaultItem = aGenerateDefaultItem; + mIsEnchantable = aIsEnchantable; + mIsUsedForOreProcessing = aIsUsedForOreProcessing; + mMaterialGenerationBits = aMaterialGenerationBits; + mMaterialAmount = aMaterialAmount; + mRegularLocalName = aRegularLocalName; + mLocalizedMaterialPre = aLocalizedMaterialPre; + mLocalizedMaterialPost = aLocalizedMaterialPost; + mDefaultStackSize = (byte) aDefaultStackSize; + mTextureIndex = (short) aTextureindex; + + if (name().startsWith("ore")) { + new TC_AspectStack(TC_Aspects.TERRA, 1).addToAspectList(mAspects); + } else if (name().startsWith("wire") || name().startsWith("cable")) { + new TC_AspectStack(TC_Aspects.ELECTRUM, 1).addToAspectList(mAspects); + } else if (name().startsWith("dust")) { + new TC_AspectStack(TC_Aspects.PERDITIO, 1).addToAspectList(mAspects); + } else if (name().startsWith("crushed")) { + new TC_AspectStack(TC_Aspects.PERFODIO, 1).addToAspectList(mAspects); + } else if (name().startsWith("ingot") || name().startsWith("nugget")) { + new TC_AspectStack(TC_Aspects.METALLUM, 1).addToAspectList(mAspects); + } else if (name().startsWith("armor")) { + new TC_AspectStack(TC_Aspects.TUTAMEN, 1).addToAspectList(mAspects); + } else if (name().startsWith("stone")) { + new TC_AspectStack(TC_Aspects.TERRA, 1).addToAspectList(mAspects); + } else if (name().startsWith("pipe")) { + new TC_AspectStack(TC_Aspects.ITER, 1).addToAspectList(mAspects); + } else if (name().startsWith("gear")) { + new TC_AspectStack(TC_Aspects.MOTUS, 1).addToAspectList(mAspects); + new TC_AspectStack(TC_Aspects.MACHINA, 1).addToAspectList(mAspects); + } else if (name().startsWith("frame") || name().startsWith("plate")) { + new TC_AspectStack(TC_Aspects.FABRICO, 1).addToAspectList(mAspects); + } else if (name().startsWith("tool")) { + new TC_AspectStack(TC_Aspects.INSTRUMENTUM, 2).addToAspectList(mAspects); + } else if (name().startsWith("gem") || name().startsWith("crystal") || name().startsWith("lens")) { + new TC_AspectStack(TC_Aspects.VITREUS, 1).addToAspectList(mAspects); + } else if (name().startsWith("crate")) { + new TC_AspectStack(TC_Aspects.ITER, 2).addToAspectList(mAspects); + } else if (name().startsWith("circuit")) { + new TC_AspectStack(TC_Aspects.COGNITIO, 1).addToAspectList(mAspects); + } else if (name().startsWith("computer")) { + new TC_AspectStack(TC_Aspects.COGNITIO, 4).addToAspectList(mAspects); + } else if (name().startsWith("battery")) { + new TC_AspectStack(TC_Aspects.ELECTRUM, 1).addToAspectList(mAspects); + } + } + + public static GregtechOrePrefixes getOrePrefix(String aOre) { + for (GregtechOrePrefixes tPrefix : values()) + if (aOre.startsWith(tPrefix.toString())) { + return tPrefix; + } + return null; + } + + public static String stripPrefix(String aOre) { + for (GregtechOrePrefixes tPrefix : values()) { + if (aOre.startsWith(tPrefix.toString())) { + return aOre.replaceFirst(tPrefix.toString(), ""); + } + } + return aOre; + } + + public static String replacePrefix(String aOre, GregtechOrePrefixes aPrefix) { + for (GregtechOrePrefixes tPrefix : values()) { + if (aOre.startsWith(tPrefix.toString())) { + return aOre.replaceFirst(tPrefix.toString(), aPrefix.toString()); + } + } + return ""; + } + + public static GregtechOrePrefixes getPrefix(String aPrefixName) { + return getPrefix(aPrefixName, null); + } + + public static GregtechOrePrefixes getPrefix(String aPrefixName, GregtechOrePrefixes aReplacement) { + Object tObject = GT_Utility.getFieldContent(GregtechOrePrefixes.class, aPrefixName, false, false); + if (tObject != null && tObject instanceof GregtechOrePrefixes) return (GregtechOrePrefixes) tObject; + return aReplacement; + } + + public static Materials getMaterial(String aOre) { + return Materials.get(stripPrefix(aOre)); + } + + public static Materials getMaterial(String aOre, GregtechOrePrefixes aPrefix) { + return Materials.get(aOre.replaceFirst(aPrefix.toString(), "")); + } + + public static Materials getRealMaterial(String aOre, GregtechOrePrefixes aPrefix) { + return Materials.getRealMaterial(aOre.replaceFirst(aPrefix.toString(), "")); + } + + public static boolean isInstanceOf(String aName, GregtechOrePrefixes aPrefix) { + return aName == null ? false : aName.startsWith(aPrefix.toString()); + } + + public boolean add(ItemStack aStack) { + if (aStack == null) return false; + if (!contains(aStack)) mPrefixedItems.add(aStack); + while (mPrefixedItems.contains(null)) mPrefixedItems.remove(null); + return true; + } + + public boolean contains(ItemStack aStack) { + if (aStack == null) return false; + for (ItemStack tStack : mPrefixedItems) + if (GT_Utility.areStacksEqual(aStack, tStack, !tStack.hasTagCompound())) return true; + return false; + } + + public boolean doGenerateItem(Materials aMaterial) { + return aMaterial != null && aMaterial != Materials._NULL && ((aMaterial.mTypes & mMaterialGenerationBits) != 0 || mGeneratedItems.contains(aMaterial)) && !mNotGeneratedItems.contains(aMaterial) && (mCondition == null || mCondition.isTrue(aMaterial)); + } + + public boolean ignoreMaterials(Materials... aMaterials) { + for (Materials tMaterial : aMaterials) if (tMaterial != null) mIgnoredMaterials.add(tMaterial); + return true; + } + + public boolean isIgnored(Materials aMaterial) { + if (aMaterial != null && (!aMaterial.mUnificatable || aMaterial != aMaterial.mMaterialInto)) return true; + return mIgnoredMaterials.contains(aMaterial); + } + + public boolean addFamiliarPrefix(GregtechOrePrefixes aPrefix) { + if (aPrefix == null || mFamiliarPrefixes.contains(aPrefix) || aPrefix == this) return false; + return mFamiliarPrefixes.add(aPrefix); + } + + public boolean add(Interface_OreRecipeRegistrator aRegistrator) { + if (aRegistrator == null) return false; + return mOreProcessing.add(aRegistrator); + } + + public void processOre(Materials aMaterial, String aOreDictName, String aModName, ItemStack aStack) { + if (aMaterial != null && (aMaterial != Materials._NULL || mIsSelfReferencing || !mIsMaterialBased) && GT_Utility.isStackValid(aStack)) + for (Interface_OreRecipeRegistrator tRegistrator : mOreProcessing) { + if (D2) + GT_Log.ore.println("Processing '" + aOreDictName + "' with the Prefix '" + name() + "' and the Material '" + aMaterial.name() + "' at " + GT_Utility.getClassName(tRegistrator)); + tRegistrator.registerOre(this, aMaterial, aOreDictName, aModName, GT_Utility.copyAmount(1, aStack)); + } + } + + public Object get(Object aMaterial) { + if (aMaterial instanceof Materials) return new GregtechItemData(this, (Materials) aMaterial); + return name() + aMaterial; + } + + @SuppressWarnings("incomplete-switch") + public String getDefaultLocalNameForItem(Materials aMaterial) { + + + // Use Standard Localization + return mLocalizedMaterialPre + aMaterial.mDefaultLocalName + mLocalizedMaterialPost; + } + + public enum GT_Materials implements IColorModulationContainer, ISubTagContainer { + + + + /** + * This is the Default Material returned in case no Material has been found or a NullPointer has been inserted at a location where it shouldn't happen. + *

+ * Mainly for preventing NullPointer Exceptions and providing Default Values. + */ + _NULL(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "NULL", 0, 0, 0, 0, false, false, 1, 1, 1, Dyes._NULL, Element._NULL, Arrays.asList(new TC_AspectStack(TC_Aspects.VACUOS, 1))), + + + /** + * Circuitry, Batteries and other Technical things + */ + Symbiotic(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "IV Tier", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 4), new TC_AspectStack(TC_Aspects.MACHINA, 4))), + Neutronic(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "LuV Tier", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 6), new TC_AspectStack(TC_Aspects.MACHINA, 6))), + Quantum(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "ZPM Tier", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 8), new TC_AspectStack(TC_Aspects.MACHINA, 8))); + + /*Advanced(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "Advanced", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.MACHINA, 4))), + Data(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "Data", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.MACHINA, 5))), + Elite(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "Elite", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.MACHINA, 6))), + Master(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "Master", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.MACHINA, 7))), + Ultimate(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "Ultimate", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.MACHINA, 8))), + Superconductor(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "Superconductor", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 8))), + Infinite(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "Infinite", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray);*/ + + /** + * List of all Materials. + */ + public static final Collection VALUES = new HashSet(Arrays.asList(values())); + + + static { + /*Primitive.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING); + Basic.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING); + Good.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING); + Advanced.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING); + Data.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING); + Elite.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING); + Master.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING); + Ultimate.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING); + Superconductor.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING); + Infinite.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING);*/ + Symbiotic.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING); + Neutronic.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING); + Quantum.add(SubTag.NO_SMASHING, SubTag.NO_SMELTING); + } + + + /** + * This Array can be changed dynamically by a Tick Handler in order to get a glowing Effect on all GT Meta Items out of this Material. + */ + public final short[] mRGBa = new short[]{255, 255, 255, 0}, mMoltenRGBa = new short[]{255, 255, 255, 0}; + public final TextureSet mIconSet; + public final int mMetaItemSubID; + public final boolean mUnificatable; + public final GT_Materials mMaterialInto; + public final List mMaterialList = new ArrayList(); + public final List mOreByProducts = new ArrayList(), mOreReRegistrations = new ArrayList(); + public final List mAspects = new ArrayList(); + private final ArrayList mMaterialItems = new ArrayList(); + private final Collection mSubTags = new HashSet(); + public Enchantment mEnchantmentTools = null, mEnchantmentArmors = null; + public byte mEnchantmentToolsLevel = 0, mEnchantmentArmorsLevel = 0; + public boolean mBlastFurnaceRequired = false; + public float mToolSpeed = 1.0F, mHeatDamage = 0.0F; + public String mChemicalFormula = "?", mDefaultLocalName = "null"; + public Dyes mColor = Dyes._NULL; + public short mMeltingPoint = 0, mBlastFurnaceTemp = 0; + public int mTypes = 0, mDurability = 16, mFuelPower = 0, mFuelType = 0, mExtraData = 0, mOreValue = 0, mOreMultiplier = 1, mByProductMultiplier = 1, mSmeltingMultiplier = 1; + public long mDensity = M; + public Element mElement = null; + public GT_Materials mDirectSmelting = this, mOreReplacement = this, mMacerateInto = this, mSmeltInto = this, mArcSmeltInto = this, mHandleMaterial = this; + public byte mToolQuality = 0; + public Fluid mSolid = null, mFluid = null, mGas = null, mPlasma = null; + /** + * This Fluid is used as standard Unit for Molten Materials. 1296 is a Molten Block, what means 144 is one Material Unit worth + */ + public Fluid mStandardMoltenFluid = null; + + private GT_Materials(int aMetaItemSubID, TextureSet aIconSet, float aToolSpeed, int aToolDurability, int aToolQuality, boolean aUnificatable) { + mUnificatable = aUnificatable; + mMaterialInto = this; + mMetaItemSubID = aMetaItemSubID; + mToolQuality = (byte) aToolQuality; + mDurability = aToolDurability; + mToolSpeed = aToolSpeed; + mIconSet = aIconSet; + if (aMetaItemSubID >= 0) { + if (CORE.sMU_GeneratedMaterials[aMetaItemSubID] == null) { + CORE.sMU_GeneratedMaterials[aMetaItemSubID] = this; + } else { + throw new IllegalArgumentException("The Index " + aMetaItemSubID + " is already used!"); + } + } + } + + private GT_Materials(GT_Materials aMaterialInto, boolean aReRegisterIntoThis) { + mUnificatable = false; + mDefaultLocalName = aMaterialInto.mDefaultLocalName; + mMaterialInto = aMaterialInto.mMaterialInto; + if (aReRegisterIntoThis) mMaterialInto.mOreReRegistrations.add(this); + mChemicalFormula = aMaterialInto.mChemicalFormula; + mMetaItemSubID = -1; + mIconSet = TextureSet.SET_NONE; + } + + /** + * @param aMetaItemSubID the Sub-ID used in my own MetaItems. Range 0-1000. -1 for no Material + * @param aTypes which kind of Items should be generated. Bitmask as follows: + * 1 = Dusts of all kinds. + * 2 = Dusts, Ingots, Plates, Rods/Sticks, Machine Components and other Metal specific things. + * 4 = Dusts, Gems, Plates, Lenses (if transparent). + * 8 = Dusts, Impure Dusts, crushed Ores, purified Ores, centrifuged Ores etc. + * 16 = Cells + * 32 = Plasma Cells + * 64 = Tool Heads + * 128 = Gears + * @param aR, aG, aB Color of the Material 0-255 each. + * @param aA transparency of the Material Texture. 0 = fully visible, 255 = Invisible. + * @param aLocalName The Name used as Default for localization. + * @param aFuelType Type of Generator to get Energy from this Material. + * @param aFuelPower EU generated. Will be multiplied by 1000, also additionally multiplied by 2 for Gems. + * @param aAmplificationValue Amount of UUM amplifier gotten from this. + * @param aUUMEnergy Amount of EU needed to shape the UUM into this Material. + * @param aMeltingPoint Used to determine the smelting Costs in Furnii. + * @param aBlastFurnaceTemp Used to determine the needed Heat capactiy Costs in Blast Furnii. + * @param aBlastFurnaceRequired If this requires a Blast Furnace. + * @param aColor Vanilla MC Wool Color which comes the closest to this. + */ + private GT_Materials(int aMetaItemSubID, TextureSet aIconSet, float aToolSpeed, int aToolDurability, int aToolQuality, int aTypes, int aR, int aG, int aB, int aA, String aLocalName, int aFuelType, int aFuelPower, int aMeltingPoint, int aBlastFurnaceTemp, boolean aBlastFurnaceRequired, boolean aTransparent, int aOreValue, int aDensityMultiplier, int aDensityDivider, Dyes aColor) { + this(aMetaItemSubID, aIconSet, aToolSpeed, aToolDurability, aToolQuality, true); + mDefaultLocalName = aLocalName; + mMeltingPoint = (short) aMeltingPoint; + mBlastFurnaceTemp = (short) aBlastFurnaceTemp; + mBlastFurnaceRequired = aBlastFurnaceRequired; + if (aTransparent) add(SubTag.TRANSPARENT); + mFuelPower = aFuelPower; + mFuelType = aFuelType; + mOreValue = aOreValue; + mDensity = (M * aDensityMultiplier) / aDensityDivider; + mColor = aColor == null ? Dyes._NULL : aColor; + if (mColor != null) add(SubTag.HAS_COLOR); + mRGBa[0] = mMoltenRGBa[0] = (short) aR; + mRGBa[1] = mMoltenRGBa[1] = (short) aG; + mRGBa[2] = mMoltenRGBa[2] = (short) aB; + mRGBa[3] = mMoltenRGBa[3] = (short) aA; + mTypes = aTypes; + if ((mTypes & 2) != 0) add(SubTag.SMELTING_TO_FLUID); + } + + private GT_Materials(int aMetaItemSubID, TextureSet aIconSet, float aToolSpeed, int aToolDurability, int aToolQuality, int aTypes, int aR, int aG, int aB, int aA, String aLocalName, int aFuelType, int aFuelPower, int aMeltingPoint, int aBlastFurnaceTemp, boolean aBlastFurnaceRequired, boolean aTransparent, int aOreValue, int aDensityMultiplier, int aDensityDivider, Dyes aColor, List aAspects) { + this(aMetaItemSubID, aIconSet, aToolSpeed, aToolDurability, aToolQuality, aTypes, aR, aG, aB, aA, aLocalName, aFuelType, aFuelPower, aMeltingPoint, aBlastFurnaceTemp, aBlastFurnaceRequired, aTransparent, aOreValue, aDensityMultiplier, aDensityDivider, aColor); + mAspects.addAll(aAspects); + } + + /** + * @param aElement The Element Enum represented by this Material + */ + private GT_Materials(int aMetaItemSubID, TextureSet aIconSet, float aToolSpeed, int aToolDurability, int aToolQuality, int aTypes, int aR, int aG, int aB, int aA, String aLocalName, int aFuelType, int aFuelPower, int aMeltingPoint, int aBlastFurnaceTemp, boolean aBlastFurnaceRequired, boolean aTransparent, int aOreValue, int aDensityMultiplier, int aDensityDivider, Dyes aColor, Element aElement, List aAspects) { + this(aMetaItemSubID, aIconSet, aToolSpeed, aToolDurability, aToolQuality, aTypes, aR, aG, aB, aA, aLocalName, aFuelType, aFuelPower, aMeltingPoint, aBlastFurnaceTemp, aBlastFurnaceRequired, aTransparent, aOreValue, aDensityMultiplier, aDensityDivider, aColor); + mElement = aElement; + //mElement.mLinkedMaterials.add(this); + if (aElement == Element._NULL) { + mChemicalFormula = "Empty"; + } else { + mChemicalFormula = aElement.toString(); + mChemicalFormula = mChemicalFormula.replaceAll("_", "-"); + } + mAspects.addAll(aAspects); + } + + private GT_Materials(int aMetaItemSubID, TextureSet aIconSet, float aToolSpeed, int aToolDurability, int aToolQuality, int aTypes, int aR, int aG, int aB, int aA, String aLocalName, int aFuelType, int aFuelPower, int aMeltingPoint, int aBlastFurnaceTemp, boolean aBlastFurnaceRequired, boolean aTransparent, int aOreValue, int aDensityMultiplier, int aDensityDivider, Dyes aColor, int aExtraData, List aMaterialList) { + this(aMetaItemSubID, aIconSet, aToolSpeed, aToolDurability, aToolQuality, aTypes, aR, aG, aB, aA, aLocalName, aFuelType, aFuelPower, aMeltingPoint, aBlastFurnaceTemp, aBlastFurnaceRequired, aTransparent, aOreValue, aDensityMultiplier, aDensityDivider, aColor, aExtraData, aMaterialList, null); + } + + private GT_Materials(int aMetaItemSubID, TextureSet aIconSet, float aToolSpeed, int aToolDurability, int aToolQuality, int aTypes, int aR, int aG, int aB, int aA, String aLocalName, int aFuelType, int aFuelPower, int aMeltingPoint, int aBlastFurnaceTemp, boolean aBlastFurnaceRequired, boolean aTransparent, int aOreValue, int aDensityMultiplier, int aDensityDivider, Dyes aColor, int aExtraData, List aMaterialList, List aAspects) { + this(aMetaItemSubID, aIconSet, aToolSpeed, aToolDurability, aToolQuality, aTypes, aR, aG, aB, aA, aLocalName, aFuelType, aFuelPower, aMeltingPoint, aBlastFurnaceTemp, aBlastFurnaceRequired, aTransparent, aOreValue, aDensityMultiplier, aDensityDivider, aColor); + mExtraData = aExtraData; + mMaterialList.addAll(aMaterialList); + mChemicalFormula = ""; + for (MaterialStack tMaterial : mMaterialList) mChemicalFormula += tMaterial.toString(); + mChemicalFormula = mChemicalFormula.replaceAll("_", "-"); + + int tAmountOfComponents = 0, tMeltingPoint = 0; + for (MaterialStack tMaterial : mMaterialList) { + tAmountOfComponents += tMaterial.mAmount; + if (tMaterial.mMaterial.mMeltingPoint > 0) + tMeltingPoint += tMaterial.mMaterial.mMeltingPoint * tMaterial.mAmount; + if (aAspects == null) + for (TC_AspectStack tAspect : tMaterial.mMaterial.mAspects) tAspect.addToAspectList(mAspects); + } + + if (mMeltingPoint < 0) mMeltingPoint = (short) (tMeltingPoint / tAmountOfComponents); + + tAmountOfComponents *= aDensityMultiplier; + tAmountOfComponents /= aDensityDivider; + if (aAspects == null) for (TC_AspectStack tAspect : mAspects) + tAspect.mAmount = Math.max(1, tAspect.mAmount / Math.max(1, tAmountOfComponents)); + else mAspects.addAll(aAspects); + } + + public static GT_Materials get(String aMaterialName) { + Object tObject = GT_Utility.getFieldContent(GT_Materials.class, aMaterialName, false, false); + if (tObject != null && tObject instanceof Materials) return (GT_Materials) tObject; + return _NULL; + } + + public static GT_Materials getRealMaterial(String aMaterialName) { + return get(aMaterialName).mMaterialInto; + } + + /** + * Called in preInit with the Config to set Values. + * + * @param aConfiguration + */ + public static void init(GT_Config aConfiguration) { + for (GT_Materials tMaterial : VALUES) { + String tString = tMaterial.toString().toLowerCase(); + tMaterial.mHeatDamage = (float) aConfiguration.get(ConfigCategories.Materials.heatdamage, tString, tMaterial.mHeatDamage); + if (tMaterial.mBlastFurnaceRequired) + tMaterial.mBlastFurnaceRequired = aConfiguration.get(ConfigCategories.Materials.blastfurnacerequirements, tString, true); + if (tMaterial.mBlastFurnaceRequired && aConfiguration.get(ConfigCategories.Materials.blastinductionsmelter, tString, tMaterial.mBlastFurnaceTemp < 1500)){} + //GT_ModHandler.ThermalExpansion.addSmelterBlastOre(tMaterial); + //tMaterial.mHandleMaterial = (tMaterial == Desh ? tMaterial.mHandleMaterial : tMaterial == Diamond || tMaterial == Thaumium ? Wood : tMaterial.contains(SubTag.BURNING) ? Blaze : tMaterial.contains(SubTag.MAGICAL) && tMaterial.contains(SubTag.CRYSTAL) && Loader.isModLoaded(MOD_ID_TC) ? Thaumium : tMaterial.getMass() > Element.Tc.getMass() * 2 ? TungstenSteel : tMaterial.getMass() > Element.Tc.getMass() ? Steel : Wood); + } + } + + public boolean isRadioactive() { + if (mElement != null) return mElement.mHalfLifeSeconds >= 0; + for (MaterialStack tMaterial : mMaterialList) if (tMaterial.mMaterial.isRadioactive()) return true; + return false; + } + + public long getProtons() { + if (mElement != null) return mElement.getProtons(); + if (mMaterialList.size() <= 0) return Element.Tc.getProtons(); + long rAmount = 0, tAmount = 0; + for (MaterialStack tMaterial : mMaterialList) { + tAmount += tMaterial.mAmount; + rAmount += tMaterial.mAmount * tMaterial.mMaterial.getProtons(); + } + return (getDensity() * rAmount) / (tAmount * M); + } + + public long getNeutrons() { + if (mElement != null) return mElement.getNeutrons(); + if (mMaterialList.size() <= 0) return Element.Tc.getNeutrons(); + long rAmount = 0, tAmount = 0; +