diff options
Diffstat (limited to 'src/main/java/gregtech/loaders/misc')
6 files changed, 1478 insertions, 0 deletions
diff --git a/src/main/java/gregtech/loaders/misc/GT_Achievements.java b/src/main/java/gregtech/loaders/misc/GT_Achievements.java new file mode 100644 index 0000000000..87e18a98f1 --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/GT_Achievements.java @@ -0,0 +1,520 @@ +package gregtech.loaders.misc; + +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.gameevent.PlayerEvent.ItemCraftedEvent; +import cpw.mods.fml.common.gameevent.PlayerEvent.ItemSmeltedEvent; +import gregtech.GT_Mod; +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.objects.ItemData; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.common.items.GT_MetaGenerated_Tool_01; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.stats.Achievement; +import net.minecraft.stats.AchievementList; +import net.minecraft.stats.StatBase; +import net.minecraftforge.common.AchievementPage; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.entity.player.EntityItemPickupEvent; +import net.minecraftforge.fluids.FluidStack; +import thaumcraft.api.ThaumcraftApiHelper; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +public class GT_Achievements { + + public static List<Materials> oreList = new ArrayList<Materials>(); + public static List<Integer[]> oreStats = new ArrayList<Integer[]>(); + public static int oreReg = -1; + public HashMap<String, Achievement> achievementList; + public HashMap<String, Boolean> issuedAchievements; + public int adjX = 5; + public int adjY = 9; + + public GT_Achievements() { + this.achievementList = new HashMap(); + this.issuedAchievements = new HashMap(); + for (int i = 0; i < oreList.size(); i++) { + if (GT_Values.D1 && this.achievementList.get(oreList.get(i).name()) == null) { + GT_Log.out.println("achievement." + oreList.get(i).name() + "=Find " + oreList.get(i).name() + " Ore"); + + StringBuilder dimensions = new StringBuilder(); + boolean isFirst = true; + if(oreStats.get(i)[3] == 1) { + dimensions.append("Overworld"); + isFirst = false; + } + if(oreStats.get(i)[4] == 1) { + if(!isFirst) dimensions.append("/"); + dimensions.append("Nether"); + isFirst = false; + } + if(oreStats.get(i)[5] == 1) { + if(!isFirst) dimensions.append("/"); + dimensions.append("End"); + isFirst = false; + } + GT_Log.out.println("achievement." + oreList.get(i).name() + ".desc=Height: " + (oreStats.get(i)[0]) + "-" + (oreStats.get(i)[1]) + ", Chance: " + (oreStats.get(i)[2]) + ", " + dimensions.toString()); + } + registerOreAchievement(oreList.get(i)); + } + registerAchievement("flintpick", 0, 0, GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(2, 1, Materials.Flint, Materials.Wood, null), "", false); + registerAchievement("crops", -4, 0, GT_ModHandler.getIC2Item("crop", 1L), "flintpick", false); + registerAchievement("havestlead", -4, 2, ItemList.Crop_Drop_Plumbilia.get(1, new Object[]{}), "crops", false); + registerAchievement("havestcopper", -2, 1, ItemList.Crop_Drop_Coppon.get(1, new Object[]{}), "crops", false); + registerAchievement("havesttin", -2, -1, ItemList.Crop_Drop_Tine.get(1, new Object[]{}), "crops", false); + registerAchievement("havestoil", -4, -4, ItemList.Crop_Drop_OilBerry.get(1, new Object[]{}), "crops", false); + registerAchievement("havestiron", -2, -3, ItemList.Crop_Drop_Ferru.get(1, new Object[]{}), "crops", false); + registerAchievement("havestgold", -2, -6, ItemList.Crop_Drop_Aurelia.get(1, new Object[]{}), "havestiron", false); + registerAchievement("havestsilver", -4, -5, ItemList.Crop_Drop_Argentia.get(1, new Object[]{}), "havestiron", false); + registerAchievement("havestemeralds", -2, -8, ItemList.Crop_Drop_BobsYerUncleRanks.get(1, new Object[]{}), "havestgold", false); + + registerAchievement("tools", 0, 4, GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(12, 1, Materials.Iron, Materials.Wood, null), "flintpick", false); + registerAchievement("driltime", 2, 4, GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(100, 1, Materials.BlueSteel, Materials.StainlessSteel, null), "tools", false); + registerAchievement("brrrr", 2, 6, GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(110, 1, Materials.BlueSteel, Materials.StainlessSteel, null), "driltime", false); + registerAchievement("highpowerdrill", 3, 5, GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(104, 1, Materials.TungstenSteel, Materials.TungstenSteel, null), "driltime", false); + registerAchievement("hammertime", 3, 7, GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(130, 1, Materials.TungstenSteel, Materials.TungstenSteel, null), "highpowerdrill", false); + registerAchievement("repair", 4, 5, ItemList.Machine_HV_Disassembler.get(1, new Object[]{}), "highpowerdrill", false); + + registerAchievement("unitool", -2, 4, GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(32, 1, Materials.Steel, Materials.Iron, null), "tools", false); + registerAchievement("recycling", -4, 4, ItemList.Machine_LV_ArcFurnace.get(1, new Object[]{}), "unitool", false); + + registerAchievement("crushed", 0, 6, GT_OreDictUnificator.get(OrePrefixes.crushed, Materials.Tin, 1L), "tools", false); + registerAchievement("cleandust", 0, 10, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 1L), "crushed", false); + registerAchievement("washing", -2, 6, GT_OreDictUnificator.get(OrePrefixes.crushedPurified, Materials.Iron, 1L), "crushed", false); + registerAchievement("spinit", -4, 6, GT_OreDictUnificator.get(OrePrefixes.crushedCentrifuged, Materials.Redstone, 1L), "crushed", false); + registerAchievement("newfuel", -4, 8, ItemList.ThoriumCell_4.get(1, new Object[]{}), "spinit", false); + registerAchievement("newmetal", -4, 10, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Lutetium, 1L), "newfuel", false); + registerAchievement("reflect", -2, 9, ItemList.Neutron_Reflector.get(1, new Object[]{}), "newfuel", false); + + registerAchievement("bronze", 2, 0, GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Bronze, 1L), "flintpick", false); + registerAchievement("simplyeco", 2, 2, ItemList.Machine_Bronze_Boiler_Solar.get(1, new Object[]{}), "bronze", false); + registerAchievement("firststeam", 2, -2, ItemList.Machine_Bronze_Boiler.get(1, new Object[]{}), "bronze", false); + registerAchievement("alloysmelter", 2, -4, ItemList.Machine_Bronze_AlloySmelter.get(1, new Object[]{}), "firststeam", false); + registerAchievement("macerator", 0, -2, ItemList.Machine_Bronze_Macerator.get(1, new Object[]{}), "firststeam", false); + registerAchievement("extract", 0, -4, ItemList.Machine_Bronze_Extractor.get(1, new Object[]{}), "alloysmelter", false); + + registerAchievement("smallparts", 0, -8, ItemList.Circuit_Primitive.get(1, new Object[]{}), "extract", false); + registerAchievement("bettercircuits", 0, -10, ItemList.Circuit_Good.get(1, new Object[]{}), "smallparts", false); + registerAchievement("stepforward", -2, -10, ItemList.Circuit_Advanced.get(1, new Object[]{}), "bettercircuits", false); + registerAchievement("energyflow", -4, -10, ItemList.Circuit_Master.get(1, new Object[]{}), "stepforward", false); + registerAchievement("orbs", -6, -10, ItemList.Energy_LapotronicOrb.get(1, new Object[]{}), "energyflow", false); + registerAchievement("thatspower", -8, -10, ItemList.Energy_LapotronicOrb2.get(1, new Object[]{}), "orbs", false); + registerAchievement("datasaving", -2, -12, ItemList.Tool_DataOrb.get(1, new Object[]{}), "stepforward", false); + registerAchievement("superbuffer", 0, -12, ItemList.Automation_SuperBuffer_LV.get(1, new Object[]{}), "datasaving", false); + registerAchievement("newstorage", -2, -14, ItemList.Quantum_Chest_HV.get(1, new Object[]{}), "superbuffer", false); + registerAchievement("whereistheocean", 2, -14, ItemList.Quantum_Tank_IV.get(1, new Object[]{}), "superbuffer", false); + registerAchievement("luck", 2, -6, ItemList.ZPM.get(1, new Object[]{}), "", false); + + registerAchievement("steel", 4, 0, GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 1L), "bronze", false); + registerAchievement("highpressure", 4, 2, ItemList.Machine_Steel_Boiler.get(1, new Object[]{}), "steel", false); + registerAchievement("extremepressure", 4, 4, ItemList.Machine_Multi_LargeBoiler_Steel.get(1, new Object[]{}), "highpressure", false); + registerAchievement("cheapermac", 6, 1, ItemList.Machine_LV_Hammer.get(1, new Object[]{}), "steel", false); + registerAchievement("complexalloys", 6, 3, GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.BlueSteel, 1L), "cheapermac", false); + + registerAchievement("magneticiron", 4, -2, GT_OreDictUnificator.get(OrePrefixes.stick, Materials.IronMagnetic, 1L), "steel", false); + registerAchievement("lvmotor", 4, -6, ItemList.Electric_Motor_LV.get(1, new Object[]{}), "magneticiron", false); + registerAchievement("pumpcover", 2, -8, ItemList.Electric_Pump_LV.get(1, new Object[]{}), "lvmotor", false); + registerAchievement("closeit", 2, -10, ItemList.Cover_Shutter.get(1, new Object[]{}), "pumpcover", false); + registerAchievement("slurp", 2, -12, ItemList.Pump_HV.get(1, new Object[]{}), "closeit", false); + registerAchievement("transport", 4, -10, ItemList.Conveyor_Module_LV.get(1, new Object[]{}), "lvmotor", false); + registerAchievement("manipulation", 4, -12, ItemList.Cover_Controller.get(1, new Object[]{}), "transport", false); + registerAchievement("buffer", 4, -14, ItemList.Automation_ChestBuffer_LV.get(1, new Object[]{}), "manipulation", false); + registerAchievement("complexmachines", 6, -9, ItemList.Robot_Arm_LV.get(1, new Object[]{}), "lvmotor", false); + registerAchievement("avengers", 8, -11, ItemList.Machine_LV_Assembler.get(1, new Object[]{}), "complexmachines", false); + registerAchievement("filterregulate", 10, -11, ItemList.Component_Filter.get(1, new Object[]{}), "avengers", false); + + registerAchievement("steampower", 6, -6, ItemList.Generator_Steam_Turbine_LV.get(1, new Object[]{}), "lvmotor", false); + registerAchievement("batterys", 6, -4, ItemList.Battery_Buffer_2by2_MV.get(1, new Object[]{}), "steampower", false); + registerAchievement("badweather", 6, -8, ItemList.Casing_FireHazard.get(1, new Object[]{}), "steampower", false); + registerAchievement("electricproblems", 7, -7, ItemList.Casing_ExplosionHazard.get(1, new Object[]{}), "steampower", false); + registerAchievement("ebf", 8, -6, ItemList.Machine_Multi_BlastFurnace.get(1, new Object[]{}), "steampower", false); + registerAchievement("energyhatch", 12, -6, ItemList.Hatch_Energy_LV.get(1, new Object[]{}), "ebf", false); + + registerAchievement("gtaluminium", 8, 0, GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Aluminium, 1L), "steel", false); + registerAchievement("highpowersmelt", 8, 2, ItemList.Machine_Multi_Furnace.get(1, new Object[]{}), "gtaluminium", false); + registerAchievement("oilplant", 8, 4, ItemList.Distillation_Tower.get(1, new Object[]{}), "highpowersmelt", false); + registerAchievement("factory", 8, 6, ItemList.Processing_Array.get(1, new Object[]{}), "oilplant", false); + registerAchievement("upgradeebf", 8, -2, ItemList.Hatch_Energy_MV.get(1, new Object[]{}), "gtaluminium", false); + registerAchievement("maintainance", 10, -2, ItemList.Hatch_Maintenance.get(1, new Object[]{}), "upgradeebf", false); + + registerAchievement("titan", 10, 0, GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Titanium, 1L), "gtaluminium", false); + registerAchievement("magic", 10, 4, ItemList.MagicEnergyConverter_LV.get(1, new Object[]{}), "titan", false); + registerAchievement("highmage", 10, 6, ItemList.MagicEnergyAbsorber_HV.get(1, new Object[]{}), "magic", false); + registerAchievement("artificaldia", 11, 2, ItemList.IC2_Industrial_Diamond.get(1, new Object[]{}), "titan", false); + registerAchievement("muchsteam", 12, 1, ItemList.LargeSteamTurbine.get(1, new Object[]{}), "titan", false); + registerAchievement("efficientsteam", 12, 3, ItemList.LargeSteamTurbine.get(1, new Object[]{}), "muchsteam", false); + + registerAchievement("upgrade", 14, 0, ItemList.Casing_Coil_Kanthal.get(1, new Object[]{}), "titan", false); + registerAchievement("tungsten", 16, 0, GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Tungsten, 1L), "upgrade", false); + registerAchievement("hightech", 15, -1, ItemList.Field_Generator_LV.get(1, new Object[]{}), "tungsten", false); + registerAchievement("amplifier", 17, -3, ItemList.Machine_LV_Amplifab.get(1, new Object[]{}), "hightech", false); + registerAchievement("scanning", 13, -2, ItemList.Machine_HV_Scanner.get(1, new Object[]{}), "hightech", false); + registerAchievement("alienpower", 14, -4, ItemList.Generator_Naquadah_Mark_I.get(1, new Object[]{}), "hightech", false); + registerAchievement("universal", 15, -6, ItemList.Machine_LV_Massfab.get(1, new Object[]{}), "hightech", false); + registerAchievement("replication", 17, -6, ItemList.Machine_LV_Replicator.get(1, new Object[]{}), "universal", false); + + registerAchievement("upgrade2", 16, 6, ItemList.Casing_Coil_Nichrome.get(1, new Object[]{}), "tungsten", false); + registerAchievement("tungstensteel", 14, 6, GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.TungstenSteel, 1L), "upgrade2", false); + registerAchievement("conducting", 12, 6, ItemList.Casing_Coil_Superconductor.get(1, new Object[]{}), "tungstensteel", false); + registerAchievement("fusion", 14, 8, ItemList.FusionComputer_LuV.get(1, new Object[]{}), "tungstensteel", false); + registerAchievement("higherefficency", 14, 10, ItemList.Generator_Plasma_IV.get(1, new Object[]{}), "fusion", false); + registerAchievement("advancing", 12, 8, ItemList.FusionComputer_ZPMV.get(1, new Object[]{}), "fusion", false); + registerAchievement("tothelimit", 12, 10, ItemList.Generator_Plasma_LuV.get(1, new Object[]{}), "advancing", false); + registerAchievement("fullefficiency", 10, 10, ItemList.Generator_Plasma_ZPMV.get(1, new Object[]{}), "tothelimit", false); + registerAchievement("denseaspossible", 8, 10, ItemList.FusionComputer_UV.get(1, new Object[]{}), "fullefficiency", false); + registerAchievement("whatnow", 6, 10, ItemList.ZPM2.get(1, new Object[]{}), "denseaspossible", false); + + if(Loader.isModLoaded("NotEnoughItems") && GT_Mod.gregtechproxy.mHideUnusedOres){ + for (int i = 1; i < GregTech_API.sGeneratedMaterials.length; i++) { + if (GregTech_API.sGeneratedMaterials[i] != null) { + if(!oreList.contains(GregTech_API.sGeneratedMaterials[i])){ + codechicken.nei.api.API.hideItem(GT_OreDictUnificator.get(OrePrefixes.ore, GregTech_API.sGeneratedMaterials[i], 1)); + } + } + } + } + if (GT_Mod.gregtechproxy.mAchievements) { + AchievementPage.registerAchievementPage(new AchievementPage("GregTech 5", (Achievement[]) this.achievementList.values().toArray( + new Achievement[this.achievementList.size()]))); + MinecraftForge.EVENT_BUS.register(this); + FMLCommonHandler.instance().bus().register(this); + } + } + + public static void registerOre(Materials aMaterial, int min, int max, int chance, boolean overworld, boolean nether, boolean end) { + if (aMaterial != Materials._NULL) { + oreList.add(aMaterial); + } + oreStats.add(new Integer[]{min, max, chance, overworld ? 1 : 0, nether ? 1 : 0, end ? 1 : 0}); + } + + public Achievement registerAchievement(String textId, int x, int y, ItemStack icon, Achievement requirement, boolean special) { + if (!GT_Mod.gregtechproxy.mAchievements) { + return null; + } + ; + Achievement achievement = new Achievement(textId, textId, this.adjX + x, this.adjY + y, icon, requirement); + if (special) { + achievement.setSpecial(); + } + achievement.registerStat(); + if (GT_Values.D2) { + GT_Log.out.println("achievement." + textId + "="); + GT_Log.out.println("achievement." + textId + ".desc="); + } + this.achievementList.put(textId, achievement); + return achievement; + } + + public Achievement registerAchievement(String textId, int x, int y, ItemStack icon, String requirement, boolean special) { + if (!GT_Mod.gregtechproxy.mAchievements) { + return null; + } + ; + Achievement achievement = new Achievement(textId, textId, this.adjX + x, this.adjY + y, icon, getAchievement(requirement)); + if (special) { + achievement.setSpecial(); + } + achievement.registerStat(); + if (GT_Values.D2) { + GT_Log.out.println("achievement." + textId + "="); + GT_Log.out.println("achievement." + textId + ".desc="); + } + this.achievementList.put(textId, achievement); + return achievement; + } + + public Achievement registerOreAchievement(Materials aMaterial) { + if (this.achievementList.get(aMaterial.name()) == null) { + oreReg++; + return registerAchievement(aMaterial.name(), -(6 + oreReg % 5), ((oreReg) / 5) - 8, new ItemStack(GregTech_API.sBlockOres1, 1, + aMaterial.mMetaItemSubID), AchievementList.openInventory, false); + } + return null; + } + + public void issueAchievement(EntityPlayer entityplayer, String textId) { + if (entityplayer == null || !GT_Mod.gregtechproxy.mAchievements) { + return; + } +// if (this.achievementList.containsKey(textId)) { +// if(this.issuedAchievements.containsKey((entityplayer.getDisplayName()+textId))){ +// return; +// }else{ +// this.issuedAchievements.put((entityplayer.getDisplayName()+textId), true); + entityplayer.triggerAchievement((StatBase) this.achievementList.get(textId)); +// } +// } + } + + public Achievement getAchievement(String textId) { + if (this.achievementList.containsKey(textId)) { + return (Achievement) this.achievementList.get(textId); + } + return null; + } + + public void issueAchivementHatch(EntityPlayer player, ItemStack stack) { + if (player == null || stack == null) { + return; + } + ItemData data = GT_OreDictUnificator.getItemData(stack); + + if (data != null) { + if (data.mPrefix == OrePrefixes.ingot) { + if (data.mMaterial.mMaterial == Materials.Aluminium) { + issueAchievement(player, "gtaluminium"); + } else if (data.mMaterial.mMaterial == Materials.Titanium) { + issueAchievement(player, "titan"); + } else if (data.mMaterial.mMaterial == Materials.BlueSteel) { + issueAchievement(player, "complexalloys"); + } else if (data.mMaterial.mMaterial == Materials.Tungsten) { + issueAchievement(player, "tungsten"); + } else if (data.mMaterial.mMaterial == Materials.TungstenSteel) { + issueAchievement(player, "tungstensteel"); + } + + + } + } + if (stack.getUnlocalizedName().equals("ic2.itemPartIndustrialDiamond")) { + issueAchievement(player, "artificaldia"); + } + } + + public void issueAchivementHatchFluid(EntityPlayer player, FluidStack fluid) { + if (player == null || fluid == null) { + return; + } + if (fluid.getFluid().getUnlocalizedName().equals("fluid.plasma.helium")) { + issueAchievement(player, "fusion"); + } else if (fluid.getFluid().getUnlocalizedName().equals("fluid.molten.europium")) { + issueAchievement(player, "advancing"); + } else if (fluid.getFluid().getUnlocalizedName().equals("fluid.molten.americium")) { + issueAchievement(player, "tothelimit"); + } else if (fluid.getFluid().getUnlocalizedName().equals("fluid.molten.neutronium")) { + issueAchievement(player, "denseaspossible"); + } else if (fluid.getFluid().getUnlocalizedName().equals("fluid.plasma.nitrogen")) { + issueAchievement(player, "higherefficency"); + } + } + + @SubscribeEvent + public void onCrafting(ItemCraftedEvent event) { + EntityPlayer player = event.player; + ItemStack stack = event.crafting; + if (player == null || stack == null) { + return; + } + ItemData data = GT_OreDictUnificator.getItemData(stack); + if (data != null) { + if (data.mPrefix == OrePrefixes.dust && data.mMaterial.mMaterial == Materials.Bronze) { + issueAchievement(player, "bronze"); + } else if (data.mPrefix == OrePrefixes.circuit && data.mMaterial.mMaterial == Materials.Advanced) { + issueAchievement(player, "stepforward"); + } + } + if (stack.getUnlocalizedName().startsWith("gt.metaitem.")) { + if (stack.getUnlocalizedName().equals("gt.metaitem.01.2300")) { + issueAchievement(player, "bronze"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32700")) { + issueAchievement(player, "smallparts"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.23354")) { + issueAchievement(player, "magneticiron"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32600")) { + issueAchievement(player, "lvmotor"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32610")) { + issueAchievement(player, "pumpcover"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32630")) { + issueAchievement(player, "transport"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32650")) { + issueAchievement(player, "complexmachines"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32670")) { + issueAchievement(player, "hightech"); + } + } else if (stack.getUnlocalizedName().equals("ic2.blockCrop")) { + issueAchievement(player, "crops"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.")) { + if (stack.getUnlocalizedName().startsWith("gt.blockmachines.basicmachine.arcfurnace.tier.")) { + issueAchievement(player, "recycling"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.basicmachine.disassembler.tier.")) { + issueAchievement(player, "repair"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.boiler.solar")) { + issueAchievement(player, "simplyeco"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.boiler.bronze")) { + issueAchievement(player, "firststeam"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.boiler.steel")) { + issueAchievement(player, "highpressure"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.bronzemachine.macerator")) { + issueAchievement(player, "macerator"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.bronzemachine.alloysmelter")) { + issueAchievement(player, "alloysmelter"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.bronzemachine.extractor")) { + issueAchievement(player, "extract"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.automation.superbuffer.tier.")) { + issueAchievement(player, "superbuffer"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.quantum.tank.tier.")) { + issueAchievement(player, "whereistheocean"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.quantum.chest.tier.")) { + issueAchievement(player, "newstorage"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.basicmachine.hammer.tier.")) { + issueAchievement(player, "cheapermac"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.automation.chestbuffer.tier.")) { + issueAchievement(player, "buffer"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.basicgenerator.steamturbine.tier.")) { + issueAchievement(player, "steampower"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.basicmachine.pump.tier.03")) { + issueAchievement(player, "slurp"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.basicmachine.assembler.tier.")) { + issueAchievement(player, "avengers"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.multimachine.blastfurnace")) { + issueAchievement(player, "ebf"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.batterybuffer.")) { + issueAchievement(player, "batterys"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.hatch.energy.tier.02")) { + issueAchievement(player, "upgradeebf"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.multimachine.multifurnace")) { + issueAchievement(player, "highpowersmelt"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.hatch.energy.tier.01")) { + issueAchievement(player, "energyhatch"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.multimachine.processingarray")) { + issueAchievement(player, "factory"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.basicgenerator.magicenergyconverter.tier.01")) { + issueAchievement(player, "magic"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.basicgenerator.magicenergyabsorber.tier.03")) { + issueAchievement(player, "highmage"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.basicmachine.amplifab.tier.")) { + issueAchievement(player, "amplifier"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.basicmachine.massfab.tier.")) { + issueAchievement(player, "universal"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.basicgenerator.naquadah.tier.")) { + issueAchievement(player, "alienpower"); + } else if (stack.getUnlocalizedName().startsWith("gt.blockmachines.basicmachine.replicator.tier.")) { + issueAchievement(player, "replication"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.basicgenerator.plasmagenerator.tier.07")) { + issueAchievement(player, "fullefficiency"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.multimachine.largeturbine")) { + issueAchievement(player, "muchsteam"); + } else if (stack.getUnlocalizedName().equals("gt.blockmachines.multimachine.largehpturbine")) { + issueAchievement(player, "efficientsteam"); + } + } else if (stack.getUnlocalizedName().equals("gt.neutronreflector")) { + issueAchievement(player, "reflect"); + } else if (stack.getUnlocalizedName().equals("gt.blockcasings.13")) { + issueAchievement(player, "upgrade"); + } else if (stack.getUnlocalizedName().equals("gt.blockcasings.14")) { + issueAchievement(player, "upgrade2"); + } else if (stack.getUnlocalizedName().equals("gt.blockcasings.15")) { + issueAchievement(player, "conducting"); + } + } + + @SubscribeEvent + public void onSmelting(ItemSmeltedEvent event) { + EntityPlayer player = event.player; + ItemStack stack = event.smelting; + if (player == null || stack == null) { + return; + } + if (stack.getItem() == Items.bread) { + event.player.triggerAchievement(AchievementList.makeBread); + } + } + + @SubscribeEvent + public void onItemPickup(EntityItemPickupEvent event) { + EntityPlayer player = event.entityPlayer; + ItemStack stack = event.item.getEntityItem(); + if (player == null || stack == null) { + return; + } + ItemData data = GT_OreDictUnificator.getItemData(stack); + if (data != null) { + if (data.mPrefix == OrePrefixes.dust) { + if (data.mMaterial.mMaterial == Materials.Lutetium) { + issueAchievement(player, "newmetal"); + } + if(data.mMaterial.mMaterial != Materials.Gunpowder){ + issueAchievement(player, "cleandust"); + } + } else if (data.mPrefix == OrePrefixes.ore || data.mPrefix == OrePrefixes.oreBlackgranite || data.mPrefix == OrePrefixes.oreEndstone + || data.mPrefix == OrePrefixes.oreNetherrack || data.mPrefix == OrePrefixes.oreRedgranite) { + for (int i = 0; i < data.getAllMaterialStacks().size(); i++) { + issueAchievement(player, data.getAllMaterialStacks().get(i).mMaterial.name()); + if (data.getAllMaterialStacks().get(i).mMaterial == Materials.AnyIron) { + issueAchievement(player, "iron"); + } + } + } else if (data.mPrefix == OrePrefixes.crushed) { + issueAchievement(player, "crushed"); + } else if (data.mPrefix == OrePrefixes.crushedPurified) { + issueAchievement(player, "washing"); + } else if (data.mPrefix == OrePrefixes.crushedCentrifuged) { + issueAchievement(player, "spinit"); + } else if (data.mMaterial.mMaterial == Materials.Steel) { + if (data.mPrefix == OrePrefixes.ingot && stack.stackSize == stack.getMaxStackSize()) { + issueAchievement(player, "steel"); + } else if (data.mPrefix == OrePrefixes.nugget && Loader.isModLoaded("Thaumcraft")) { + if (ThaumcraftApiHelper.isResearchComplete(player.getDisplayName(), "GT_IRON_TO_STEEL")) { + issueAchievement(player, "steel"); + } + } + } else if (data.mPrefix == OrePrefixes.circuit && data.mMaterial.mMaterial == Materials.Advanced) { + issueAchievement(player, "stepforward"); + } + } + if (stack.getUnlocalizedName().startsWith("gt.metaitem.")) { + if (stack.getUnlocalizedName().equals("gt.metaitem.02.32500")) { + issueAchievement(player, "havestlead"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.02.32501")) { + issueAchievement(player, "havestsilver"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.02.32503")) { + issueAchievement(player, "havestiron"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.02.32504")) { + issueAchievement(player, "havestgold"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.02.32530")) { + issueAchievement(player, "havestcopper"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.02.32540")) { + issueAchievement(player, "havesttin"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.02.32510")) { + issueAchievement(player, "havestoil"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.02.32511")) { + issueAchievement(player, "havestemeralds"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32706")) { + issueAchievement(player, "energyflow"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32702")) { + issueAchievement(player, "bettercircuits"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32707")) { + issueAchievement(player, "datasaving"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32597")) { + issueAchievement(player, "orbs"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32599")) { + issueAchievement(player, "thatspower"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32598")) { + issueAchievement(player, "luck"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32749")) { + issueAchievement(player, "closeit"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32730")) { + issueAchievement(player, "manipulation"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32729")) { + issueAchievement(player, "filterregulate"); + } else if (stack.getUnlocalizedName().equals("gt.metaitem.01.32605")) { + issueAchievement(player, "whatnow"); + } + } else if (stack.getUnlocalizedName().equals("gt.Thoriumcell")) { + issueAchievement(player, "newfuel"); + } + } +} diff --git a/src/main/java/gregtech/loaders/misc/GT_BeeDefinition.java b/src/main/java/gregtech/loaders/misc/GT_BeeDefinition.java new file mode 100644 index 0000000000..d7b36cac5b --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/GT_BeeDefinition.java @@ -0,0 +1,748 @@ +package gregtech.loaders.misc; + +import forestry.api.apiculture.*; +import forestry.api.core.EnumHumidity; +import forestry.api.core.EnumTemperature; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IAllele; +import forestry.apiculture.genetics.Bee; +import forestry.apiculture.genetics.BeeDefinition; +import forestry.apiculture.genetics.BeeVariation; +import forestry.apiculture.genetics.IBeeDefinition; +//import forestry.apiculture.items.EnumHoneyComb; +import forestry.core.genetics.alleles.AlleleHelper; +//import forestry.plugins.PluginApiculture; +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.util.GT_ModHandler; +import gregtech.common.items.CombType; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import org.apache.commons.lang3.text.WordUtils; + +import java.util.Arrays; +import java.util.Locale; + +public enum GT_BeeDefinition implements IBeeDefinition { + CLAY(GT_BranchDefinition.ORGANIC, "Clay", true, 0x19d0ec, 0xffdc16) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_ModHandler.getModItem(GT_Values.MOD_ID_FR, "beeCombs", 1, 0), 0.30f); + beeSpecies.addProduct(new ItemStack(Items.clay_ball, 1), 0.15f); + beeSpecies.setHumidity(EnumHumidity.DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.MEADOWS.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(getSpecies("Industrious"), getSpecies("Diligent"), 20); + } + }, + SLIMEBALL(GT_BranchDefinition.ORGANIC, "SlimeBall", true, 0x4E9E55, 0x00FF15) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_ModHandler.getModItem(GT_Values.MOD_ID_FR, "beeCombs", 1, 15), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STICKY), 0.30f); + beeSpecies.setHumidity(EnumHumidity.DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.MARSHY.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(getSpecies("Marshy"), CLAY.species, 15); + } + }, + PEAT(GT_BranchDefinition.ORGANIC, "Peat", true, 0x906237, 0x58300B) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.LIGNIE), 0.30f); + beeSpecies.addProduct(GT_ModHandler.getModItem(GT_Values.MOD_ID_FR, "beeCombs", 1, 0), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.RURAL.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(getSpecies("Rural"), CLAY.species, 20); + } + }, + STICKYRESIN(GT_BranchDefinition.ORGANIC, "StickyResin", true, 0x2E8F5B, 0xDCC289) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_ModHandler.getModItem(GT_Values.MOD_ID_FR, "beeCombs", 1, 0), 0.30f); + beeSpecies.addProduct(ItemList.IC2_Resin.get(1, new Object[0]), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.MEADOWS.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(SLIMEBALL.species, PEAT.species, 25); + } + }, + COAL(GT_BranchDefinition.ORGANIC, "Coal", true, 0x666666, 0x525252) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.LIGNIE), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.COAL), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.AUSTERE.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(getSpecies("Industrious"), PEAT.species, 18); + } + }, + OIL(GT_BranchDefinition.ORGANIC, "Oil", true, 0x4C4C4C, 0x333333) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_ModHandler.getModItem(GT_Values.MOD_ID_FR, "beeCombs", 1, 0), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.OIL), 0.15f); + beeSpecies.setHumidity(EnumHumidity.DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setNocturnal(); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.MEADOWS.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(COAL.species, STICKYRESIN.species, 8); + } + }, + REDSTONE(GT_BranchDefinition.GEM, "Redstone", true, 0x7D0F0F, 0xD11919) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.REDSTONE), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(getSpecies("Industrious"), getSpecies("Demonic"), 20); + } + }, + LAPIS(GT_BranchDefinition.GEM, "Lapis", true, 0x1947D1, 0x476CDA) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.LAPIS), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(getSpecies("Demonic"), getSpecies("Imperial"), 20); + } + }, + CERTUS(GT_BranchDefinition.GEM, "CertusQuartz", true, 0x57CFFB, 0xBBEEFF) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.CERTUS), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(getSpecies("Hermitic"), LAPIS.species, 20); + } + }, + RUBY(GT_BranchDefinition.GEM, "Ruby", true, 0xE6005C, 0xCC0052) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.RUBY), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(REDSTONE.species, DIAMOND.species, 10); + } + }, + SAPPHIRE(GT_BranchDefinition.GEM, "Sapphire", true, 0x0033CC, 0x00248F) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SAPPHIRE), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(CERTUS.species, LAPIS.species, 10); + } + }, + DIAMOND(GT_BranchDefinition.GEM, "Diamond", true, 0xCCFFFF, 0xA3CCCC) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.DIAMOND), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(CERTUS.species, COAL.species, 6); + } + }, + OLIVINE(GT_BranchDefinition.GEM, "Olivine", true, 0x248F24, 0xCCFFCC) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.OLIVINE), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(CERTUS.species, getSpecies("Ended"), 10); + } + }, + EMERALD(GT_BranchDefinition.GEM, "Emerald", true, 0x248F24, 0x2EB82E) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.EMERALD), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.COLD); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(OLIVINE.species, DIAMOND.species, 8); + } + }, + COPPER(GT_BranchDefinition.METAL, "Copper", true, 0xFF6600, 0xE65C00) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.COPPER), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(getSpecies("Majestic"), CLAY.species, 25); + } + }, + TIN(GT_BranchDefinition.METAL, "Tin", true, 0xD4D4D4, 0xDDDDDD) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.TIN), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(CLAY.species, getSpecies("Diligent"), 25); + } + }, + LEAD(GT_BranchDefinition.METAL, "Lead", true, 0x666699, 0xA3A3CC) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.LEAD), 0.15f); + beeSpecies.setHumidity(EnumHumidity.DAMP); + beeSpecies.setTemperature(EnumTemperature.WARM); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(COAL.species, COPPER.species, 25); + } + }, + IRON(GT_BranchDefinition.METAL, "Iron", true, 0xDA9147, 0xDE9C59) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.IRON), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(TIN.species, COPPER.species, 25); + } + }, + STEEL(GT_BranchDefinition.METAL, "Steel", true, 0x808080, 0x999999) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STEEL), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(IRON.species, COAL.species, 20); + } + }, + NICKEL(GT_BranchDefinition.METAL, "Nickel", true, 0x8585AD, 0x8585AD) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.NICKEL), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(IRON.species, COPPER.species, 25); + } + }, + ZINC(GT_BranchDefinition.METAL, "Zinc", true, 0xF0DEF0, 0xF2E1F2) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.ZINC), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(IRON.species, TIN.species, 20); + } + }, + SILVER(GT_BranchDefinition.METAL, "Silver", true, 0xC2C2D6, 0xCECEDE) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SILVER), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(LEAD.species, TIN.species, 20); + } + }, + GOLD(GT_BranchDefinition.METAL, "Gold", true, 0xEBC633, 0xEDCC47) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.GOLD), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(LEAD.species, COPPER.species, 20); + } + }, + ALUMINIUM(GT_BranchDefinition.RAREMETAL, "Aluminium", true, 0xB8B8FF, 0xD6D6FF) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.ALUMINIUM), 0.15f); + beeSpecies.setHumidity(EnumHumidity.ARID); + beeSpecies.setTemperature(EnumTemperature.HOT); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(NICKEL.species, ZINC.species, 18); + } + }, + TITANIUM(GT_BranchDefinition.RAREMETAL, "Titanium", true, 0xCC99FF, 0xDBB8FF) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.TITANIUM), 0.15f); + beeSpecies.setHumidity(EnumHumidity.ARID); + beeSpecies.setTemperature(EnumTemperature.HOT); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(REDSTONE.species, ALUMINIUM.species, 5); + } + }, + CHROME(GT_BranchDefinition.RAREMETAL, "Chrome", true, 0xEBA1EB, 0xF2C3F2) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.CHROME), 0.15f); + beeSpecies.setHumidity(EnumHumidity.ARID); + beeSpecies.setTemperature(EnumTemperature.HOT); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(TITANIUM.species, RUBY.species, 5); + tMutation.requireResource(GregTech_API.sBlockMetal2, 3); + } + }, + MANGANESE(GT_BranchDefinition.RAREMETAL, "Manganese", true, 0xD5D5D5, 0xAAAAAA) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.MANGANESE), 0.15f); + beeSpecies.setHumidity(EnumHumidity.ARID); + beeSpecies.setTemperature(EnumTemperature.HOT); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(TITANIUM.species, ALUMINIUM.species, 5); + tMutation.requireResource(GregTech_API.sBlockMetal4, 6); + } + }, + TUNGSTEN(GT_BranchDefinition.RAREMETAL, "Tungsten", true, 0x5C5C8A, 0x7D7DA1) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.TUNGSTEN), 0.15f); + beeSpecies.setHumidity(EnumHumidity.ARID); + beeSpecies.setTemperature(EnumTemperature.HOT); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(getSpecies("Heroic"), MANGANESE.species, 5); + tMutation.requireResource(GregTech_API.sBlockMetal7, 11); + } + }, + PLATINUM(GT_BranchDefinition.RAREMETAL, "Platinum", true, 0xE6E6E6, 0xFFFFCC) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.PLATINUM), 0.15f); + beeSpecies.setHumidity(EnumHumidity.ARID); + beeSpecies.setTemperature(EnumTemperature.HOT); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(DIAMOND.species, CHROME.species, 5); + tMutation.requireResource(GregTech_API.sBlockMetal5, 12); + } + }, + IRIDIUM(GT_BranchDefinition.RAREMETAL, "Iridium", true, 0xDADADA, 0xD1D1E0) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.TUNGSTEN), 0.15f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.PLATINUM), 0.15f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.IRIDIUM), 0.15f); + beeSpecies.setHumidity(EnumHumidity.ARID); + beeSpecies.setTemperature(EnumTemperature.HELLISH); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.COMMON.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(TUNGSTEN.species, PLATINUM.species, 5); + tMutation.requireResource(GregTech_API.sBlockMetal3, 12); + } + }, + URANIUM(GT_BranchDefinition.RADIOACTIVE, "Uranium", true, 0x19AF19, 0x169E16) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.URANIUM), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.COLD); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.AVENGING.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(getSpecies("Avenging"), PLATINUM.species, 5); + tMutation.requireResource(GregTech_API.sBlockMetal7, 14); + } + }, + PLUTONIUM(GT_BranchDefinition.RADIOACTIVE, "Plutonium", true, 0x335C33, 0x6B8F00) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.PLUTONIUM), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.ICY); + beeSpecies.setNocturnal(); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.AVENGING.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(URANIUM.species, EMERALD.species, 5); + tMutation.requireResource(GregTech_API.sBlockMetal5, 13); + } + }, + NAQUADAH(GT_BranchDefinition.RADIOACTIVE, "Naquadah", true, 0x003300, 0x002400) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.NAQUADAH), 0.15f); + beeSpecies.setHumidity(EnumHumidity.ARID); + beeSpecies.setTemperature(EnumTemperature.ICY); + beeSpecies.setNocturnal(); + } + + @Override + protected void setAlleles(IAllele[] template) { + template = BeeDefinition.AVENGING.getTemplate(); + } + + @Override + protected void registerMutations() { + IBeeMutationCustom tMutation = registerMutation(PLUTONIUM.species, IRIDIUM.species, 3); + tMutation.requireResource(GregTech_API.sBlockMetal4, 12); + } + }; + + + private final GT_BranchDefinition branch; + private final IAlleleBeeSpeciesCustom species; + + private IAllele[] template; + private IBeeGenome genome; + + GT_BeeDefinition(GT_BranchDefinition branch, String binomial, boolean dominant, int primary, int secondary) { + String lowercaseName = this.toString().toLowerCase(Locale.ENGLISH); + String species = "species" + WordUtils.capitalize(lowercaseName); + + String uid = "forestry." + species; + String description = "for.description." + species; + String name = "for.bees.species." + lowercaseName; + + this.branch = branch; + this.species = BeeManager.beeFactory.createSpecies(uid, dominant, "Sengir", name, description, branch.getBranch(), binomial, primary, secondary); + } + + public static void initBees() { + for (GT_BeeDefinition bee : values()) { + bee.init(); + } + for (GT_BeeDefinition bee : values()) { + bee.registerMutations(); + } + } + + private static IAlleleBeeSpecies getSpecies(String name) { + return (IAlleleBeeSpecies) AlleleManager.alleleRegistry.getAllele((new StringBuilder()).append("forestry.species").append(name).toString()); + } + + protected abstract void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies); + + protected abstract void setAlleles(IAllele[] template); + + protected abstract void registerMutations(); + + private void init() { + setSpeciesProperties(species); + + template = branch.getTemplate(); + AlleleHelper.instance.set(template, EnumBeeChromosome.SPECIES, species); + setAlleles(template); + + genome = BeeManager.beeRoot.templateAsGenome(template); + + BeeManager.beeRoot.registerTemplate(template); + } + + protected final IBeeMutationCustom registerMutation(IAlleleBeeSpecies parent1, IAlleleBeeSpecies parent2, int chance) { + return BeeManager.beeMutationFactory.createMutation(parent1, parent2, getTemplate(), chance); + } + + @Override + public final IAllele[] getTemplate() { + return Arrays.copyOf(template, template.length); + } + + @Override + public final IBeeGenome getGenome() { + return genome; + } + + @Override + public final IBee getIndividual() { + return new Bee(genome); + } + + @Override + public final ItemStack getMemberStack(EnumBeeType beeType) { + IBee bee = getIndividual(); + return BeeManager.beeRoot.getMemberStack(bee, beeType.ordinal()); + } + + public final IBeeDefinition getRainResist() { + return new BeeVariation.RainResist(this); + } + +} diff --git a/src/main/java/gregtech/loaders/misc/GT_Bees.java b/src/main/java/gregtech/loaders/misc/GT_Bees.java new file mode 100644 index 0000000000..8635d9c8c5 --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/GT_Bees.java @@ -0,0 +1,24 @@ +package gregtech.loaders.misc; + +import cpw.mods.fml.common.Loader; +import forestry.api.apiculture.BeeManager; +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IClassification; +import forestry.core.genetics.alleles.AlleleHelper; +import forestry.core.genetics.alleles.EnumAllele; +import gregtech.GT_Mod; +import gregtech.common.items.ItemComb; + +public class GT_Bees { + + public static ItemComb combs; + + public GT_Bees() { + if (Loader.isModLoaded("Forestry") && GT_Mod.gregtechproxy.mGTBees) { + combs = new ItemComb(); + combs.initCombsRecipes(); + GT_BeeDefinition.initBees(); + } + } +} diff --git a/src/main/java/gregtech/loaders/misc/GT_BranchDefinition.java b/src/main/java/gregtech/loaders/misc/GT_BranchDefinition.java new file mode 100644 index 0000000000..ffb6b59b54 --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/GT_BranchDefinition.java @@ -0,0 +1,105 @@ +package gregtech.loaders.misc; + +import forestry.api.apiculture.BeeManager; +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IClassification; +import forestry.apiculture.genetics.alleles.AlleleEffect; +import forestry.core.genetics.alleles.Allele; +import forestry.core.genetics.alleles.AlleleHelper; +import forestry.core.genetics.alleles.EnumAllele; + +import java.util.Arrays; + + +public enum GT_BranchDefinition { + + ORGANIC("Fuelis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_2); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.NOCTURNAL, false); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.MUSHROOMS); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOW); + } + }, + GEM("Ornamentis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.NONE); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.NOCTURNAL, false); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.VANILLA); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.AVERAGE); + } + }, + METAL("Metaliferis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.DOWN_2); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.NOCTURNAL, false); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.JUNGLE); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOWER); + } + }, + RAREMETAL("Mineralis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.DOWN_1); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.NOCTURNAL, false); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.CACTI); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.FAST); + } + }, + RADIOACTIVE("Criticalis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + AlleleHelper.instance.set(alleles, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.NONE); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.NOCTURNAL, false); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.END); + AlleleHelper.instance.set(alleles, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.AVERAGE); + } + }; + + private static IAllele[] defaultTemplate; + private final IClassification branch; + + GT_BranchDefinition(String scientific) { + branch = BeeManager.beeFactory.createBranch(this.name().toLowerCase(), scientific); + } + + private static IAllele[] getDefaultTemplate() { + if (defaultTemplate == null) { + defaultTemplate = new IAllele[EnumBeeChromosome.values().length]; + + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWEST); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTER); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.NORMAL); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.NONE); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.NOCTURNAL, false); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.NONE); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.TOLERANT_FLYER, false); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.CAVE_DWELLING, false); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.VANILLA); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOWEST); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.TERRITORY, EnumAllele.Territory.AVERAGE); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.EFFECT, AlleleEffect.effectNone); + } + return Arrays.copyOf(defaultTemplate, defaultTemplate.length); + } + + protected void setBranchProperties(IAllele[] template) { + + } + + public final IAllele[] getTemplate() { + IAllele[] template = getDefaultTemplate(); + setBranchProperties(template); + return template; + } + + public final IClassification getBranch() { + return branch; + } + +} diff --git a/src/main/java/gregtech/loaders/misc/GT_CoverLoader.java b/src/main/java/gregtech/loaders/misc/GT_CoverLoader.java new file mode 100644 index 0000000000..b7045814de --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/GT_CoverLoader.java @@ -0,0 +1,23 @@ +package gregtech.loaders.misc; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +import gregtech.api.objects.GT_CopiedBlockTexture; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_ModHandler; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; + +public class GT_CoverLoader + implements Runnable { + public void run() { + for (byte i = 0; i < 16; i = (byte) (i + 1)) { + GregTech_API.registerCover(new ItemStack(Blocks.carpet, 1, i), new GT_CopiedBlockTexture(Blocks.wool, 0, i), null); + } + GregTech_API.registerCover(GT_ModHandler.getIC2Item("reactorVent", 1L), new GT_RenderedTexture(Textures.BlockIcons.VENT_NORMAL), null); + GregTech_API.registerCover(GT_ModHandler.getIC2Item("reactorVentCore", 1L), new GT_RenderedTexture(Textures.BlockIcons.VENT_NORMAL), null); + GregTech_API.registerCover(GT_ModHandler.getIC2Item("reactorVentGold", 1L), new GT_RenderedTexture(Textures.BlockIcons.VENT_ADVANCED), null); + GregTech_API.registerCover(GT_ModHandler.getIC2Item("reactorVentSpread", 1L), new GT_RenderedTexture(Textures.BlockIcons.VENT_NORMAL), null); + GregTech_API.registerCover(GT_ModHandler.getIC2Item("reactorVentDiamond", 1L), new GT_RenderedTexture(Textures.BlockIcons.VENT_ADVANCED), null); + } +} diff --git a/src/main/java/gregtech/loaders/misc/OreProcessingConfiguration.java b/src/main/java/gregtech/loaders/misc/OreProcessingConfiguration.java new file mode 100644 index 0000000000..cafde84836 --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/OreProcessingConfiguration.java @@ -0,0 +1,58 @@ +package gregtech.loaders.misc; + +import java.io.File; +import java.util.HashMap; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.Materials; +import net.minecraftforge.common.config.Configuration; +import net.minecraftforge.common.config.Property; + +public class OreProcessingConfiguration + implements Runnable +{ + private final Configuration mConfiguration; + private final HashMap<String, Boolean> mEnabledMaterials; + public OreProcessingConfiguration(File aModConfigurationDirectory) + { + this.mEnabledMaterials = new HashMap<String, Boolean>(); + this.mConfiguration = + new Configuration(new File(new File(aModConfigurationDirectory, "GregTech"), "OreProcessing.cfg")); + this.mConfiguration.load(); + this.loadConfiguration(); + if (this.mConfiguration.hasChanged()) + { + this.mConfiguration.save(); + } + } + private void loadConfiguration() + { + for (Materials tMaterial : GregTech_API.sGeneratedMaterials) + { + if (tMaterial != null && tMaterial != Materials._NULL) + { + String tMaterialName = tMaterial.name(); + boolean tDefaultValue = (tMaterial.mTypes & 8) != 0; + Property tProperty = + this.mConfiguration.get("processores", tMaterialName + "_" + tDefaultValue, tDefaultValue); + this.mEnabledMaterials.put(tMaterialName, tProperty.getBoolean(tDefaultValue)); + } + } + } + @Override + public void run() + { + for (String tMaterialName : this.mEnabledMaterials.keySet()) + { + if (this.mEnabledMaterials.get(tMaterialName)) + { + Materials.valueOf(tMaterialName).mTypes |= 8; + } + else if ((Materials.valueOf(tMaterialName).mTypes & 8) != 0) + { + Materials.valueOf(tMaterialName).mTypes ^= 8; + } + } + } +} + |