From 1b820de08a05070909a267e17f033fcf58ac8710 Mon Sep 17 00:00:00 2001 From: NotAPenguin Date: Mon, 2 Sep 2024 23:17:17 +0200 Subject: The Great Renaming (#3014) * move kekztech to a single root dir * move detrav to a single root dir * move gtnh-lanthanides to a single root dir * move tectech and delete some gross reflection in gt++ * remove more reflection inside gt5u * delete more reflection in gt++ * fix imports * move bartworks and bwcrossmod * fix proxies * move galactigreg and ggfab * move gtneioreplugin * try to fix gt++ bee loader * apply the rename rules to BW * apply rename rules to bwcrossmod * apply rename rules to detrav scanner mod * apply rename rules to galacticgreg * apply rename rules to ggfab * apply rename rules to goodgenerator * apply rename rules to gtnh-lanthanides * apply rename rules to gt++ * apply rename rules to kekztech * apply rename rules to kubatech * apply rename rules to tectech * apply rename rules to gt apply the rename rules to gt * fix tt import * fix mui hopefully * fix coremod except intergalactic * rename assline recipe class * fix a class name i stumbled on * rename StructureUtility to GTStructureUtility to prevent conflict with structurelib * temporary rename of GTTooltipDataCache to old name * fix gt client/server proxy names --- .../java/gregtech/loaders/misc/CoverLoader.java | 42 + .../java/gregtech/loaders/misc/GTAchievements.java | 814 ++++++ .../gregtech/loaders/misc/GTBeeDefinition.java | 2818 +++++++++++++++++++ src/main/java/gregtech/loaders/misc/GTBees.java | 231 ++ .../gregtech/loaders/misc/GTBranchDefinition.java | 207 ++ .../gregtech/loaders/misc/GT_Achievements.java | 822 ------ .../gregtech/loaders/misc/GT_BeeDefinition.java | 2831 -------------------- src/main/java/gregtech/loaders/misc/GT_Bees.java | 231 -- .../gregtech/loaders/misc/GT_BranchDefinition.java | 207 -- .../java/gregtech/loaders/misc/GT_CoverLoader.java | 42 - .../gregtech/loaders/misc/bees/GTAlleleEffect.java | 57 + .../loaders/misc/bees/GTEffectMachineBoost.java | 61 + .../loaders/misc/bees/GTEffectTreeTwister.java | 87 + .../java/gregtech/loaders/misc/bees/GTFlowers.java | 135 + .../loaders/misc/bees/GT_AlleleEffect.java | 57 - .../loaders/misc/bees/GT_EffectMachineBoost.java | 61 - .../loaders/misc/bees/GT_EffectTreeTwister.java | 87 - .../gregtech/loaders/misc/bees/GT_Flowers.java | 135 - 18 files changed, 4452 insertions(+), 4473 deletions(-) create mode 100644 src/main/java/gregtech/loaders/misc/CoverLoader.java create mode 100644 src/main/java/gregtech/loaders/misc/GTAchievements.java create mode 100644 src/main/java/gregtech/loaders/misc/GTBeeDefinition.java create mode 100644 src/main/java/gregtech/loaders/misc/GTBees.java create mode 100644 src/main/java/gregtech/loaders/misc/GTBranchDefinition.java delete mode 100644 src/main/java/gregtech/loaders/misc/GT_Achievements.java delete mode 100644 src/main/java/gregtech/loaders/misc/GT_BeeDefinition.java delete mode 100644 src/main/java/gregtech/loaders/misc/GT_Bees.java delete mode 100644 src/main/java/gregtech/loaders/misc/GT_BranchDefinition.java delete mode 100644 src/main/java/gregtech/loaders/misc/GT_CoverLoader.java create mode 100644 src/main/java/gregtech/loaders/misc/bees/GTAlleleEffect.java create mode 100644 src/main/java/gregtech/loaders/misc/bees/GTEffectMachineBoost.java create mode 100644 src/main/java/gregtech/loaders/misc/bees/GTEffectTreeTwister.java create mode 100644 src/main/java/gregtech/loaders/misc/bees/GTFlowers.java delete mode 100644 src/main/java/gregtech/loaders/misc/bees/GT_AlleleEffect.java delete mode 100644 src/main/java/gregtech/loaders/misc/bees/GT_EffectMachineBoost.java delete mode 100644 src/main/java/gregtech/loaders/misc/bees/GT_EffectTreeTwister.java delete mode 100644 src/main/java/gregtech/loaders/misc/bees/GT_Flowers.java (limited to 'src/main/java/gregtech/loaders/misc') diff --git a/src/main/java/gregtech/loaders/misc/CoverLoader.java b/src/main/java/gregtech/loaders/misc/CoverLoader.java new file mode 100644 index 0000000000..f2feaa3a29 --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/CoverLoader.java @@ -0,0 +1,42 @@ +package gregtech.loaders.misc; + +import static gregtech.api.enums.Textures.BlockIcons.VENT_ADVANCED; +import static gregtech.api.enums.Textures.BlockIcons.VENT_NORMAL; + +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; + +import gregtech.api.GregTechAPI; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GTModHandler; +import gregtech.common.covers.CoverVent; + +public class CoverLoader implements Runnable { + + @Override + public void run() { + for (byte i = 0; i < 16; i = (byte) (i + 1)) { + GregTechAPI.registerCover(new ItemStack(Blocks.carpet, 1, i), TextureFactory.of(Blocks.wool, i), null); + } + GregTechAPI.registerCover( + GTModHandler.getIC2Item("reactorVent", 1L, 1), + TextureFactory.of(VENT_NORMAL), + new CoverVent(1)); + GregTechAPI.registerCover( + GTModHandler.getIC2Item("reactorVentCore", 1L, 1), + TextureFactory.of(VENT_NORMAL), + new CoverVent(1)); + GregTechAPI.registerCover( + GTModHandler.getIC2Item("reactorVentGold", 1L, 1), + TextureFactory.of(VENT_ADVANCED), + new CoverVent(2)); + GregTechAPI.registerCover( + GTModHandler.getIC2Item("reactorVentSpread", 1L), + TextureFactory.of(VENT_NORMAL), + new CoverVent(2)); + GregTechAPI.registerCover( + GTModHandler.getIC2Item("reactorVentDiamond", 1L, 1), + TextureFactory.of(VENT_ADVANCED), + new CoverVent(3)); + } +} diff --git a/src/main/java/gregtech/loaders/misc/GTAchievements.java b/src/main/java/gregtech/loaders/misc/GTAchievements.java new file mode 100644 index 0000000000..aed2ff6d28 --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/GTAchievements.java @@ -0,0 +1,814 @@ +package gregtech.loaders.misc; + +import static gregtech.api.enums.Mods.Thaumcraft; + +import java.util.concurrent.ConcurrentHashMap; + +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 cpw.mods.fml.common.FMLCommonHandler; +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.GTMod; +import gregtech.api.enums.GTValues; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.objects.ItemData; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.util.GTLog; +import gregtech.api.util.GTModHandler; +import gregtech.api.util.GTOreDictUnificator; +import gregtech.api.util.GTRecipe; +import gregtech.common.items.IDMetaTool01; +import gregtech.common.items.MetaGeneratedTool01; +import ic2.core.Ic2Items; +import thaumcraft.api.ThaumcraftApiHelper; + +public class GTAchievements { + + public static int oreReg = -1; + public static int assReg = -1; + public ConcurrentHashMap achievementList; + public ConcurrentHashMap issuedAchievements; + public int adjX = 5; + public int adjY = 9; + + public GTAchievements() { + this.achievementList = new ConcurrentHashMap<>(); + this.issuedAchievements = new ConcurrentHashMap<>(); + + for (GTRecipe recipe : RecipeMaps.assemblylineVisualRecipes.getAllRecipes()) { + registerAssAchievement(recipe); + } + + registerAchievement( + "flintpick", + 0, + 0, + MetaGeneratedTool01.INSTANCE.getToolWithStats(2, 1, Materials.Flint, Materials.Wood, null), + "", + false); + registerAchievement("crops", -4, 0, GTModHandler.getIC2Item("crop", 1L), "flintpick", false); + registerAchievement("havestlead", -4, 2, ItemList.Crop_Drop_Plumbilia.get(1), "crops", false); + registerAchievement("havestcopper", -2, 1, ItemList.Crop_Drop_Coppon.get(1), "crops", false); + registerAchievement("havesttin", -2, -1, ItemList.Crop_Drop_Tine.get(1), "crops", false); + registerAchievement("havestoil", -4, -4, ItemList.Crop_Drop_OilBerry.get(1), "crops", false); + registerAchievement("havestiron", -2, -3, ItemList.Crop_Drop_Ferru.get(1), "crops", false); + registerAchievement("havestgold", -2, -6, ItemList.Crop_Drop_Aurelia.get(1), "havestiron", false); + registerAchievement("havestsilver", -4, -5, ItemList.Crop_Drop_Argentia.get(1), "havestiron", false); + registerAchievement("havestemeralds", -2, -8, ItemList.Crop_Drop_BobsYerUncleRanks.get(1), "havestgold", false); + + registerAchievement( + "tools", + 0, + 4, + MetaGeneratedTool01.INSTANCE + .getToolWithStats(IDMetaTool01.HARDHAMMER.ID, 1, Materials.Iron, Materials.Wood, null), + "flintpick", + false); + registerAchievement( + "driltime", + 2, + 4, + MetaGeneratedTool01.INSTANCE + .getToolWithStats(IDMetaTool01.DRILL_LV.ID, 1, Materials.BlueSteel, Materials.StainlessSteel, null), + "tools", + false); + registerAchievement( + "brrrr", + 2, + 6, + MetaGeneratedTool01.INSTANCE + .getToolWithStats(IDMetaTool01.CHAINSAW_LV.ID, 1, Materials.BlueSteel, Materials.StainlessSteel, null), + "driltime", + false); + registerAchievement( + "highpowerdrill", + 3, + 5, + MetaGeneratedTool01.INSTANCE + .getToolWithStats(IDMetaTool01.DRILL_HV.ID, 1, Materials.TungstenSteel, Materials.TungstenSteel, null), + "driltime", + false); + registerAchievement( + "hammertime", + 3, + 7, + MetaGeneratedTool01.INSTANCE.getToolWithStats( + IDMetaTool01.JACKHAMMER.ID, + 1, + Materials.TungstenSteel, + Materials.TungstenSteel, + null), + "highpowerdrill", + false); + + registerAchievement( + "unitool", + -2, + 4, + MetaGeneratedTool01.INSTANCE + .getToolWithStats(IDMetaTool01.UNIVERSALSPADE.ID, 1, Materials.Steel, Materials.Iron, null), + "tools", + false); + registerAchievement("recycling", -4, 4, ItemList.Machine_LV_ArcFurnace.get(1), "unitool", false); + + registerAchievement( + "crushed", + 0, + 6, + GTOreDictUnificator.get(OrePrefixes.crushed, Materials.Tin, 1L), + "tools", + false); + registerAchievement( + "cleandust", + 0, + 10, + GTOreDictUnificator.get(OrePrefixes.dust, Materials.Redstone, 1L), + "crushed", + false); + registerAchievement( + "washing", + -2, + 6, + GTOreDictUnificator.get(OrePrefixes.crushedPurified, Materials.Iron, 1L), + "crushed", + false); + registerAchievement( + "spinit", + -4, + 6, + GTOreDictUnificator.get(OrePrefixes.crushedCentrifuged, Materials.Redstone, 1L), + "crushed", + false); + + registerAchievement("newfuel", -4, 8, ItemList.ThoriumCell_4.get(1), "spinit", false); + registerAchievement( + "newmetal", + -4, + 10, + GTOreDictUnificator.get(OrePrefixes.dust, Materials.Lutetium, 1L), + "newfuel", + false); + registerAchievement("reflect", -2, 9, ItemList.Neutron_Reflector.get(1), "newfuel", false); + + registerAchievement( + "bronze", + 2, + 0, + GTOreDictUnificator.get(OrePrefixes.dust, Materials.Bronze, 1L), + "flintpick", + false); + registerAchievement( + "simplyeco", + 2, + 2, + ItemList.Machine_Bronze_Boiler_Solar.get(1, ItemList.Machine_HP_Solar.get(1L)), + "bronze", + false); + registerAchievement("firststeam", 2, -2, ItemList.Machine_Bronze_Boiler.get(1), "bronze", false); + registerAchievement("alloysmelter", 2, -4, ItemList.Machine_Bronze_AlloySmelter.get(1), "firststeam", false); + registerAchievement("macerator", 0, -2, ItemList.Machine_Bronze_Macerator.get(1), "firststeam", false); + registerAchievement("extract", 0, -4, ItemList.Machine_Bronze_Extractor.get(1), "alloysmelter", false); + + registerAchievement("smallparts", 0, -5, ItemList.Circuit_Primitive.get(1), "alloysmelter", false); + registerAchievement("gtbasiccircuit", 0, -8, Ic2Items.electronicCircuit.copy(), "smallparts", false); + registerAchievement("bettercircuits", 0, -9, ItemList.Circuit_Good.get(1), "gtbasiccircuit", false); + registerAchievement("stepforward", -2, -9, Ic2Items.advancedCircuit.copy(), "bettercircuits", false); + registerAchievement("gtmonosilicon", -5, -10, ItemList.Circuit_Silicon_Ingot.get(1), "stepforward", false); + registerAchievement("gtlogicwafer", -7, -10, ItemList.Circuit_Wafer_ILC.get(1), "gtmonosilicon", false); + registerAchievement("gtlogiccircuit", -9, -10, ItemList.Circuit_Basic.get(1), "gtlogicwafer", false); + registerAchievement("gtcleanroom", -11, -10, ItemList.Machine_Multi_Cleanroom.get(1), "gtlogiccircuit", false); + registerAchievement("energyflow", -13, -10, ItemList.Circuit_Nanoprocessor.get(1), "gtcleanroom", false); + registerAchievement( + "gtquantumprocessor", + -13, + -12, + ItemList.Circuit_Quantumprocessor.get(1), + "energyflow", + false); + registerAchievement( + "gtcrystalprocessor", + -11, + -12, + ItemList.Circuit_Crystalprocessor.get(1), + "gtquantumprocessor", + false); + registerAchievement("gtwetware", -9, -12, ItemList.Circuit_Neuroprocessor.get(1), "gtcrystalprocessor", false); + registerAchievement("gtwetmain", -7, -12, ItemList.Circuit_Wetwaremainframe.get(1), "gtwetware", false); + + registerAchievement("orbs", -10, -14, ItemList.Energy_LapotronicOrb.get(1), "energyflow", false); + registerAchievement("thatspower", -8, -14, ItemList.Energy_LapotronicOrb2.get(1), "orbs", false); + registerAchievement("datasaving", -2, -12, ItemList.Tool_DataOrb.get(1), "stepforward", false); + registerAchievement("superbuffer", 0, -12, ItemList.Automation_SuperBuffer_LV.get(1), "datasaving", false); + registerAchievement("newstorage", -2, -14, ItemList.Quantum_Chest_HV.get(1), "superbuffer", false); + registerAchievement("whereistheocean", 2, -14, ItemList.Quantum_Tank_IV.get(1), "superbuffer", false); + registerAchievement("luck", 2, -6, ItemList.ZPM.get(1), "", false); + + registerAchievement( + "steel", + 4, + 0, + GTOreDictUnificator.get(OrePrefixes.ingot, Materials.Steel, 1L), + "bronze", + false); + registerAchievement("highpressure", 4, 2, ItemList.Machine_Steel_Boiler.get(1), "steel", false); + registerAchievement( + "extremepressure", + 4, + 4, + ItemList.Machine_Multi_LargeBoiler_Steel.get(1), + "highpressure", + false); + registerAchievement("cheapermac", 6, 1, ItemList.Machine_LV_Hammer.get(1), "steel", false); + registerAchievement( + "complexalloys", + 6, + 3, + GTOreDictUnificator.get(OrePrefixes.ingot, Materials.BlueSteel, 1L), + "cheapermac", + false); + + registerAchievement( + "magneticiron", + 4, + -2, + GTOreDictUnificator.get(OrePrefixes.stick, Materials.IronMagnetic, 1L), + "steel", + false); + registerAchievement("lvmotor", 4, -6, ItemList.Electric_Motor_LV.get(1), "magneticiron", false); + registerAchievement("pumpcover", 2, -8, ItemList.Electric_Pump_LV.get(1), "lvmotor", false); + registerAchievement("closeit", 2, -10, ItemList.Cover_Shutter.get(1), "pumpcover", false); + registerAchievement("slurp", 2, -12, ItemList.Pump_HV.get(1), "closeit", false); + registerAchievement("transport", 4, -10, ItemList.Conveyor_Module_LV.get(1), "lvmotor", false); + registerAchievement("manipulation", 4, -12, ItemList.Cover_Controller.get(1), "transport", false); + registerAchievement("buffer", 4, -14, ItemList.Automation_ChestBuffer_LV.get(1), "manipulation", false); + registerAchievement("complexmachines", 6, -9, ItemList.Robot_Arm_LV.get(1), "lvmotor", false); + registerAchievement("avengers", 8, -11, ItemList.Machine_LV_Assembler.get(1), "complexmachines", false); + registerAchievement("filterregulate", 10, -11, ItemList.Component_Filter.get(1), "avengers", false); + + registerAchievement("steampower", 6, -6, ItemList.Generator_Steam_Turbine_LV.get(1), "lvmotor", false); + registerAchievement("batterys", 6, -4, ItemList.Battery_Buffer_2by2_MV.get(1), "steampower", false); + registerAchievement("badweather", 6, -8, ItemList.Casing_FireHazard.get(1), "steampower", false); + registerAchievement("electricproblems", 7, -7, ItemList.Casing_ExplosionHazard.get(1), "steampower", false); + registerAchievement("ebf", 8, -6, ItemList.Machine_Multi_BlastFurnace.get(1), "steampower", false); + registerAchievement("energyhatch", 12, -6, ItemList.Hatch_Energy_LV.get(1), "ebf", false); + + registerAchievement( + "gtaluminium", + 8, + 0, + GTOreDictUnificator.get(OrePrefixes.ingot, Materials.Aluminium, 1L), + "steel", + false); + registerAchievement("highpowersmelt", 8, 2, ItemList.Machine_Multi_Furnace.get(1), "gtaluminium", false); + registerAchievement("oilplant", 8, 4, ItemList.Distillation_Tower.get(1), "highpowersmelt", false); + registerAchievement("factory", 8, 6, ItemList.Processing_Array.get(1), "oilplant", false); + registerAchievement("upgradeebf", 8, -2, ItemList.Hatch_Energy_MV.get(1), "gtaluminium", false); + registerAchievement("maintainance", 10, -2, ItemList.Hatch_Maintenance.get(1), "upgradeebf", false); + + registerAchievement("upgrade", 10, 0, ItemList.Casing_Coil_Kanthal.get(1), "gtaluminium", false); + registerAchievement( + "titan", + 14, + 0, + GTOreDictUnificator.get(OrePrefixes.ingot, Materials.Titanium, 1L), + "upgrade", + false); + registerAchievement("magic", 14, 3, ItemList.MagicEnergyConverter_LV.get(1), "titan", false); + registerAchievement("highmage", 10, 3, ItemList.MagicEnergyAbsorber_HV.get(1), "magic", false); + registerAchievement("artificaldia", 12, 2, ItemList.IC2_Industrial_Diamond.get(1), "titan", false); + registerAchievement("muchsteam", 13, 1, ItemList.LargeSteamTurbine.get(1), "titan", false); + registerAchievement("efficientsteam", 11, 1, ItemList.LargeSteamTurbine.get(1), "muchsteam", false); + + registerAchievement("upgrade2", 16, 0, ItemList.Casing_Coil_Nichrome.get(1), "titan", false); + registerAchievement( + "tungsten", + 16, + 2, + GTOreDictUnificator.get(OrePrefixes.ingot, Materials.Tungsten, 1L), + "upgrade2", + false); + registerAchievement( + "osmium", + 16, + -2, + GTOreDictUnificator.get(OrePrefixes.ingot, Materials.Osmium, 1L), + "upgrade2", + false); + registerAchievement("hightech", 15, -3, ItemList.Field_Generator_LV.get(1), "osmium", false); + registerAchievement("amplifier", 16, -5, ItemList.Machine_LV_Amplifab.get(1), "hightech", false); + registerAchievement("scanning", 13, -3, ItemList.Machine_HV_Scanner.get(1), "hightech", false); + registerAchievement("alienpower", 14, -5, ItemList.Generator_Naquadah_Mark_I.get(1), "hightech", false); + registerAchievement("universal", 15, -6, ItemList.Machine_LV_Massfab.get(1), "hightech", false); + registerAchievement("replication", 17, -6, ItemList.Machine_LV_Replicator.get(1), "universal", false); + + registerAchievement( + "tungstensteel", + 16, + 4, + GTOreDictUnificator.get(OrePrefixes.ingot, Materials.TungstenSteel, 1L), + "tungsten", + false); + registerAchievement("upgrade3", 15, 5, ItemList.Casing_Coil_TungstenSteel.get(1), "tungstensteel", false); + registerAchievement( + "hssg", + 13, + 5, + GTOreDictUnificator.get(OrePrefixes.ingot, Materials.HSSG, 1L), + "upgrade3", + false); + registerAchievement("upgrade4", 11, 5, ItemList.Casing_Coil_HSSG.get(1), "hssg", false); + registerAchievement( + "stargatematerial", + 11, + 7, + GTOreDictUnificator.get(OrePrefixes.ingot, Materials.Naquadah, 1L), + "upgrade4", + false); + registerAchievement("conducting", 14, 6, ItemList.Casing_Coil_Superconductor.get(1), "upgrade3", false); + registerAchievement("fusion", 15, 7, ItemList.FusionComputer_LuV.get(1), "tungstensteel", false); + registerAchievement("higherefficency", 15, 9, ItemList.Generator_Plasma_EV.get(1), "fusion", false); + registerAchievement("advancing", 13, 7, ItemList.FusionComputer_ZPMV.get(1), "fusion", false); + + registerAchievement("stargateliquid", 11, 9, ItemList.Generator_Plasma_IV.get(1), "advancing", false); + registerAchievement("tothelimit", 13, 9, ItemList.Generator_Plasma_IV.get(1), "advancing", false); + registerAchievement("fullefficiency", 12, 10, ItemList.Generator_Plasma_LuV.get(1), "tothelimit", false); + registerAchievement("upgrade5", 9, 9, ItemList.Casing_Coil_Naquadah.get(1), "stargateliquid", false); + registerAchievement( + "alienmetallurgy", + 9, + 7, + GTOreDictUnificator.get(OrePrefixes.ingot, Materials.NaquadahAlloy, 1L), + "upgrade5", + false); + registerAchievement("over9000", 7, 7, ItemList.Casing_Coil_NaquadahAlloy.get(1), "alienmetallurgy", false); + registerAchievement( + "finalpreparations", + 7, + 9, + GTOreDictUnificator.get(OrePrefixes.ingot, Materials.Naquadria, 1L), + "over9000", + false); + registerAchievement("denseaspossible", 6, 10, ItemList.FusionComputer_UV.get(1), "finalpreparations", false); + + registerAchievement("zpmage", 8, 10, ItemList.Energy_Module.get(1), "denseaspossible", false); + registerAchievement("uvage", 10, 10, ItemList.Energy_Cluster.get(1), "zpmage", false); + registerAchievement("whatnow", 12, 10, ItemList.ZPM2.get(1), "uvage", false); + + if (GTMod.gregtechproxy.mAchievements) { + AchievementPage.registerAchievementPage( + new AchievementPage( + "GregTech 5", + this.achievementList.values() + .toArray(new Achievement[0]))); + 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) {} + + public Achievement registerAchievement(String textId, int x, int y, ItemStack icon, Achievement requirement, + boolean special) { + if (!GTMod.gregtechproxy.mAchievements) { + return null; + } + Achievement achievement = new Achievement(textId, textId, this.adjX + x, this.adjY + y, icon, requirement); + if (special) { + achievement.setSpecial(); + } + ((StatBase) achievement).registerStat(); + if (GTValues.D2) { + GTLog.out.println("achievement." + textId + "="); + GTLog.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 (!GTMod.gregtechproxy.mAchievements) { + return null; + } + Achievement achievement = new Achievement( + textId, + textId, + this.adjX + x, + this.adjY + y, + icon, + getAchievement(requirement)); + if (special) { + achievement.setSpecial(); + } + ((StatBase) achievement).registerStat(); + if (GTValues.D2) { + GTLog.out.println("achievement." + textId + "="); + GTLog.out.println("achievement." + textId + ".desc="); + } + this.achievementList.put(textId, achievement); + return achievement; + } + + public Achievement registerOreAchievement(Materials aMaterial) { + return null; + } + + public Achievement registerAssAchievement(GTRecipe recipe) { + if (recipe == null) { + GTMod.GT_FML_LOGGER.error("Invalid achievement registration attempt for null recipe", new Exception()); + return null; + } + if (recipe.getOutput(0) == null) { + GTMod.GT_FML_LOGGER + .error("Invalid achievement registration attempt for recipe with null output", new Exception()); + return null; + } + if (this.achievementList.get( + recipe.getOutput(0) + .getUnlocalizedName()) + == null) { + assReg++; + return registerAchievement( + recipe.getOutput(0) + .getUnlocalizedName(), + -(11 + assReg % 5), + ((assReg) / 5) - 8, + recipe.getOutput(0), + AchievementList.openInventory, + false); + } + return null; + } + + public void issueAchievement(EntityPlayer entityplayer, String textId) { + if (entityplayer == null || !GTMod.gregtechproxy.mAchievements) { + return; + } + entityplayer.triggerAchievement(this.achievementList.get(textId)); + } + + public Achievement getAchievement(String textId) { + if (this.achievementList.containsKey(textId)) { + return this.achievementList.get(textId); + } + return null; + } + + public void issueAchivementHatch(EntityPlayer player, ItemStack stack) { + if (player == null || stack == null) { + return; + } + ItemData data = GTOreDictUnificator.getItemData(stack); + + if ((data != null) && (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.Osmium) { + issueAchievement(player, "osmium"); + } else if (data.mMaterial.mMaterial == Materials.TungstenSteel) { + issueAchievement(player, "tungstensteel"); + } else if (data.mMaterial.mMaterial == Materials.HSSG) { + issueAchievement(player, "hssg"); + } else if (data.mMaterial.mMaterial == Materials.Naquadah) { + issueAchievement(player, "stargatematerial"); + } else if (data.mMaterial.mMaterial == Materials.NaquadahAlloy) { + issueAchievement(player, "alienmetallurgy"); + } else if (data.mMaterial.mMaterial == Materials.Naquadria) { + issueAchievement(player, "finalpreparations"); + } + } + if (stack.getUnlocalizedName() + .equals("ic2.itemPartIndustrialDiamond")) { + issueAchievement(player, "artificaldia"); + issueAchievement(player, "buildCoalDiamond"); + } + } + + public void issueAchivementHatchFluid(EntityPlayer player, FluidStack fluid) { + if (player == null || fluid == null) { + return; + } + switch (fluid.getFluid() + .getUnlocalizedName()) { + case "fluid.plasma.helium" -> issueAchievement(player, "fusion"); + case "fluid.molten.europium" -> issueAchievement(player, "advancing"); + case "fluid.molten.naquadah" -> issueAchievement(player, "stargateliquid"); + case "fluid.molten.americium" -> issueAchievement(player, "tothelimit"); + case "fluid.molten.neutronium" -> issueAchievement(player, "denseaspossible"); + case "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 = GTOreDictUnificator.getItemData(stack); + if (data != null) { + if (data.mPrefix == OrePrefixes.dust && data.mMaterial.mMaterial == Materials.Bronze) { + issueAchievement(player, "bronze"); + } + } + switch (stack.getUnlocalizedName()) { + case "gt.metaitem.01.2300" -> issueAchievement(player, "bronze"); + case "gt.metaitem.01.32700" -> issueAchievement(player, "smallparts"); + case "gt.metaitem.01.32702" -> issueAchievement(player, "bettercircuits"); + case "gt.metaitem.01.23354" -> issueAchievement(player, "magneticiron"); + case "gt.metaitem.01.32600" -> { + issueAchievement(player, "lvmotor"); + issueAchievement(player, "buildCable"); + } + case "gt.metaitem.01.32610" -> issueAchievement(player, "pumpcover"); + case "gt.metaitem.01.32630" -> issueAchievement(player, "transport"); + case "gt.metaitem.01.32650" -> issueAchievement(player, "complexmachines"); + case "gt.metaitem.01.32670" -> issueAchievement(player, "hightech"); + case "ic2.blockCrop" -> issueAchievement(player, "crops"); + case "ic2.itemPartCircuit" -> issueAchievement(player, "gtbasiccircuit"); + case "ic2.itemPartCircuitAdv" -> issueAchievement(player, "stepforward"); + case "gt.blockmachines.boiler.solar" -> issueAchievement(player, "simplyeco"); + case "gt.blockmachines.boiler.bronze" -> issueAchievement(player, "firststeam"); + case "gt.blockmachines.boiler.steel" -> issueAchievement(player, "highpressure"); + case "gt.blockmachines.bronzemachine.macerator" -> { + issueAchievement(player, "macerator"); + issueAchievement(player, "buildMacerator"); + } + case "gt.blockmachines.bronzemachine.alloysmelter.tier.3" -> issueAchievement(player, "buildIndFurnace"); + case "gt.blockmachines.bronzemachine.alloysmelter" -> { + issueAchievement(player, "alloysmelter"); + issueAchievement(player, "buildElecFurnace"); + } + + case "gt.blockmachines.bronzemachine.extractor" -> { + issueAchievement(player, "extract"); + issueAchievement(player, "buildCompressor"); + issueAchievement(player, "buildExtractor"); + } + case "gt.blockmachines.basicmachine.pump.tier.03" -> issueAchievement(player, "slurp"); + case "gt.blockmachines.multimachine.blastfurnace" -> issueAchievement(player, "ebf"); + case "gt.blockmachines.hatch.energy.tier.02" -> issueAchievement(player, "upgradeebf"); + case "gt.blockmachines.multimachine.multifurnace" -> issueAchievement(player, "highpowersmelt"); + case "gt.blockmachines.hatch.energy.tier.01" -> issueAchievement(player, "energyhatch"); + case "gt.blockmachines.multimachine.processingarray" -> issueAchievement(player, "factory"); + case "gt.blockmachines.basicgenerator.magicenergyconverter.tier.01" -> issueAchievement(player, "magic"); + case "gt.blockmachines.basicgenerator.magicenergyabsorber.tier.03" -> issueAchievement(player, "highmage"); + case "gt.blockmachines.basicgenerator.plasmagenerator.tier.07" -> issueAchievement( + player, + "fullefficiency"); + case "gt.blockmachines.multimachine.largeturbine" -> issueAchievement(player, "muchsteam"); + case "gt.blockmachines.multimachine.largehpturbine" -> issueAchievement(player, "efficientsteam"); + case "gt.blockmachines.multimachine.cleanroom" -> issueAchievement(player, "gtcleanroom"); + case "gt.neutronreflector" -> issueAchievement(player, "reflect"); + case "gt.blockcasings5.1" -> issueAchievement(player, "upgrade"); + case "gt.blockcasings5.2" -> issueAchievement(player, "upgrade2"); + case "gt.blockcasings5.3" -> issueAchievement(player, "upgrade3"); + case "gt.blockcasings5.4" -> issueAchievement(player, "upgrade4"); + case "gt.blockcasings5.5" -> issueAchievement(player, "upgrade5"); + case "gt.blockcasings5.6" -> issueAchievement(player, "over9000"); + case "gt.blockcasings.15" -> issueAchievement(player, "conducting"); + } + + if (!stack.getUnlocalizedName() + .startsWith("gt.blockmachines.")) { + return; + } + + // from here, it only concerns "gt.blockmachines." kind of achievements + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.basicmachine.arcfurnace.tier.")) { + issueAchievement(player, "recycling"); + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.basicmachine.disassembler.tier.")) { + issueAchievement(player, "repair"); + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.automation.superbuffer.tier.")) { + issueAchievement(player, "superbuffer"); + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.quantum.tank.tier.")) { + issueAchievement(player, "whereistheocean"); + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.quantum.chest.tier.")) { + issueAchievement(player, "newstorage"); + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.basicmachine.hammer.tier.")) { + issueAchievement(player, "cheapermac"); + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.automation.chestbuffer.tier.")) { + issueAchievement(player, "buffer"); + issueAchievement(player, "buildBatBox"); + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.automation.chestbuffer.tier.3")) { + issueAchievement(player, "buildMFE"); + } + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.basicgenerator.steamturbine.tier.")) { + issueAchievement(player, "steampower"); + issueAchievement(player, "buildGenerator"); + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.basicmachine.assembler.tier.")) { + issueAchievement(player, "avengers"); + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.batterybuffer.")) { + issueAchievement(player, "batterys"); + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.basicmachine.amplifab.tier.")) { + issueAchievement(player, "amplifier"); + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.basicmachine.massfab.tier.")) { + issueAchievement(player, "universal"); + issueAchievement(player, "buildMassFab"); + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.basicgenerator.naquadah.tier.")) { + issueAchievement(player, "alienpower"); + return; + } + if (stack.getUnlocalizedName() + .startsWith("gt.blockmachines.basicmachine.replicator.tier.")) { + issueAchievement(player, "replication"); + return; + } + + } + + @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 = GTOreDictUnificator.getItemData(stack); + if (data != null && data.mPrefix != 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.name() + .startsWith("ore")) { + int data_getAllMaterialStacks_sS = data.getAllMaterialStacks() + .size(); + for (int i = 0; i < data_getAllMaterialStacks_sS; i++) { + issueAchievement( + player, + data.getAllMaterialStacks() + .get(i).mMaterial.mName); + if (data.getAllMaterialStacks() + .get(i).mMaterial == Materials.AnyIron) { + issueAchievement(player, "iron"); + } + if (data.getAllMaterialStacks() + .get(i).mMaterial == Materials.Copper + || data.getAllMaterialStacks() + .get(i).mMaterial == Materials.Tin) { + issueAchievement(event.entityPlayer, "mineOre"); + } + } + } 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 && Thaumcraft.isModLoaded() + && ThaumcraftApiHelper.isResearchComplete(player.getDisplayName(), "GT_IRON_TO_STEEL")) { + issueAchievement(player, "steel"); + } + } + } + // GT_FML_LOGGER.info(stack.getUnlocalizedName()); + switch (stack.getUnlocalizedName()) { + case "gt.metaitem.02.32500" -> issueAchievement(player, "havestlead"); + case "gt.metaitem.02.32501" -> issueAchievement(player, "havestsilver"); + case "gt.metaitem.02.32503" -> issueAchievement(player, "havestiron"); + case "gt.metaitem.02.32504" -> issueAchievement(player, "havestgold"); + case "gt.metaitem.02.32530" -> issueAchievement(player, "havestcopper"); + case "gt.metaitem.02.32540" -> issueAchievement(player, "havesttin"); + case "gt.metaitem.02.32510" -> issueAchievement(player, "havestoil"); + case "gt.metaitem.02.32511" -> issueAchievement(player, "havestemeralds"); + case "gt.metaitem.03.32082" -> issueAchievement(player, "energyflow"); + case "gt.metaitem.01.32702" -> issueAchievement(player, "bettercircuits"); + case "gt.metaitem.01.32707" -> issueAchievement(player, "datasaving"); + case "gt.metaitem.01.32597" -> issueAchievement(player, "orbs"); + case "gt.metaitem.01.32599" -> issueAchievement(player, "thatspower"); + case "gt.metaitem.01.32598" -> issueAchievement(player, "luck"); + case "gt.metaitem.01.32749" -> issueAchievement(player, "closeit"); + case "gt.metaitem.01.32730" -> issueAchievement(player, "manipulation"); + case "gt.metaitem.01.32729" -> issueAchievement(player, "filterregulate"); + case "gt.metaitem.01.32605" -> issueAchievement(player, "whatnow"); + case "gt.metaitem.01.32736" -> issueAchievement(player, "zpmage"); + case "gt.metaitem.01.32737" -> issueAchievement(player, "uvage"); + case "gt.metaitem.03.32030" -> issueAchievement(player, "gtmonosilicon"); + case "gt.metaitem.03.32036" -> issueAchievement(player, "gtlogicwafer"); + case "gt.metaitem.01.32701" -> issueAchievement(player, "gtlogiccircuit"); + case "gt.metaitem.03.32085" -> issueAchievement(player, "gtquantumprocessor"); + case "gt.metaitem.03.32089" -> issueAchievement(player, "gtcrystalprocessor"); + case "gt.metaitem.03.32092" -> issueAchievement(player, "gtwetware"); + case "gt.metaitem.03.32095" -> issueAchievement(player, "gtwetmain"); + case "gt.Thoriumcell" -> issueAchievement(player, "newfuel"); + case "ic2.itemPartCircuitAdv" -> issueAchievement(player, "stepforward"); + case "gt.blockcasings5.1" -> issueAchievement(player, "upgrade"); + case "gt.blockcasings5.2" -> issueAchievement(player, "upgrade2"); + case "gt.blockcasings5.3" -> issueAchievement(player, "upgrade3"); + case "gt.blockcasings5.4" -> issueAchievement(player, "upgrade4"); + case "gt.blockcasings5.5" -> issueAchievement(player, "upgrade5"); + case "gt.blockcasings5.6" -> issueAchievement(player, "over9000"); + case "gt.blockcasings.15" -> issueAchievement(player, "conducting"); + case "gt.metaitem.01.32761" -> { // Debug Scanner pickup shows all assline recipes. + if (player.capabilities.isCreativeMode) { + for (GTRecipe recipe : RecipeMaps.assemblylineVisualRecipes.getAllRecipes()) { + issueAchievement( + player, + recipe.getOutput(0) + .getUnlocalizedName()); + recipe.mHidden = false; + } + } + } + } + + if ((stack.getItem() == Ic2Items.quantumBodyarmor.getItem()) + || (stack.getItem() == Ic2Items.quantumBoots.getItem()) + || (stack.getItem() == Ic2Items.quantumHelmet.getItem()) + || (stack.getItem() == Ic2Items.quantumLeggings.getItem())) { + issueAchievement(player, "buildQArmor"); + } + + for (GTRecipe recipe : RecipeMaps.assemblylineVisualRecipes.getAllRecipes()) { + if (recipe.getOutput(0) + .getUnlocalizedName() + .equals(stack.getUnlocalizedName())) { + issueAchievement( + player, + recipe.getOutput(0) + .getUnlocalizedName()); + recipe.mHidden = false; + } + } + } +} diff --git a/src/main/java/gregtech/loaders/misc/GTBeeDefinition.java b/src/main/java/gregtech/loaders/misc/GTBeeDefinition.java new file mode 100644 index 0000000000..c8fcf5839e --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/GTBeeDefinition.java @@ -0,0 +1,2818 @@ +package gregtech.loaders.misc; + +import static forestry.api.apiculture.EnumBeeChromosome.CAVE_DWELLING; +import static forestry.api.apiculture.EnumBeeChromosome.EFFECT; +import static forestry.api.apiculture.EnumBeeChromosome.FERTILITY; +import static forestry.api.apiculture.EnumBeeChromosome.FLOWERING; +import static forestry.api.apiculture.EnumBeeChromosome.FLOWER_PROVIDER; +import static forestry.api.apiculture.EnumBeeChromosome.HUMIDITY_TOLERANCE; +import static forestry.api.apiculture.EnumBeeChromosome.LIFESPAN; +import static forestry.api.apiculture.EnumBeeChromosome.NOCTURNAL; +import static forestry.api.apiculture.EnumBeeChromosome.SPECIES; +import static forestry.api.apiculture.EnumBeeChromosome.SPEED; +import static forestry.api.apiculture.EnumBeeChromosome.TEMPERATURE_TOLERANCE; +import static forestry.api.apiculture.EnumBeeChromosome.TERRITORY; +import static forestry.api.apiculture.EnumBeeChromosome.TOLERANT_FLYER; +import static forestry.api.core.EnumHumidity.ARID; +import static forestry.api.core.EnumHumidity.DAMP; +import static forestry.api.core.EnumTemperature.COLD; +import static forestry.api.core.EnumTemperature.HELLISH; +import static forestry.api.core.EnumTemperature.HOT; +import static forestry.api.core.EnumTemperature.ICY; +import static forestry.api.core.EnumTemperature.NORMAL; +import static forestry.api.core.EnumTemperature.WARM; +import static forestry.core.genetics.alleles.EnumAllele.Fertility; +import static forestry.core.genetics.alleles.EnumAllele.Flowering; +import static forestry.core.genetics.alleles.EnumAllele.Flowers; +import static forestry.core.genetics.alleles.EnumAllele.Lifespan; +import static forestry.core.genetics.alleles.EnumAllele.Speed; +import static forestry.core.genetics.alleles.EnumAllele.Territory; +import static forestry.core.genetics.alleles.EnumAllele.Tolerance; +import static gregtech.api.enums.Mods.AdvancedSolarPanel; +import static gregtech.api.enums.Mods.AppliedEnergistics2; +import static gregtech.api.enums.Mods.Avaritia; +import static gregtech.api.enums.Mods.AvaritiaAddons; +import static gregtech.api.enums.Mods.BiomesOPlenty; +import static gregtech.api.enums.Mods.CropsPlusPlus; +import static gregtech.api.enums.Mods.EnderStorage; +import static gregtech.api.enums.Mods.ExtraBees; +import static gregtech.api.enums.Mods.ExtraCells2; +import static gregtech.api.enums.Mods.ExtraUtilities; +import static gregtech.api.enums.Mods.Forestry; +import static gregtech.api.enums.Mods.GalacticraftCore; +import static gregtech.api.enums.Mods.GalacticraftMars; +import static gregtech.api.enums.Mods.GalaxySpace; +import static gregtech.api.enums.Mods.HardcoreEnderExpansion; +import static gregtech.api.enums.Mods.IndustrialCraft2; +import static gregtech.api.enums.Mods.MagicBees; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.enums.Mods.PamsHarvestCraft; +import static gregtech.api.enums.Mods.TaintedMagic; +import static gregtech.api.enums.Mods.Thaumcraft; +import static gregtech.api.enums.Mods.ThaumicBases; +import static gregtech.api.enums.Mods.TinkerConstruct; +import static gregtech.loaders.misc.GTBeeDefinitionReference.EXTRABEES; +import static gregtech.loaders.misc.GTBeeDefinitionReference.FORESTRY; +import static gregtech.loaders.misc.GTBeeDefinitionReference.GENDUSTRY; +import static gregtech.loaders.misc.GTBeeDefinitionReference.GREGTECH; +import static gregtech.loaders.misc.GTBeeDefinitionReference.MAGICBEES; + +import java.awt.Color; +import java.util.Arrays; +import java.util.Locale; +import java.util.function.Consumer; + +import net.minecraft.block.Block; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import org.apache.commons.lang3.text.WordUtils; + +import cpw.mods.fml.common.registry.GameRegistry; +import forestry.api.apiculture.BeeManager; +import forestry.api.apiculture.EnumBeeType; +import forestry.api.apiculture.IAlleleBeeEffect; +import forestry.api.apiculture.IAlleleBeeSpecies; +import forestry.api.apiculture.IBee; +import forestry.api.apiculture.IBeeGenome; +import forestry.api.apiculture.IBeeMutationCustom; +import forestry.api.core.EnumHumidity; +import forestry.api.core.EnumTemperature; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IAlleleFlowers; +import forestry.api.genetics.IMutationCustom; +import forestry.apiculture.genetics.Bee; +import forestry.apiculture.genetics.IBeeDefinition; +import forestry.apiculture.genetics.alleles.AlleleEffect; +import forestry.core.genetics.alleles.AlleleHelper; +import gregtech.api.GregTechAPI; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsKevlar; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GTLanguageManager; +import gregtech.api.util.GTModHandler; +import gregtech.api.util.GTOreDictUnificator; +import gregtech.api.util.JubilanceMegaApiary; +import gregtech.common.bees.GTAlleleBeeSpecies; +import gregtech.common.bees.GTBeeMutation; +import gregtech.common.items.CombType; +import gregtech.common.items.DropType; +import gregtech.common.items.PropolisType; +import gregtech.loaders.misc.bees.GTFlowers; +import gtnhlanth.common.register.WerkstoffMaterialPool; + +/** + * Bride Class for Lambdas + */ +class GTBeeDefinitionReference { + + protected static final byte FORESTRY = 0; + protected static final byte EXTRABEES = 1; + protected static final byte GENDUSTRY = 2; + protected static final byte MAGICBEES = 3; + protected static final byte GREGTECH = 4; + + private GTBeeDefinitionReference() {} +} + +public enum GTBeeDefinition implements IBeeDefinition { + + // organic + CLAY(GTBranchDefinition.ORGANIC, "Clay", true, new Color(0xC8C8DA), new Color(0x0000FF), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 0), 0.30f); + beeSpecies.addProduct(new ItemStack(Items.clay_ball, 1), 0.15f); + beeSpecies.addSpecialty(GTModHandler.getModItem(BiomesOPlenty.ID, "mudball", 1, 0), 0.05f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOWER); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.VANILLA); + }, dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(FORESTRY, "Industrious"), getSpecies(FORESTRY, "Diligent"), 10); + tMutation.requireResource(Blocks.clay, 0); // blockStainedHardenedClay + }), + SLIMEBALL(GTBranchDefinition.ORGANIC, "SlimeBall", true, new Color(0x4E9E55), new Color(0x00FF15), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 15), 0.30f); + beeSpecies.addProduct(new ItemStack(Items.slime_ball, 1), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.STICKY), 0.05f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + if (TinkerConstruct.isModLoaded()) { + beeSpecies.addProduct(GTModHandler.getModItem(TinkerConstruct.ID, "strangeFood", 1, 0), 0.10f); + beeSpecies.addSpecialty(GTModHandler.getModItem(TinkerConstruct.ID, "slime.gel", 1, 2), 0.02f); + } + }, template -> { + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.MUSHROOMS); + AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOWER); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, getFlowers(EXTRABEES, "water")); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Marshy"), CLAY, 7); + if (TinkerConstruct.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(TinkerConstruct.ID, "slime.gel"), 1); + }), + PEAT(GTBranchDefinition.ORGANIC, "Peat", true, new Color(0x906237), new Color(0x58300B), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.LIGNIE), 0.30f); + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 0), 0.15f); + beeSpecies.addSpecialty(GTModHandler.getModItem(Forestry.ID, "peat", 1, 0), 0.15f); + beeSpecies.addSpecialty(GTModHandler.getModItem(Forestry.ID, "mulch", 1, 0), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTER); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.WHEAT); + AlleleHelper.instance.set(template, FLOWERING, Flowering.FASTER); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); + }, dis -> dis.registerMutation(getSpecies(FORESTRY, "Rural"), CLAY, 10)), + STICKYRESIN(GTBranchDefinition.ORGANIC, "StickyResin", true, new Color(0x2E8F5B), new Color(0xDCC289), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 0), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.STICKY), 0.15f); + beeSpecies.addSpecialty(ItemList.IC2_Resin.get(1), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOWER); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(SLIMEBALL, PEAT, 15); + tMutation.requireResource("logRubber"); + }), + COAL(GTBranchDefinition.ORGANIC, "Coal", true, new Color(0x666666), new Color(0x525252), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.LIGNIE), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.COAL), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.CACTI); + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_2); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.DOWN_1); + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectCreeper); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Industrious"), PEAT, 9); + tMutation.requireResource("blockCoal"); + }), + OIL(GTBranchDefinition.ORGANIC, "Oil", true, new Color(0x4C4C4C), new Color(0x333333), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 0), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.OIL), 0.75f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOWER); + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.NORMAL); + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, getFlowers(EXTRABEES, "water")); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); + }, dis -> dis.registerMutation(COAL, STICKYRESIN, 4)), + SANDWICH(GTBranchDefinition.ORGANIC, "Sandwich", true, new Color(0x32CD32), new Color(0xDAA520), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(ExtraBees.ID, "honeyComb", 1, 9), 0.15f); + beeSpecies.addSpecialty(ItemList.Food_Sliced_Cucumber.get(1), 0.05f); + beeSpecies.addSpecialty(ItemList.Food_Sliced_Onion.get(1), 0.05f); + beeSpecies.addSpecialty(ItemList.Food_Sliced_Tomato.get(1), 0.05f); + beeSpecies.addSpecialty(ItemList.Food_Sliced_Cheese.get(1), 0.05f); + beeSpecies.addSpecialty(new ItemStack(Items.cooked_porkchop, 1, 0), 0.05f); + beeSpecies.addSpecialty(new ItemStack(Items.cooked_beef, 1, 0), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOW); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_2); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectFertile); + AlleleHelper.instance.set(template, TERRITORY, Territory.LARGE); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTER); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.WHEAT); + AlleleHelper.instance.set(template, FLOWERING, Flowering.FASTER); + }, dis -> dis.registerMutation(getSpecies(FORESTRY, "Agrarian"), getSpecies(MAGICBEES, "TCBatty"), 10)), + ASH(GTBranchDefinition.ORGANIC, "Ash", true, new Color(0x1e1a18), new Color(0xc6c6c6), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(ExtraBees.ID, "honeyComb", 1, 9), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ASH), 0.15f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.NORMAL); + AlleleHelper.instance.set(template, TERRITORY, Territory.LARGE); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTER); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.WHEAT); + AlleleHelper.instance.set(template, FLOWERING, Flowering.FASTER); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(COAL, CLAY, 10); + tMutation.restrictTemperature(HELLISH); + }), + APATITE(GTBranchDefinition.ORGANIC, "Apatite", true, new Color(0xc1c1f6), new Color(0x676784), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(ExtraBees.ID, "honeyComb", 1, 9), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.APATITE), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(WARM); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FASTEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.WHEAT); + AlleleHelper.instance.set(template, FLOWERING, Flowering.FASTER); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, getFlowers(EXTRABEES, "rock")); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(ASH, COAL, 10); + tMutation.requireResource("blockApatite"); + }), + FERTILIZER(GTBranchDefinition.ORGANIC, "Fertilizer", true, new Color(0x7fcef5), new Color(0x654525), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(ExtraBees.ID, "honeyComb", 1, 9), 0.15f); + beeSpecies.addSpecialty(GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1), 0.2f); + beeSpecies.addSpecialty(GTOreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1), 0.2f); + beeSpecies.addSpecialty(ItemList.FR_Fertilizer.get(1), 0.3f); + beeSpecies.addSpecialty(ItemList.IC2_Fertilizer.get(1), 0.3f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(WARM); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FASTEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.WHEAT); + AlleleHelper.instance.set(template, FLOWERING, Flowering.FASTER); + }, dis -> dis.registerMutation(ASH, APATITE, 8)), + // Phosphorus bee, Humidity: normal, Temperature: Hot, Parents: Apatite & Ash, Mutationrate: 12%, Combrate: 55% + PHOSPHORUS(GTBranchDefinition.ORGANIC, "Phosphorus", false, new Color(0xFFC826), new Color(0xC1C1F6), + beeSpecies -> { + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.PHOSPHORUS), 0.35f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(HOT); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(APATITE, ASH, 12); + tMutation.restrictTemperature(HOT); + GregTechAPI.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTechAPI.sBlockGem2, 8)); + }), + // Tea bee, Humidity: normal, Parents: Ash and Fertilizer, Mutationrate: 10%, combrate: 10% + TEA(GTBranchDefinition.ORGANIC, "Tea", false, new Color(0x65D13A), new Color(0x9a9679), beeSpecies -> { + beeSpecies.addProduct( + GTModHandler.getModItem(PamsHarvestCraft.ID, "tealeafItem", 1, ItemList.Crop_Drop_TeaLeaf.get(1)), + 0.10f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(NORMAL); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), + dis -> dis.registerMutation(FERTILIZER, ASH, 10)), + // Mica bee, Humidity: normal, Parents: Silicon & PEAT, Mutationrate: 15%, Combrate: 25% + MICA(GTBranchDefinition.ORGANIC, "Mica", false, new Color(0xFFC826), new Color(0xC1C1F6), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.MICA), 0.25f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(HOT); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(PEAT, getSpecies(MAGICBEES, "Silicon"), 15); + GregTechAPI.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTechAPI.sBlockCasings5, 0)); + }), + + // gems + REDSTONE(GTBranchDefinition.GEM, "Redstone", true, new Color(0x7D0F0F), new Color(0xD11919), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.REDSTONE), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.RAREEARTH), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(FORESTRY, "Industrious"), getSpecies(FORESTRY, "Demonic"), 10); + tMutation.requireResource("blockRedstone"); + }), + LAPIS(GTBranchDefinition.GEM, "Lapis", true, new Color(0x1947D1), new Color(0x476CDA), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.LAPIS), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(FORESTRY, "Demonic"), getSpecies(FORESTRY, "Imperial"), 10); + tMutation.requireResource("blockLapis"); + }), + CERTUS(GTBranchDefinition.GEM, "CertusQuartz", true, new Color(0x57CFFB), new Color(0xBBEEFF), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.CERTUS), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Hermitic"), LAPIS, 10); + tMutation.requireResource(GameRegistry.findBlock(AppliedEnergistics2.ID, "tile.BlockQuartz"), 0); + }), + FLUIX(GTBranchDefinition.GEM, "FluixDust", true, new Color(0xA375FF), new Color(0xB591FF), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.FLUIX), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, LAPIS, 7); + tMutation.requireResource(GameRegistry.findBlock(AppliedEnergistics2.ID, "tile.BlockFluix"), 0); + }), + DIAMOND(GTBranchDefinition.GEM, "Diamond", false, new Color(0xCCFFFF), new Color(0xA3CCCC), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.DIAMOND), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(HOT); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(CERTUS, COAL, 3); + tMutation.requireResource("blockDiamond"); + }), + RUBY(GTBranchDefinition.GEM, "Ruby", false, new Color(0xE6005C), new Color(0xCC0052), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.RUBY), 0.15f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.REDGARNET), 0.05f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, DIAMOND, 5); + tMutation.requireResource("blockRuby"); + }), + SAPPHIRE(GTBranchDefinition.GEM, "Sapphire", true, new Color(0x0033CC), new Color(0x00248F), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.SAPPHIRE), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(CERTUS, LAPIS, 5); + tMutation.requireResource(GregTechAPI.sBlockGem2, 12); + }), + OLIVINE(GTBranchDefinition.GEM, "Olivine", true, new Color(0x248F24), new Color(0xCCFFCC), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.OLIVINE), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.MAGNESIUM), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), + dis -> dis.registerMutation(CERTUS, getSpecies(FORESTRY, "Ended"), 5)), + EMERALD(GTBranchDefinition.GEM, "Emerald", false, new Color(0x248F24), new Color(0x2EB82E), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.EMERALD), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ALUMINIUM), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(COLD); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(OLIVINE, DIAMOND, 4); + tMutation.requireResource("blockEmerald"); + }), + REDGARNET(GTBranchDefinition.GEM, "RedGarnet", false, new Color(0xBD4C4C), new Color(0xECCECE), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.REDGARNET), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.PYROPE), 0.05f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(WARM); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(DIAMOND, RUBY, 4); + tMutation.requireResource("blockGarnetRed"); + }), + YELLOWGARNET(GTBranchDefinition.GEM, "YellowGarnet", false, new Color(0xA3A341), new Color(0xEDEDCE), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.YELLOWGARNET), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.GROSSULAR), 0.05f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(WARM); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(EMERALD, REDGARNET, 3); + tMutation.requireResource("blockGarnetYellow"); + }), + FIRESTONE(GTBranchDefinition.GEM, "Firestone", false, new Color(0xC00000), new Color(0xFF0000), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STONE), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.FIRESTONE), 0.15f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(WARM); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + AlleleHelper.instance.set(template, NOCTURNAL, true); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, RUBY, 4); + tMutation.requireResource("blockFirestone"); + }), + + // Metal Line + COPPER(GTBranchDefinition.METAL, "Copper", true, new Color(0xFF6600), new Color(0xE65C00), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.COPPER), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.GOLD), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Majestic"), CLAY, 13); + tMutation.requireResource("blockCopper"); + }), + TIN(GTBranchDefinition.METAL, "Tin", true, new Color(0xD4D4D4), new Color(0xDDDDDD), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.TIN), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ZINC), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(CLAY, getSpecies(FORESTRY, "Diligent"), 13); + tMutation.requireResource("blockTin"); + }), + LEAD(GTBranchDefinition.METAL, "Lead", true, new Color(0x666699), new Color(0xA3A3CC), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.LEAD), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.SULFUR), 0.05f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(WARM); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(COAL, COPPER, 13); + tMutation.requireResource("blockLead"); + }), + IRON(GTBranchDefinition.METAL, "Iron", true, new Color(0xDA9147), new Color(0xDE9C59), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.IRON), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.TIN), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(TIN, COPPER, 13); + tMutation.requireResource("blockIron"); + }), + STEEL(GTBranchDefinition.METAL, "Steel", true, new Color(0x808080), new Color(0x999999), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STEEL), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.IRON), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(WARM); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(IRON, COAL, 10); + tMutation.requireResource(GregTechAPI.sBlockMetal6, 13); + }), + NICKEL(GTBranchDefinition.METAL, "Nickel", true, new Color(0x8585AD), new Color(0x8585AD), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.NICKEL), 0.15f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.PLATINUM), 0.02f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(IRON, COPPER, 13); + tMutation.requireResource("blockNickel"); + }), + ZINC(GTBranchDefinition.METAL, "Zinc", true, new Color(0xF0DEF0), new Color(0xF2E1F2), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.ZINC), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.GALLIUM), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(IRON, TIN, 13); + tMutation.requireResource("blockZinc"); + }), + SILVER(GTBranchDefinition.METAL, "Silver", true, new Color(0xC2C2D6), new Color(0xCECEDE), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SILVER), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.SULFUR), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(COLD); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(LEAD, TIN, 10); + tMutation.requireResource("blockSilver"); + }), + CRYOLITE(GTBranchDefinition.METAL, "Cryolite", true, new Color(0xBFEFFF), new Color(0x73B9D0), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.CRYOLITE), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.SILVER), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(WARM); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.FASTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(LEAD, SILVER, 9); + tMutation.requireResource("blockCryolite"); + }), + GOLD(GTBranchDefinition.METAL, "Gold", true, new Color(0xEBC633), new Color(0xEDCC47), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.GOLD), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.NICKEL), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(WARM); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(LEAD, COPPER, 13); + tMutation.requireResource("blockGold"); + tMutation.restrictTemperature(HOT); + }), + ARSENIC(GTBranchDefinition.METAL, "Arsenic", true, new Color(0x736C52), new Color(0x292412), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.ARSENIC), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(WARM); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(ZINC, SILVER, 10); + tMutation.requireResource("blockArsenic"); + }), + + // Rare Metals + ALUMINIUM(GTBranchDefinition.RAREMETAL, "Aluminium", true, new Color(0xB8B8FF), new Color(0xD6D6FF), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.ALUMINIUM), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.BAUXITE), 0.05f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(NICKEL, ZINC, 9); + tMutation.requireResource("blockAluminium"); + }), + TITANIUM(GTBranchDefinition.RAREMETAL, "Titanium", true, new Color(0xCC99FF), new Color(0xDBB8FF), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.TITANIUM), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ALMANDINE), 0.05f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, ALUMINIUM, 5); + tMutation.requireResource(GregTechAPI.sBlockMetal7, 9); + }), + GLOWSTONE(GTBranchDefinition.RAREMETAL, "Glowstone", false, new Color(0xE5CA2A), new Color(0xFFBC5E), + beeSpecies -> { + beeSpecies.addSpecialty(Materials.Glowstone.getDust(1), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.NORMAL), + dis -> dis.registerMutation(REDSTONE, GOLD, 10)), + SUNNARIUM(GTBranchDefinition.RAREMETAL, "Sunnarium", false, new Color(0xFFBC5E), new Color(0xE5CA2A), + beeSpecies -> { + beeSpecies.addProduct(Materials.Glowstone.getDust(1), 0.30f); + beeSpecies.addSpecialty(Materials.Sunnarium.getDust(1), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(GLOWSTONE, GOLD, 5); + GregTechAPI.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTechAPI.sBlockCasings1, 15)); + }), + CHROME(GTBranchDefinition.RAREMETAL, "Chrome", true, new Color(0xEBA1EB), new Color(0xF2C3F2), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.CHROME), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.MAGNESIUM), 0.05f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(TITANIUM, RUBY, 5); + tMutation.requireResource(GregTechAPI.sBlockMetal2, 3); + }), + MANGANESE(GTBranchDefinition.RAREMETAL, "Manganese", true, new Color(0xD5D5D5), new Color(0xAAAAAA), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.MANGANESE), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.IRON), 0.05f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(TITANIUM, ALUMINIUM, 5); + tMutation.requireResource(GregTechAPI.sBlockMetal4, 6); + }), + TUNGSTEN(GTBranchDefinition.RAREMETAL, "Tungsten", false, new Color(0x5C5C8A), new Color(0x7D7DA1), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.TUNGSTEN), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.MOLYBDENUM), 0.05f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Heroic"), MANGANESE, 5); + tMutation.requireResource(GregTechAPI.sBlockMetal7, 11); + }), + PLATINUM(GTBranchDefinition.RAREMETAL, "Platinum", false, new Color(0xE6E6E6), new Color(0xFFFFCC), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.PLATINUM), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.IRIDIUM), 0.02f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(DIAMOND, CHROME, 5); + tMutation.requireResource("blockNickel"); + }), + IRIDIUM(GTBranchDefinition.RAREMETAL, "Iridium", false, new Color(0xDADADA), new Color(0xD1D1E0), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.IRIDIUM), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.OSMIUM), 0.05f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.PALLADIUM), 0.30f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(TUNGSTEN, PLATINUM, 5); + tMutation.requireResource(GregTechAPI.sBlockMetal3, 12); + }), + OSMIUM(GTBranchDefinition.RAREMETAL, "Osmium", false, new Color(0x2B2BDA), new Color(0x8B8B8B), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.OSMIUM), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.IRIDIUM), 0.05f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(COLD); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(TUNGSTEN, PLATINUM, 5); + tMutation.requireResource(GregTechAPI.sBlockMetal5, 9); + }), + SALTY(GTBranchDefinition.RAREMETAL, "Salt", true, new Color(0xF0C8C8), new Color(0xFAFAFA), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.SALT), 0.35f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.LITHIUM), 0.05f); + beeSpecies.addSpecialty(GTOreDictUnificator.get(OrePrefixes.dust, Materials.Borax, 1L), 0.1f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(WARM); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(CLAY, ALUMINIUM, 5); + tMutation.requireResource("blockSalt"); + }), + LITHIUM(GTBranchDefinition.RAREMETAL, "Lithium", false, new Color(0xF0328C), new Color(0xE1DCFF), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.LITHIUM), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.SALT), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(COLD); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(SALTY, ALUMINIUM, 5); + tMutation.requireResource("frameGtLithium"); + }), + ELECTROTINE(GTBranchDefinition.RAREMETAL, "Electrotine", false, new Color(0x1E90FF), new Color(0x3CB4C8), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ELECTROTINE), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.REDSTONE), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, GOLD, 5); + tMutation.requireResource("blockElectrotine"); + }), + // Sulfur bee, Humidity: normal, Temperature: Hot, Parents: PEAT & Ash, Mutationrate: 15%, Combrate: 80% + SULFUR(GTBranchDefinition.RAREMETAL, "Sulfur", false, new Color(0x1E90FF), new Color(0x3CB4C8), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SULFUR), 0.70f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.FIRESTONE), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.NORMAL), + dis -> dis.registerMutation(ASH, PEAT, 15)), + + INDIUM(GTBranchDefinition.RAREMETAL, "Indium", false, new Color(0xFFA9FF), new Color(0x8F5D99), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.INDIUM), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(LEAD, OSMIUM, 1); + tMutation.requireResource("blockIndium"); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(39, "Venus")); // Venus Dim + // Harder mutation that isn't dim locked + tMutation = dis.registerMutation(SILVER, OSMIUM, 1); + tMutation.requireResource("blockCinobiteA243"); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(60, "Bedrock")); // Thaumic Tinkerer + // Bedrock Dim + }), + + // IC2 + COOLANT(GTBranchDefinition.IC2, "Coolant", false, new Color(0x144F5A), new Color(0x2494A2), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 4), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.COOLANT), 0.15f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(COLD); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOW); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.SNOW); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectGlacial); + }, dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(FORESTRY, "Icy"), getSpecies(FORESTRY, "Glacial"), 10); + tMutation.requireResource( + Block.getBlockFromItem( + GTModHandler.getModItem(IndustrialCraft2.ID, "fluidCoolant", 1) + .getItem()), + 0); + tMutation.restrictTemperature(ICY); + }), + ENERGY(GTBranchDefinition.IC2, "Energy", false, new Color(0xC11F1F), new Color(0xEBB9B9), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(ExtraBees.ID, "honeyComb", 1, 12), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ENERGY), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(WARM); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectIgnition); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_2); + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.NETHER); + AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); + }, dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(FORESTRY, "Demonic"), getSpecies(EXTRABEES, "volcanic"), 10); + tMutation.requireResource( + Block.getBlockFromItem( + GTModHandler.getModItem(IndustrialCraft2.ID, "fluidHotCoolant", 1) + .getItem()), + 0); + tMutation.addMutationCondition(new GTBees.BiomeIDMutationCondition(128, "Boneyard Biome")); // Boneyard Biome + }), + LAPOTRON(GTBranchDefinition.IC2, "Lapotron", false, new Color(0x6478FF), new Color(0x1414FF), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.LAPIS), 0.20f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ENERGY), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.LAPOTRON), 0.10f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(ICY); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectIgnition); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_1); + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.SNOW); + AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(LAPIS, ENERGY, 6); + tMutation.requireResource("blockLapis"); + tMutation.restrictTemperature(ICY); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(28, "Moon")); // moon dim + }), + PYROTHEUM(GTBranchDefinition.IC2, "Pyrotheum", false, new Color(0xffebc4), new Color(0xe36400), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.ENERGY), 0.20f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.PYROTHEUM), 0.15f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FASTEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectIgnition); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.NETHER); + AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, ENERGY, 4); + tMutation.restrictTemperature(HELLISH); + }), + CRYOTHEUM(GTBranchDefinition.IC2, "Cryotheum", false, new Color(0x2660ff), new Color(0x5af7ff), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.BLIZZ), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.CRYOTHEUM), 0.20f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(ICY); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectSnowing); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.SNOW); + AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, COOLANT, 4); + tMutation.restrictTemperature(ICY); + }), + Explosive(GTBranchDefinition.IC2, "explosive", false, new Color(0x7E270F), new Color(0x747474), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getIC2Item("industrialTnt", 1L), 0.2f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectSnowing); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.SNOW); + AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(FIRESTONE, COAL, 4); + tMutation.requireResource(GameRegistry.findBlock(IndustrialCraft2.ID, "blockITNT"), 0); + }), + // Alloy + REDALLOY(GTBranchDefinition.GTALLOY, "RedAlloy", false, new Color(0xE60000), new Color(0xB80000), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.REDALLOY), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTER); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(COPPER, REDSTONE, 10); + tMutation.requireResource("blockRedAlloy"); + }), + REDSTONEALLOY(GTBranchDefinition.GTALLOY, "RedStoneAlloy", false, new Color(0xA50808), new Color(0xE80000), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.REDSTONEALLOY), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTER); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, REDALLOY, 8); + tMutation.requireResource("blockRedstoneAlloy"); + }), + CONDUCTIVEIRON(GTBranchDefinition.GTALLOY, "ConductiveIron", false, new Color(0xCEADA3), new Color(0x817671), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.CONDUCTIVEIRON), 0.15f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(WARM); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(REDSTONEALLOY, IRON, 8); + tMutation.requireResource("blockConductiveIron"); + }), + ENERGETICALLOY(GTBranchDefinition.GTALLOY, "EnergeticAlloy", false, new Color(0xFF9933), new Color(0xFFAD5C), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ENERGETICALLOY), 0.15f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(REDSTONEALLOY, getSpecies(FORESTRY, "Demonic"), 9); + tMutation.requireResource("blockEnergeticAlloy"); + }), + VIBRANTALLOY(GTBranchDefinition.GTALLOY, "VibrantAlloy", false, new Color(0x86A12D), new Color(0xC4F2AE), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.VIBRANTALLOY), 0.15f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + AlleleHelper.instance.set(template, FLOWERING, Flowering.FAST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(ENERGETICALLOY, getSpecies(FORESTRY, "Phantasmal"), 6); + tMutation.requireResource("blockVibrantAlloy"); + tMutation.restrictTemperature(HOT, HELLISH); + }), + ELECTRICALSTEEL(GTBranchDefinition.GTALLOY, "ElectricalSteel", false, new Color(0x787878), new Color(0xD8D8D8), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ELECTRICALSTEEL), 0.15f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTER); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(STEEL, getSpecies(FORESTRY, "Demonic"), 9); + tMutation.requireResource("blockElectricalSteel"); + }), + DARKSTEEL(GTBranchDefinition.GTALLOY, "DarkSteel", false, new Color(0x252525), new Color(0x443B44), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.DARKSTEEL), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(COLD); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(ELECTRICALSTEEL, getSpecies(FORESTRY, "Demonic"), 7); + tMutation.requireResource("blockDarkSteel"); + }), + PULSATINGIRON(GTBranchDefinition.GTALLOY, "PulsatingIron", false, new Color(0x6DD284), new Color(0x006600), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.PULSATINGIRON), 0.15f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(REDALLOY, getSpecies(FORESTRY, "Ended"), 9); + tMutation.requireResource("blockPulsatingIron"); + }), + STAINLESSSTEEL(GTBranchDefinition.GTALLOY, "StainlessSteel", false, new Color(0xC8C8DC), new Color(0x778899), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.STEEL), 0.10f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.STAINLESSSTEEL), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.CHROME), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(HOT); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectIgnition); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(CHROME, STEEL, 9); + tMutation.requireResource("blockStainlessSteel"); + }), + ENDERIUM(GTBranchDefinition.GTALLOY, "Enderium", false, new Color(0x599087), new Color(0x2E8B57), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ENDERIUM), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.CHROME), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(HOT); + }, template -> { + AlleleHelper.instance.set(template, SPEED, GTBees.speedBlinding); + AlleleHelper.instance.set(template, EFFECT, getEffect(EXTRABEES, "teleport")); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(PLATINUM, getSpecies(FORESTRY, "Phantasmal"), 3); + tMutation.requireResource("blockEnderium"); + }), + BEDROCKIUM(GTBranchDefinition.GTALLOY, "Bedrockium", false, new Color(0x0C0C0C), new Color(0xC6C6C6), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.20f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.BEDROCKIUM), 0.55f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(HOT); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOW); + AlleleHelper.instance.set(template, EFFECT, getEffect(EXTRABEES, "gravity")); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(Explosive, DIAMOND, 2); + if (ExtraUtilities.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(ExtraUtilities.ID, "block_bedrockium"), 0); + }), + + // thaumic + THAUMIUMDUST(GTBranchDefinition.THAUMIC, "ThaumiumDust", true, new Color(0x7A007A), new Color(0x5C005C), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 3), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.THAUMIUMDUST), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_2); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectExploration); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.UP_1); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.JUNGLE); + }, dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(MAGICBEES, "TCFire"), getSpecies(FORESTRY, "Edenic"), 10); + tMutation.requireResource("blockThaumium"); + tMutation.addMutationCondition(new GTBees.BiomeIDMutationCondition(192, "Magical Forest")); // magical + // forest + }), + THAUMIUMSHARD(GTBranchDefinition.THAUMIC, "ThaumiumShard", true, new Color(0x9966FF), new Color(0xAD85FF), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.THAUMIUMDUST), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.THAUMIUMSHARD), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.SNOW); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectGlacial); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(THAUMIUMDUST, getSpecies(MAGICBEES, "TCWater"), 10); + tMutation.addMutationCondition(new GTBees.BiomeIDMutationCondition(192, "Magical Forest")); // magical + // forest + }), + AMBER(GTBranchDefinition.THAUMIC, "Amber", true, new Color(0xEE7700), new Color(0x774B15), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 3), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.AMBER), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(THAUMIUMDUST, STICKYRESIN, 10); + tMutation.requireResource("blockAmber"); + }), + QUICKSILVER(GTBranchDefinition.THAUMIC, "Quicksilver", true, new Color(0x7A007A), new Color(0x5C005C), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 3), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.QUICKSILVER), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.UP_1); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.JUNGLE); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectMiasmic); + }, dis -> dis.registerMutation(THAUMIUMDUST, SILVER, 10)), + SALISMUNDUS(GTBranchDefinition.THAUMIC, "SalisMundus", true, new Color(0xF7ADDE), new Color(0x592582), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 3), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.SALISMUNDUS), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.UP_1); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.JUNGLE); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectMiasmic); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(THAUMIUMDUST, THAUMIUMSHARD, 8); + tMutation.addMutationCondition(new GTBees.BiomeIDMutationCondition(192, "Magical Forest")); // magical + // forest + }), + TAINTED(GTBranchDefinition.THAUMIC, "Tainted", true, new Color(0x904BB8), new Color(0xE800FF), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 3), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.TAINTED), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, CAVE_DWELLING, true); + AlleleHelper.instance.set(template, TOLERANT_FLYER, true); + AlleleHelper.instance.set(template, FERTILITY, Fertility.LOW); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, getFlowers(EXTRABEES, "rock")); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(THAUMIUMDUST, THAUMIUMSHARD, 7); + tMutation.addMutationCondition(new GTBees.BiomeIDMutationCondition(193, "Tainted Land")); // Tainted Land + }), + MITHRIL(GTBranchDefinition.THAUMIC, "Mithril", true, new Color(0xF0E68C), new Color(0xFFFFD2), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.PLATINUM), 0.20f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.MITHRIL), 0.125f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, CAVE_DWELLING, true); + AlleleHelper.instance.set(template, TOLERANT_FLYER, true); + AlleleHelper.instance.set(template, FERTILITY, Fertility.LOW); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, getFlowers(EXTRABEES, "rock")); + }, new Consumer<>() { + + @Override + public void accept(GTBeeDefinition dis) { + IBeeMutationCustom tMutation = dis.registerMutation(IO, PLATINUM, 7); + tMutation.requireResource(GregTechAPI.sBlockMetal4, 10); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(36, "IO")); // IO Dim + } + }), + ASTRALSILVER(GTBranchDefinition.THAUMIC, "AstralSilver", true, new Color(0xAFEEEE), new Color(0xE6E6FF), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SILVER), 0.20f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ASTRALSILVER), 0.125f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, CAVE_DWELLING, true); + AlleleHelper.instance.set(template, TOLERANT_FLYER, true); + AlleleHelper.instance.set(template, FERTILITY, Fertility.LOW); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, getFlowers(EXTRABEES, "rock")); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(SILVER, IRON, 3); + tMutation.requireResource(GregTechAPI.sBlockMetal1, 6); + }), + THAUMINITE(GTBranchDefinition.THAUMIC, "Thauminite", true, new Color(0x2E2D79), new Color(0x7581E0), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(MagicBees.ID, "comb", 1, 19), 0.20f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.THAUMINITE), 0.125f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOW); + AlleleHelper.instance.set(template, NOCTURNAL, true); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(MAGICBEES, "TCOrder"), THAUMIUMDUST, 8); + if (ThaumicBases.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(ThaumicBases.ID, "thauminiteBlock"), 0); + }), + SHADOWMETAL(GTBranchDefinition.THAUMIC, "ShadowMetal", true, new Color(0x100322), new Color(0x100342), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(MagicBees.ID, "comb", 1, 20), 0.20f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.SHADOWMETAL), 0.125f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOW); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(template, NOCTURNAL, true); + }, dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(MAGICBEES, "TCChaos"), getSpecies(MAGICBEES, "TCVoid"), 6); + if (TaintedMagic.isModLoaded()) { + tMutation.requireResource("blockShadow"); + } + }), + DIVIDED(GTBranchDefinition.THAUMIC, "Unstable", true, new Color(0xF0F0F0), new Color(0xDCDCDC), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(ExtraBees.ID, "honeyComb", 1, 61), 0.20f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.DIVIDED), 0.125f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOW); + AlleleHelper.instance.set(template, NOCTURNAL, true); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(DIAMOND, IRON, 3); + if (ExtraUtilities.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(ExtraUtilities.ID, "decorativeBlock1"), 5); + }), + CAELESTIS(GTBranchDefinition.THAUMIC, "Caelestis", true, new Color(0xF0F0F0), new Color(0xDCDCDC), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.CAELESTISRED), 0.60f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.CAELESTISBLUE), 0.60f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.CAELESTISGREEN), 0.60f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOW); + AlleleHelper.instance.set(template, NOCTURNAL, true); + }, dis -> dis.registerMutation(DIAMOND, DIVIDED, 10)), + SPARKELING(GTBranchDefinition.THAUMIC, "NetherStar", true, new Color(0x7A007A), new Color(0xFFFFFF), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(MagicBees.ID, "miscResources", 1, 3), 0.20f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.SPARKLING), 0.125f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_2); + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, CAVE_DWELLING, true); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.NETHER); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectAggressive); + AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); + }, dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(MAGICBEES, "Withering"), getSpecies(MAGICBEES, "Draconic"), 1); + tMutation.requireResource(GregTechAPI.sBlockGem3, 3); + tMutation.addMutationCondition(new GTBees.BiomeIDMutationCondition(9, "END Biome")); // sky end biome + }), + + ESSENTIA(GTBranchDefinition.THAUMIC, "Essentia", true, new Color(0x7A007A), new Color(0xFFFFFF), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(MagicBees.ID, "miscResources", 1, 3), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + }, template -> { + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_2); + AlleleHelper.instance.set(template, CAVE_DWELLING, true); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.VANILLA); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectReanimation); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(SHADOWMETAL, SPARKELING, 5); + if (Thaumcraft.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 6); + }), + + DRAKE(GTBranchDefinition.THAUMIC, "Drake", true, new Color(0x100322), new Color(0x7A007A), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.DRACONIC), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.AWAKENEDDRACONIUM), 0.20f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setJubilanceProvider(JubilanceMegaApiary.instance); + }, template -> { + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_3); + AlleleHelper.instance.set(template, CAVE_DWELLING, false); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.END); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectDrunkard); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(ESSENTIA, THAUMINITE, 5); + GregTechAPI.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTechAPI.sBlockCasings5, 8)); + }), + + // radioctive + URANIUM(GTBranchDefinition.RADIOACTIVE, "Uranium", true, new Color(0x19AF19), new Color(0x169E16), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.URANIUM), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(COLD); + beeSpecies.setNocturnal(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Avenging"), PLATINUM, 3); + tMutation.requireResource(GregTechAPI.sBlockMetal7, 14); + }), + PLUTONIUM(GTBranchDefinition.RADIOACTIVE, "Plutonium", true, new Color(0x570000), new Color(0x240000), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.LEAD), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.PLUTONIUM), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(URANIUM, EMERALD, 3); + tMutation.requireResource(GregTechAPI.sBlockMetal5, 13); + }), + NAQUADAH(GTBranchDefinition.RADIOACTIVE, "Naquadah", false, new Color(0x003300), new Color(0x002400), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.NAQUADAH), 0.15f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(PLUTONIUM, IRIDIUM, 3); + tMutation.requireResource(GregTechAPI.sBlockMetal4, 12); + }), + NAQUADRIA(GTBranchDefinition.RADIOACTIVE, "Naquadria", false, new Color(0x000000), new Color(0x002400), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SLAG), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.NAQUADAH), 0.20f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.NAQUADRIA), 0.15f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(PLUTONIUM, IRIDIUM, 8, 10); + tMutation.requireResource(GregTechAPI.sBlockMetal4, 15); + }), + DOB(GTBranchDefinition.RADIOACTIVE, "DOB", false, new Color(0x003300), new Color(0x002400), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.DOB), 0.75f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(NAQUADAH, THAUMIUMSHARD, 2); + if (AdvancedSolarPanel.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(AdvancedSolarPanel.ID, "BlockAdvSolarPanel"), 2); + tMutation.addMutationCondition(new GTBees.BiomeIDMutationCondition(9, "END Biome")); // sky end biome + }), + THORIUM(GTBranchDefinition.RADIOACTIVE, "Thorium", false, new Color(0x005000), new Color(0x001E00), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.THORIUM), 0.75f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(COLD); + beeSpecies.setNocturnal(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + }, dis -> { + IMutationCustom tMutation = dis.registerMutation(COAL, URANIUM, 3) + .setIsSecret(); + tMutation.requireResource(GregTechAPI.sBlockMetal7, 5); + }), + LUTETIUM(GTBranchDefinition.RADIOACTIVE, "Lutetium", false, new Color(0xE6FFE6), new Color(0xFFFFFF), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.LUTETIUM), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + }, dis -> { + IMutationCustom tMutation = dis.registerMutation(THORIUM, getSpecies(EXTRABEES, "rotten"), 1) + .setIsSecret(); + tMutation.requireResource(GregTechAPI.sBlockMetal4, 3); + }), + AMERICIUM(GTBranchDefinition.RADIOACTIVE, "Americium", false, new Color(0xE6E6FF), new Color(0xC8C8C8), + beeSpecies -> { + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.AMERICIUM), 0.075f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + // Makes it only work in the Mega Apiary NOTE: COMB MUST BE SPECIALITY COMB + beeSpecies.setJubilanceProvider(JubilanceMegaApiary.instance); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + }, dis -> { + IMutationCustom tMutation = dis.registerMutation(LUTETIUM, CHROME, 5, 4) + .setIsSecret(); + GregTechAPI.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTechAPI.sBlockMachines, 32020)); + }), + NEUTRONIUM(GTBranchDefinition.RADIOACTIVE, "Neutronium", false, new Color(0xFFF0F0), new Color(0xFAFAFA), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.NEUTRONIUM), 0.02f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + AlleleHelper.instance.set(template, NOCTURNAL, true); + }, dis -> { + IMutationCustom tMutation = dis.registerMutation(NAQUADRIA, AMERICIUM, 2, 2) + .setIsSecret(); + tMutation.requireResource(GregTechAPI.sBlockMetal5, 2); + }), + // Twilight + NAGA(GTBranchDefinition.TWILIGHT, "Naga", true, new Color(0x0D5A0D), new Color(0x28874B), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SALISMUNDUS), 0.02f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.NAGA), 0.10f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(MAGICBEES, "Eldritch"), getSpecies(FORESTRY, "Imperial"), 8); + tMutation.restrictHumidity(DAMP); + }), + LICH(GTBranchDefinition.TWILIGHT, "Lich", true, new Color(0xC5C5C5), new Color(0x5C605E), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SALISMUNDUS), 0.04f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.LICH), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(MAGICBEES, "Supernatural"), NAGA, 7); + tMutation.restrictHumidity(ARID); + }), + HYDRA(GTBranchDefinition.TWILIGHT, "Hydra", true, new Color(0x872836), new Color(0xB8132C), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SALISMUNDUS), 0.06f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.HYDRA), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(LICH, getSpecies(MAGICBEES, "TCFire"), 6); + tMutation.addMutationCondition(new GTBees.BiomeIDMutationCondition(138, "Undergarden")); // undergarden biome + }), + URGHAST(GTBranchDefinition.TWILIGHT, "UrGhast", true, new Color(0xA7041C), new Color(0x7C0618), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SALISMUNDUS), 0.08f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.URGHAST), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setHasEffect(); + beeSpecies.setNocturnal(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FAST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(HYDRA, THAUMIUMDUST, 5); + if (Thaumcraft.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCosmeticSolid"), 4); + tMutation.restrictTemperature(HELLISH); + }), + SNOWQUEEN(GTBranchDefinition.TWILIGHT, "SnowQueen", true, new Color(0xD02001), new Color(0x9C0018), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SALISMUNDUS), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.SNOWQUEEN), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(ICY); + beeSpecies.setHasEffect(); + beeSpecies.setNocturnal(); + }, template -> {}, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(URGHAST, SALISMUNDUS, 4); + if (ThaumicBases.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(ThaumicBases.ID, "blockSalisMundus"), 0); + tMutation.restrictTemperature(ICY); + }), + // HEE + ENDDUST(GTBranchDefinition.HEE, "End Dust", true, new Color(0xCC00FA), new Color(0x003A7D), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ENDDUST), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.NORMAL), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Ended"), STAINLESSSTEEL, 8); + + tMutation.restrictHumidity(ARID); + if (HardcoreEnderExpansion.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "end_powder_ore"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(1, "End")); // End Dim + }), + ENDIUM(GTBranchDefinition.HEE, "Endium", true, new Color(0xa0ffff), new Color(0x2F5A6C), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ENDIUM), 0.10f); + beeSpecies.addSpecialty(GTBees.propolis.getStackForType(PropolisType.Endium), 0.15f); + beeSpecies.addSpecialty(GTBees.drop.getStackForType(DropType.ENDERGOO), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.NORMAL), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Ended"), THAUMIUMDUST, 8); + tMutation.restrictHumidity(ARID); + if (HardcoreEnderExpansion.isModLoaded()) tMutation.requireResource("blockHeeEndium"); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(1, "End")); // End Dim + }), + STARDUST(GTBranchDefinition.HEE, "Star Dust", true, new Color(0xffff00), new Color(0xDCBE13), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.STARDUST), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, GTBees.speedBlinding); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOWER); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Ended"), ZINC, 8); + tMutation.restrictHumidity(ARID); + if (HardcoreEnderExpansion.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "stardust_ore"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(1, "End")); // End Dim + }), + ECTOPLASMA(GTBranchDefinition.HEE, "Ectoplasma", true, new Color(0xDCB0E5), new Color(0x381C40), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ECTOPLASMA), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Ended"), ENDDUST, 5); + tMutation.restrictHumidity(ARID); + if (HardcoreEnderExpansion.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "spooky_log"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(1, "End")); // End Dim + }), + ARCANESHARDS(GTBranchDefinition.HEE, "Arcane Shards", true, new Color(0x9010AD), new Color(0x333D82), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ARCANESHARD), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONG); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(THAUMIUMSHARD, ENDDUST, 5); + tMutation.restrictHumidity(ARID); + if (HardcoreEnderExpansion.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "laboratory_floor"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(1, "End")); // End Dim + }), + DRAGONESSENCE(GTBranchDefinition.HEE, "Dragonessence", true, new Color(0xFFA12B), new Color(0x911ECE), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.DRAGONESSENCE), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectBeatific); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_3); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_3); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(ECTOPLASMA, ARCANESHARDS, 4); + tMutation.restrictHumidity(ARID); + if (HardcoreEnderExpansion.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "essence_altar"), 1); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(1, "End")); // End Dim + }), + FIREESSENCE(GTBranchDefinition.HEE, "Fireessence", true, new Color(0xD41238), new Color(0xFFA157), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.FIREESSENSE), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.ELONGATED); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectIgnition); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_3); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.DOWN_3); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(FIRESTONE, ARCANESHARDS, 4); + tMutation.restrictHumidity(ARID); + if (HardcoreEnderExpansion.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "essence_altar"), 2); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(1, "End")); // End Dim + }), + ENDERMANHEAD(GTBranchDefinition.HEE, "EndermanHead", true, new Color(0x161616), new Color(0x6200e7), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ENDERMAN), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); + AlleleHelper.instance.set(template, EFFECT, getEffect(EXTRABEES, "teleport")); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.UP_1); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(ENDERIUM, STARDUST, 4); + tMutation.restrictHumidity(ARID); + if (HardcoreEnderExpansion.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "ender_goo"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(1, "End")); // End Dim + }), + SILVERFISH(GTBranchDefinition.HEE, "Silverfisch", true, new Color(0xEE053D), new Color(0x000000), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.SILVERFISH), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); + AlleleHelper.instance.set(template, EFFECT, getEffect(MAGICBEES, "SlowSpeed")); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.DOWN_1); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(ECTOPLASMA, STARDUST, 5); + tMutation.restrictHumidity(ARID); + if (HardcoreEnderExpansion.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "ender_goo"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(1, "End")); // End Dim + }), + RUNE(GTBranchDefinition.HEE, "Rune", true, new Color(0xE31010), new Color(0x0104D9), beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.RUNEI), 0.025f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.RUNEII), 0.0125f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, LIFESPAN, GTBees.superLife); + AlleleHelper.instance.set(template, EFFECT, getEffect(MAGICBEES, "SlowSpeed")); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); + }, dis -> { + IMutationCustom tMutation = dis.registerMutation(DRAGONESSENCE, STARDUST, 2) + .setIsSecret(); + tMutation.restrictHumidity(ARID); + if (EnderStorage.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(EnderStorage.ID, "enderChest"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(1, "End")); // End Dim + }), + // Walrus Bee, 100% Combchance, Parents: Catty and Watery + WALRUS(GTBranchDefinition.PLANET, "Walrus", true, new Color(0xD6D580), new Color(0xB5CFC9), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.WALRUS), 1.00f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FASTEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, NOCTURNAL, true); + }, dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(MAGICBEES, "Watery"), getSpecies(MAGICBEES, "Catty"), 45, 2); + if (ExtraCells2.isModLoaded()) { + tMutation.requireResource(GameRegistry.findBlock(ExtraCells2.ID, "walrus"), 0); + } + }), + MACHINIST(GTBranchDefinition.ORGANIC, "Machinist", true, new Color(85, 37, 130), new Color(253, 185, 39), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.MACHINIST), 0.2f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.FASTEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, GTFlowers.FLAMING); + AlleleHelper.instance.set(template, FERTILITY, Fertility.MAXIMUM); + AlleleHelper.instance.set(template, EFFECT, getEffect(GREGTECH, "MachineBoost")); + }, dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(FORESTRY, "Industrious"), getSpecies(FORESTRY, "Imperial"), 1); + tMutation.addMutationCondition(new GTBees.ActiveGTMachineMutationCondition()); + }), + // Space Bees + SPACE(GTBranchDefinition.SPACE, "Space", true, new Color(0x003366), new Color(0xC0C0C0), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SPACE), 0.02f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + }, template -> {}, dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(FORESTRY, "Industrious"), getSpecies(FORESTRY, "Heroic"), 10); + tMutation.restrictTemperature(ICY); + }), + METEORICIRON(GTBranchDefinition.SPACE, "MeteoricIron", true, new Color(0x321928), new Color(0x643250), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SPACE), 0.04f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.METEORICIRON), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + beeSpecies.setNocturnal(); + }, template -> {}, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(SPACE, IRON, 9); + tMutation.requireResource(GregTechAPI.sBlockMetal4, 7); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(28, "Moon")); // Moon Dim + }), + DESH(GTBranchDefinition.SPACE, "Desh", false, new Color(0x323232), new Color(0x282828), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SPACE), 0.06f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.DESH), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + beeSpecies.setNocturnal(); + }, template -> AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectIgnition), new Consumer<>() { + + @Override + public void accept(GTBeeDefinition dis) { + IBeeMutationCustom tMutation = dis.registerMutation(MARS, TITANIUM, 9); + tMutation.requireResource(GregTechAPI.sBlockMetal2, 12); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(29, "Mars")); // Mars Dim + } + }), + LEDOX(GTBranchDefinition.SPACE, "Ledox", false, new Color(0x0000CD), new Color(0x0074FF), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SPACE), 0.10f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.LEDOX), 0.10f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(COLD); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, EFFECT, getEffect(EXTRABEES, "freezing")), new Consumer<>() { + + @Override + public void accept(GTBeeDefinition dis) { + IBeeMutationCustom tMutation = dis.registerMutation(CALLISTO, LEAD, 7); + if (NewHorizonsCoreMod.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.Ledox"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(35, "Europa")); // Europa Dim + } + }), + CALLISTOICE(GTBranchDefinition.SPACE, "CallistoIce", false, new Color(0x0074FF), new Color(0x1EB1FF), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SPACE), 0.10f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.CALLISTOICE), 0.10f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, EFFECT, getEffect(EXTRABEES, "freezing")), new Consumer<>() { + + @Override + public void accept(GTBeeDefinition dis) { + IBeeMutationCustom tMutation = dis.registerMutation(CALLISTO, getSpecies(EXTRABEES, "freezing"), 7); + if (NewHorizonsCoreMod.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.CallistoColdIce"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(45, "Callisto")); // Callisto + // Dim + } + }), + MYTRYL(GTBranchDefinition.SPACE, "Mytryl", false, new Color(0xDAA520), new Color(0xF26404), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SPACE), 0.16f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.MYTRYL), 0.10f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> {}, new Consumer<>() { + + @Override + public void accept(GTBeeDefinition dis) { + IBeeMutationCustom tMutation = dis.registerMutation(IO, MITHRIL, 6); + if (NewHorizonsCoreMod.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.Mytryl"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(36, "IO")); // IO Dim + } + }), + QUANTIUM(GTBranchDefinition.SPACE, "Quantium", false, new Color(0x00FF00), new Color(0x00D10B), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SPACE), 0.16f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.QUANTIUM), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> {}, new Consumer<>() { + + @Override + public void accept(GTBeeDefinition dis) { + IBeeMutationCustom tMutation = dis.registerMutation(VENUS, OSMIUM, 6); + if (NewHorizonsCoreMod.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.Quantinum"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(39, "Venus")); // Venus Dim + } + }), + ORIHARUKON(GTBranchDefinition.SPACE, "Oriharukon", false, new Color(0x228B22), new Color(0x677D68), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SPACE), 0.26f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.ORIHARUKON), 0.10f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(COLD); + beeSpecies.setHasEffect(); + }, template -> {}, new Consumer<>() { + + @Override + public void accept(GTBeeDefinition dis) { + IBeeMutationCustom tMutation = dis.registerMutation(LEAD, OBERON, 5); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "metalsblock"), 6); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(46, "Oberon")); // Oberon Dim + } + }), + INFUSEDGOLD(GTBranchDefinition.SPACE, "Infused Gold", false, new Color(0x80641E), new Color(0xFFC83C), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.GOLD), 0.20f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.INFUSEDGOLD), 0.30f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> {}, new Consumer<>() { + + @Override + public void accept(GTBeeDefinition dis) { + IBeeMutationCustom tMutation = dis.registerMutation(GOLD, HAUMEA, 5); + tMutation.requireResource(GregTechAPI.sBlockMetal3, 10); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(83, "Haumea")); // Haumea Dim + } + }), + MYSTERIOUSCRYSTAL(GTBranchDefinition.SPACE, "MysteriousCrystal", false, new Color(0x3CB371), new Color(0x16856C), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SPACE), 0.42f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.MYSTERIOUSCRYSTAL), 0.30f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> {}, new Consumer<>() { + + @Override + public void accept(GTBeeDefinition dis) { + IBeeMutationCustom tMutation = dis.registerMutation(ENCELADUS, EMERALD, 3); + if (NewHorizonsCoreMod.isModLoaded()) tMutation + .requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.MysteriousCrystal"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(41, "Enceladus")); // Enceladus + // Dim + } + }), + BLACKPLUTONIUM(GTBranchDefinition.SPACE, "BlackPlutonium", false, new Color(0x000000), new Color(0x323232), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SPACE), 0.68f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.BLACKPLUTONIUM), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> {}, new Consumer<>() { + + @Override + public void accept(GTBeeDefinition dis) { + IBeeMutationCustom tMutation = dis.registerMutation(PLUTO, PLUTONIUM, 2); + if (NewHorizonsCoreMod.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.BlackPlutonium"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(49, "Pluto")); // Pluto Dim + } + }), + TRINIUM(GTBranchDefinition.SPACE, "Trinium", false, new Color(0xB0E0E6), new Color(0xC8C8D2), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.TRINIUM), 0.75f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.QUANTIUM), 0.10f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(COLD); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, SPEED, GTBees.speedBlinding), new Consumer<>() { + + @Override + public void accept(GTBeeDefinition dis) { + IBeeMutationCustom tMutation = dis.registerMutation(ENCELADUS, IRIDIUM, 4); + tMutation.requireResource(GregTechAPI.sBlockMetal4, 9); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(41, "Enceladus")); // Enceladus Dim + } + }), + // Planet Line + MOON(GTBranchDefinition.PLANET, "Moon", false, new Color(0x373735), new Color(0x7E7E78), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.MOON), 0.35f); + if (NewHorizonsCoreMod.isModLoaded()) + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MoonStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(COLD); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(SPACE, CLAY, 25); + if (GalacticraftCore.isModLoaded()) { + tMutation.requireResource(GameRegistry.findBlock(GalacticraftCore.ID, "tile.moonBlock"), 4); + } + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(28, "Moon")); // Moon Dim + }), + MARS(GTBranchDefinition.PLANET, "Mars", false, new Color(0x220D05), new Color(0x3A1505), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.MARS), 0.35f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MarsStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(MOON, IRON, 20); + if (GalacticraftMars.isModLoaded()) { + tMutation.requireResource(GameRegistry.findBlock(GalacticraftMars.ID, "tile.mars"), 5); + } + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(29, "Mars")); // Mars Dim + }), + PHOBOS(GTBranchDefinition.PLANET, "Phobos", true, new Color(0x220D05), new Color(0x7a5706), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.MARS), 0.25f); + if (NewHorizonsCoreMod.isModLoaded()) beeSpecies + .addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.PhobosStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + beeSpecies.setNocturnal(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(MARS, MOON, 20); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "phobosblocks"), 2); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(38, "Phobos")); // Phobos Dim + }), + DEIMOS(GTBranchDefinition.PLANET, "Deimos", true, new Color(0x220D05), new Color(0x7a3206), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.MARS), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.DeimosStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(HOT); + beeSpecies.setNocturnal(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(MARS, SPACE, 20); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "deimosblocks"), 1); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(40, "Deimos")); // Deimos Dim + }), + CERES(GTBranchDefinition.PLANET, "Ceres", true, new Color(0x3ca5b7), new Color(0x1e7267), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.JUPITER), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CeresStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + beeSpecies.setNocturnal(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(MARS, METEORICIRON, 20); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "ceresblocks"), 1); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(42, "Ceres")); // Ceres Dim + }), + JUPITER(GTBranchDefinition.PLANET, "Jupiter", false, new Color(0x734B2E), new Color(0xD0CBC4), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.JUPITER), 0.35f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CallistoStoneDust", 1, 0), 0.05f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CallistoIceDust", 1, 0), 0.05f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.IoStoneDust", 1, 0), 0.05f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EuropaStoneDust", 1, 0), 0.05f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EuropaIceDust", 1, 0), 0.05f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.GanymedeStoneDust", 1, 0), 0.05f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(MARS, DESH, 15); + if (NewHorizonsCoreMod.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.Ledox"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(30, "Asteroids")); // Asteroid Dim + }), + IO(GTBranchDefinition.PLANET, "IO", true, new Color(0x734B2E), new Color(0xe5701b), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.JUPITER), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.IoStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, getSpecies(EXTRABEES, "volcanic"), 15); + tMutation.restrictTemperature(HELLISH); + if (GalaxySpace.isModLoaded()) tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "ioblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(36, "IO")); // IO Dim + }), + EUROPA(GTBranchDefinition.PLANET, "Europa", true, new Color(0x5982ea), new Color(0x0b36a3), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.JUPITER), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EuropaStoneDust", 1, 0), 0.10f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EuropaIceDust", 1, 0), 0.10f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, IRON, 15); + tMutation.restrictTemperature(ICY); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "europagrunt"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(35, "Europa")); // Europa Dim + }), + GANYMEDE(GTBranchDefinition.PLANET, "Ganymede", true, new Color(0x3d1b10), new Color(0x190c07), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.JUPITER), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.GanymedeStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(COLD); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, TITANIUM, 15); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "ganymedeblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(43, "Ganymede")); // Ganymede Dim + }), + CALLISTO(GTBranchDefinition.PLANET, "Callisto", true, new Color(0x0f333d), new Color(0x0d84a5), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.JUPITER), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CallistoStoneDust", 1, 0), 0.10f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CallistoIceDust", 1, 0), 0.10f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, getSpecies(EXTRABEES, "artic"), 15); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "callistoblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(45, "Callisto")); // Callisto Dim + }), + SATURN(GTBranchDefinition.PLANET, "Saturn", false, new Color(0xD2A472), new Color(0xF8C37B), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SATURN), 0.35f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TitanStoneDust", 1, 0), 0.05f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EnceladusStoneDust", 1, 0), 0.05f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EnceladusIceDust", 1, 0), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(COLD); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, LEDOX, 25, 2); + if (NewHorizonsCoreMod.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.Quantinum"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(30, "Asteriods")); // Asteriods Dim + }), + ENCELADUS(GTBranchDefinition.PLANET, "Enceladus", true, new Color(0xD2A472), new Color(0x193fa0), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SATURN), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EnceladusStoneDust", 1, 0), 0.10f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EnceladusIceDust", 1, 0), 0.10f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(SATURN, CHROME, 25, 2); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "enceladusblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(41, "Enceladus")); // Enceladus Dim + }), + TITAN(GTBranchDefinition.PLANET, "Titan", true, new Color(0xa0641b), new Color(0x7c1024), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SATURN), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TitanStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(SATURN, NICKEL, 25, 2); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "titanblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(44, "Titan")); // Titan Dim + }), + URANUS(GTBranchDefinition.PLANET, "Uranus", false, new Color(0x75C0C9), new Color(0x84D8EC), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.URANUS), 0.35f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MirandaStoneDust", 1, 0), 0.05f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.OberonStoneDust", 1, 0), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(SATURN, TRINIUM, 10); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "metalsblock"), 6); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(30, "Asteroids")); // Asteroids Dim + }), + MIRANDA(GTBranchDefinition.PLANET, "Miranda", true, new Color(0x75C0C9), new Color(0x0d211c), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.URANUS), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MirandaStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(URANUS, TIN, 10); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "mirandablocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(86, "Miranda")); // Miranda Dim + }), + OBERON(GTBranchDefinition.PLANET, "Oberon", true, new Color(0x4A4033), new Color(0xB5A288), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.URANUS), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.OberonStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(ICY); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(URANUS, IRIDIUM, 10); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "oberonblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(46, "Oberon")); // Oberon Dim + }), + NEPTUNE(GTBranchDefinition.PLANET, "Neptune", false, new Color(0x334CFF), new Color(0x576DFF), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.NEPTUNE), 0.35f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.ProteusStoneDust", 1, 0), 0.05f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TritonStoneDust", 1, 0), 0.05f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(COLD); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(URANUS, ORIHARUKON, 7); + if (NewHorizonsCoreMod.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.MysteriousCrystal"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(30, "Asteroids")); // Asteroids Dim + }), + PROTEUS(GTBranchDefinition.PLANET, "Proteus", true, new Color(0x334CFF), new Color(0x592610), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.NEPTUNE), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.ProteusStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(COLD); + beeSpecies.setNocturnal(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(NEPTUNE, COPPER, 7); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "proteusblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(47, "Proteus")); // Proteus Dim + }), + TRITON(GTBranchDefinition.PLANET, "Triton", true, new Color(0x334CFF), new Color(0x421118), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.NEPTUNE), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TritonStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(NEPTUNE, GOLD, 7); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "tritonblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(48, "Triton")); // Triton Dim + }), + PLUTO(GTBranchDefinition.PLANET, "Pluto", false, new Color(0x34271E), new Color(0x69503D), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.PLUTO), 0.35f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.PlutoStoneDust", 1, 0), 0.10f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.PlutoIceDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(NEPTUNE, PLUTONIUM, 5); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "plutoblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(49, "Pluto")); // Pluto Dim + }), + HAUMEA(GTBranchDefinition.PLANET, "Haumea", false, new Color(0x1C1413), new Color(0x392B28), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.HAUMEA), 0.35f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.HaumeaStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(ICY); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(PLUTO, NAQUADAH, 7, 2); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "haumeablocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(83, "Haumea")); // Haumea Dim + }), + MAKEMAKE(GTBranchDefinition.PLANET, "MakeMake", false, new Color(0x301811), new Color(0x120A07), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.MAKEMAKE), 0.35f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MakeMakeStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(PLUTO, NAQUADRIA, 7, 2); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "makemakegrunt"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(25, "MakeMake")); // MakeMake Dim + }), + CENTAURI(GTBranchDefinition.PLANET, "Centauri", false, new Color(0x2F2A14), new Color(0xB06B32), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.CENTAURI), 0.35f); + beeSpecies + .addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CentauriASurfaceDust", 1, 0), 0.05f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(MAKEMAKE, DESH, 3); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "acentauribbgrunt"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(33, "Kuiper Belt")); // Kuiper Belt Dim + }), + ACENTAURI(GTBranchDefinition.PLANET, "aCentauri", false, new Color(0x2F2A14), new Color(0xa01e14), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.CENTAURI), 0.25f); + beeSpecies + .addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CentauriASurfaceDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), new Consumer<>() { + + @Override + public void accept(GTBeeDefinition dis) { + IBeeMutationCustom tMutation = dis.registerMutation(CENTAURI, INFINITYCATALYST, 3); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "acentauribbgrunt"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(31, "aCentauri")); // aCentauri Dim + } + }), + TCETI(GTBranchDefinition.PLANET, "tCeti", false, new Color(0x46241A), new Color(0x7B412F), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.TCETI), 0.35f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TCetiEStoneDust", 1, 0), 0.05f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(MAKEMAKE, HAUMEA, 5, 2); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "tcetieblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(33, "Kuiper Belt")); // Kuiper Belt Dim + }), + TCETIE(GTBranchDefinition.PLANET, "tCetiE", false, new Color(0x2d561b), new Color(0x0c0f60), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.TCETI), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TCetiEStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(TCETI, getSpecies(MAGICBEES, "TCWater"), 5, 2); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "tcetieblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(85, "tCeti E")); // tCeti E Dim + }), + // Parents: TCETI and TCETIE, 25% combchance, needs Damp Humidity and Normal temperature. Is Mycophilic + SEAWEED(GTBranchDefinition.PLANET, "SeaWeed", true, new Color(0xCBCBCB), new Color(0x83FF83), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.SEAWEED), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TCetiEStoneDust", 1, 0), 0.15f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(EnumTemperature.NORMAL); + beeSpecies.setHasEffect(); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_1); + AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.DOWN_1); + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectMycophilic); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(TCETI, TCETIE, 5, 2); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "tcetieblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(85, "tCeti E")); // tCeti E Dim + }), + + BARNARDA(GTBranchDefinition.PLANET, "Barnarda", false, new Color(0x0D5A0D), new Color(0xE6C18D), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.BARNARDA), 0.35f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.BarnardaEStoneDust", 1, 0), 0.05f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.BarnardaFStoneDust", 1, 0), 0.05f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(MAKEMAKE, THORIUM, 3, 2); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "barnardaEgrunt"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(33, "Kuiper Belt")); // Kuiper Belt Dim + }), + BARNARDAC(GTBranchDefinition.PLANET, "BarnardaC", false, new Color(0x0D5A0D), new Color(0x473f0a), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.BARNARDA), 0.25f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + }, template -> { + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + AlleleHelper.instance.set(template, EFFECT, getEffect(GREGTECH, "Treetwister")); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(BARNARDA, AMERICIUM, 3, 2); + if (GalaxySpace.isModLoaded()) { + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "barnardaEgrunt"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(32, "Barnarda C")); // Barnarda C Dim + } + }), + BARNARDAE(GTBranchDefinition.PLANET, "BarnardaE", false, new Color(0x0D5A0D), new Color(0x4c1f0a), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.BARNARDA), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.BarnardaEStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(BARNARDA, DIVIDED, 3, 2); + if (GalaxySpace.isModLoaded()) { + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "barnardaEgrunt"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(81, "Barnard E")); // "Barnard E Dim + } + }), + BARNARDAF(GTBranchDefinition.PLANET, "BarnardaF", false, new Color(0x0D5A0D), new Color(0x1e0b49), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.BARNARDA), 0.25f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.BarnardaFStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(BARNARDA, NEUTRONIUM, 3, 2); + if (GalaxySpace.isModLoaded()) { + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "barnardaFgrunt"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(82, "Barnard F")); // "Barnard F Dim + } + }), + VEGA(GTBranchDefinition.PLANET, "Vega", false, new Color(0x1A2036), new Color(0xB5C0DE), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.VEGA), 0.35f); + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.VegaBStoneDust", 1, 0), 0.05f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(COLD); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(MAKEMAKE, NAQUADAH, 2); + if (GalaxySpace.isModLoaded()) { + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "vegabgrunt"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(33, "Kuiper Belt")); // Kuiper Belt + // Dim + } + }), + VEGAB(GTBranchDefinition.PLANET, "VegaB", false, new Color(0x1A2036), new Color(0x81e261), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.VEGA), 0.35f); + if (NewHorizonsCoreMod.isModLoaded()) + beeSpecies.addSpecialty(GTModHandler.getModItem(NewHorizonsCoreMod.ID, "item.VegaBStoneDust", 1, 0), 0.10f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(COLD); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(VEGA, NAQUADRIA, 2); + if (GalaxySpace.isModLoaded()) { + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "vegabgrunt"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(84, "VegaB")); // VegaB Dim + } + }), + MERCURY(GTBranchDefinition.PLANET, "Mercury", false, new Color(0x4A4033), new Color(0xB5A288), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.MERCURY), 0.35f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, TUNGSTEN, 25, 2); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "mercuryblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(37, "Mercury")); // Mercury Dim + }), + VENUS(GTBranchDefinition.PLANET, "Venus", false, new Color(0x4A4033), new Color(0xB5A288), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.VENUS), 0.35f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, MITHRIL, 25, 2); + if (GalaxySpace.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "venusblocks"), 0); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(39, "Venus")); // Venus Dim + }), + + // Infinity Line + COSMICNEUTRONIUM(GTBranchDefinition.PLANET, "CosmicNeutronium", false, new Color(0x484848), new Color(0x323232), + beeSpecies -> { + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.COSMICNEUTRONIUM), 0.375f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + // Makes it only work in the Mega Apiary NOTE: COMB MUST BE SPECIALITY COMB + beeSpecies.setJubilanceProvider(JubilanceMegaApiary.instance); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(NEUTRONIUM, BARNARDAF, 7, 10); + if (Avaritia.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(Avaritia.ID, "Resource_Block"), 0); + }), + INFINITYCATALYST(GTBranchDefinition.PLANET, "InfinityCatalyst", false, new Color(0xFFFFFF), new Color(0xFFFFFF), + beeSpecies -> { + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.INFINITYCATALYST), 0.015f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(HELLISH); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + // Makes it only work in the Mega Apiary NOTE: COMB MUST BE SPECIALITY COMB + beeSpecies.setJubilanceProvider(JubilanceMegaApiary.instance); + }, template -> { + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); + AlleleHelper.instance.set(template, EFFECT, getEffect(EXTRABEES, "blindness")); + }, dis -> { + IMutationCustom tMutation = dis.registerMutation(DOB, COSMICNEUTRONIUM, 3, 10) + .setIsSecret(); + if (Avaritia.isModLoaded()) { + tMutation.requireResource(GameRegistry.findBlock(Avaritia.ID, "Resource_Block"), 1); + } + }), + INFINITY(GTBranchDefinition.PLANET, "Infinity", false, new Color(0xFFFFFF), new Color(0xFFFFFF), beeSpecies -> { + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.INFINITY), 0.015f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + // Makes it only work in the Mega Apiary NOTE: COMB MUST BE SPECIALITY COMB + beeSpecies.setJubilanceProvider(JubilanceMegaApiary.instance); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(INFINITYCATALYST, COSMICNEUTRONIUM, 1, 10); + if (AvaritiaAddons.isModLoaded()) { + tMutation.requireResource(GameRegistry.findBlock(AvaritiaAddons.ID, "InfinityChest"), 0); + } + }), + KEVLAR(GTBranchDefinition.IC2, "Kevlar", false, new Color(0x2d542f), new Color(0xa2baa3), beeSpecies -> { + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.KEVLAR), 0.075f); + beeSpecies.addSpecialty(MaterialsKevlar.Kevlar.getNuggets(1), 0.01f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setTemperature(COLD); + beeSpecies.setHasEffect(); + beeSpecies.setJubilanceProvider(JubilanceMegaApiary.instance); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectSnowing); + AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(template, NOCTURNAL, true); + AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.SNOW); + AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(OIL, INFINITYCATALYST, 4); + // UHV Replicator (UU-Matter) + GregTechAPI.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTechAPI.sBlockMachines, 11003)); + }), + + // Noble Gas Line + // Helium bee, Humidity: normal, Temperature: Icy, Parents: Space & Mars, Mutationrate: 10%, Combrate: 50% + HELIUM(GTBranchDefinition.NOBLEGAS, "Helium", false, new Color(0xFFA9FF), new Color(0xC8B8B4), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.HELIUM), 0.35f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(MAGICBEES, "Watery"), ENDDUST, 10); + tMutation.restrictTemperature(ICY); + }), + // Argon bee, Humidity: normal, Temperature: Icy, Parents: Helium & Phobos, Mutationrate: 8%, Combrate: 50% + ARGON(GTBranchDefinition.NOBLEGAS, "Argon", false, new Color(0x89D9E1), new Color(0xBDA5C2), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.ARGON), 0.35f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(HELIUM, LICH, 8); + tMutation.restrictTemperature(ICY); + }), + // Neon bee, Humidity: normal, Temperature: Icy, Parents: Xenon & Ceres, Mutationrate: 6%, Combrate: 50% + NEON(GTBranchDefinition.NOBLEGAS, "Neon", false, new Color(0xFFC826), new Color(0xFF7200), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.NEON), 0.35f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(ARGON, HYDRA, 6); + tMutation.restrictTemperature(ICY); + }), + // Krypton bee, Humidity: normal, Temperature: Icy, Parents: Neon & Jupiter, Mutationrate: 4%, Combrate: 50% + KRYPTON(GTBranchDefinition.NOBLEGAS, "Krypton", false, new Color(0x8A97B0), new Color(0x160822), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.KRYPTON), 0.35f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(NEON, URGHAST, 4); + tMutation.restrictTemperature(ICY); + }), + // Xenon bee, Humidity: normal, Temperature: Icy, Parents: Argon & Deimos, Mutationrate: 6%, Combrate: 50% + XENON(GTBranchDefinition.NOBLEGAS, "Xenon", false, new Color(0x8A97B0), new Color(0x160822), beeSpecies -> { + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.XENON), 0.525f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + // Makes it only work in the Mega Apiary NOTE: COMB MUST BE SPECIALITY COMB + beeSpecies.setJubilanceProvider(JubilanceMegaApiary.instance); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(KRYPTON, SNOWQUEEN, 2); + tMutation.restrictTemperature(ICY); + }), + // Oxygen bee, Humidity: normal, Temperature: Icy, Parents: Space & Callisto, Mutationrate: 15%, Combrate: 50% + OXYGEN(GTBranchDefinition.NOBLEGAS, "Oxygen", false, new Color(0xFFFFFF), new Color(0x8F8FFF), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.OXYGEN), 0.45f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.HYDROGEN), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(HELIUM, DRAGONESSENCE, 15); + tMutation.restrictTemperature(ICY); + }), + // Hydrogen bee, Humidity: normal, Temperature: Icy, Parents: Oxygen & Watery, Mutationrate: 15%, Combrate: 50% + HYDROGEN(GTBranchDefinition.NOBLEGAS, "Oxygen", false, new Color(0xFFFFFF), new Color(0xFF1493), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.HYDROGEN), 0.45f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.NITROGEN), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(OXYGEN, getSpecies(MAGICBEES, "Watery"), 15); + tMutation.restrictTemperature(ICY); + }), + // Nitrogen bee, Humidity: normal, Temperature: Icy, Parents: Oxygen & Hydrogen, Mutationrate: 15%, Combrate: 50% + NITROGEN(GTBranchDefinition.NOBLEGAS, "Nitrogen", false, new Color(0xFFC832), new Color(0xA52A2A), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.NITROGEN), 0.45f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.FLUORINE), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(OXYGEN, HYDROGEN, 15); + tMutation.restrictTemperature(ICY); + }), + // Fluorine bee, Humidity: normal, Temperature: Icy, Parents: Nitrogen & Hydrogen, Mutationrate: 15%, Combrate: 50% + FLUORINE(GTBranchDefinition.NOBLEGAS, "Fluorine", false, new Color(0x86AFF0), new Color(0xFF6D00), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.FLUORINE), 0.45f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.OXYGEN), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(ICY); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(NITROGEN, HYDROGEN, 15); + tMutation.restrictTemperature(ICY); + }), + // Europium line, needed after fluorine definition + RAREEARTH(GTBranchDefinition.RAREMETAL, "RareEarth", false, new Color(0x555643), new Color(0x343428), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.RAREEARTH), 0.20f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.NEODYMIUM), 0.05f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(NORMAL); + }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST), + dis -> dis.registerMutation(FLUORINE, REDSTONE, 10)), + NEODYMIUM(GTBranchDefinition.RAREMETAL, "Neodymium", false, new Color(0x555555), new Color(0x4F4F4F), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.RAREEARTH), 0.15f); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.NEODYMIUM), 0.15f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(HOT); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(RAREEARTH, IRON, 10); + tMutation.requireResource(GregTechAPI.sBlockMetal5, 0); + }), + EUROPIUM(GTBranchDefinition.RAREMETAL, "Europium", false, new Color(0xDAA0E2), new Color(0xAB7EB1), beeSpecies -> { + beeSpecies.addProduct(WerkstoffMaterialPool.EuropiumIIIOxide.get(OrePrefixes.dust, 1), 0.10F); + beeSpecies.addSpecialty(GTBees.combs.getStackForType(CombType.EUROPIUM), 0.075f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setTemperature(HOT); + beeSpecies.setNocturnal(); + // Makes it only work in the Mega Apiary NOTE: COMB MUST BE SPECIALITY COMB + beeSpecies.setJubilanceProvider(JubilanceMegaApiary.instance); + }, template -> { + AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); + }, dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(NEODYMIUM, HYDROGEN, 5, 4); + // Compact fusion reactor mark 1 controller + GregTechAPI.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTechAPI.sBlockMachines, 32019)); + }), + // infused Shards line + AIR(GTBranchDefinition.INFUSEDSHARD, "Air", false, new Color(0xFFFF7E), new Color(0x60602F), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.INFUSEDAER), 0.30f); + beeSpecies.setHumidity(DAMP); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis + .registerMutation(getSpecies(MAGICBEES, "Supernatural"), getSpecies(MAGICBEES, "Windy"), 15); + tMutation.restrictTemperature(HOT); + if (Thaumcraft.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 0); + }), + FIRE(GTBranchDefinition.INFUSEDSHARD, "Fire", false, new Color(0xED3801), new Color(0x3B0E00), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.INFUSEDIGNIS), 0.30f); + beeSpecies.setHumidity(ARID); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(MAGICBEES, "Supernatural"), AIR, 15); + tMutation.restrictTemperature(HELLISH); + if (Thaumcraft.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 1); + }), + WATER(GTBranchDefinition.INFUSEDSHARD, "Water", false, new Color(0x0090FF), new Color(0x002542), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.INFUSEDAQUA), 0.30f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(FIRE, AIR, 15); + tMutation.restrictTemperature(ICY); + if (Thaumcraft.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 2); + }), + EARTH(GTBranchDefinition.INFUSEDSHARD, "Earth", false, new Color(0x008600), new Color(0x003300), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.INFUSEDTERRA), 0.30f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(WATER, FIRE, 15); + tMutation.restrictTemperature(WARM); + if (Thaumcraft.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 3); + }), + ORDER(GTBranchDefinition.INFUSEDSHARD, "Order", false, new Color(0x8A97B0), new Color(0x5C5F62), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.INFUSEDORDO), 0.30f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(EARTH, FIRE, 15); + tMutation.restrictTemperature(ICY); + if (Thaumcraft.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 4); + }), + CHAOS(GTBranchDefinition.INFUSEDSHARD, "Chaos", false, new Color(0x2E2E41), new Color(0x232129), beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.INFUSEDPERDITIO), 0.30f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(ORDER, FIRE, 15); + tMutation.restrictTemperature(ICY); + if (Thaumcraft.isModLoaded()) + tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 5); + }), + NETHERSHARD(GTBranchDefinition.INFUSEDSHARD, "NetherShard", false, new Color(0xBE0135), new Color(0x350211), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.NETHERSHARD), 0.30f); + beeSpecies.setHumidity(ARID); + beeSpecies.setTemperature(HOT); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(CHAOS, FIRE, 15); + GregTechAPI.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTechAPI.sBlockGem3, 3)); + }), + ENDSHARD(GTBranchDefinition.INFUSEDSHARD, "EnderShard", false, new Color(0x2E2E41), new Color(0x232129), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.ENDERSHARD), 0.30f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(NETHERSHARD, ENDDUST, 15); + tMutation.restrictTemperature(ICY); + GregTechAPI.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTechAPI.sBlockGem1, 7)); + }), + // Organic branch 2.0 + UNKNOWNWATER(GTBranchDefinition.ORGANIC, "UnknownLiquid", false, new Color(0x4333A5), new Color(0x36ABFF), + beeSpecies -> { + beeSpecies.addProduct(GTBees.combs.getStackForType(CombType.UNKNOWNLIQUID), 0.20f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), + dis -> dis.registerMutation(INFINITYCATALYST, MYSTERIOUSCRYSTAL, 5)), + // Endgame bees + JAEGERMEISTER(GTBranchDefinition.ENDGAME, "JaegerMeister", false, new Color(0x05AD18), new Color(0xE7DAC3), + beeSpecies -> { + beeSpecies.addProduct(GTModHandler.getModItem(CropsPlusPlus.ID, "BppPotions", 1L, 8), 0.01f); + beeSpecies.setHumidity(EnumHumidity.NORMAL); + beeSpecies.setNocturnal(); + beeSpecies.setHasEffect(); + }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { + IBeeMutationCustom tMutation = dis.registerMutation(INFINITYCATALYST, NAQUADRIA, 5); + tMutation.requireResource(GregTechAPI.sBlockMachines, 4684); + tMutation.addMutationCondition(new GTBees.DimensionMutationCondition(100, "Deep Dark")); // Deep Dark + // dim + }); + + private final GTBranchDefinition branch; + private final GTAlleleBeeSpecies species; + private final Consumer mSpeciesProperties; + private final Consumer mAlleles; + private final Consumer mMutations; + private IAllele[] template; + private IBeeGenome genome; + + GTBeeDefinition(GTBranchDefinition branch, String binomial, boolean dominant, Color primary, Color secondary, + Consumer aSpeciesProperties, Consumer aAlleles, + Consumer aMutations) { + this.mAlleles = aAlleles; + this.mMutations = aMutations; + this.mSpeciesProperties = aSpeciesProperties; + String lowercaseName = this.toString() + .toLowerCase(Locale.ENGLISH); + String species = WordUtils.capitalize(lowercaseName); + + String uid = "gregtech.bee.species" + species; + String description = "for.description." + lowercaseName; + String name = "for.bees.species." + lowercaseName; + GTLanguageManager.addStringLocalization("for.bees.species." + lowercaseName, species); + + String authority = GTLanguageManager.getTranslation("for.bees.authority." + lowercaseName); + if (authority.equals("for.bees.authority." + lowercaseName)) { + authority = "GTNH"; + } + this.branch = branch; + this.species = new GTAlleleBeeSpecies( + uid, + dominant, + name, + authority, + description, + branch.getBranch(), + binomial, + primary, + secondary); + } + + public static void initBees() { + for (GTBeeDefinition bee : values()) { + bee.init(); + } + for (GTBeeDefinition bee : values()) { + bee.registerMutations(); + } + } + + static IAlleleBeeEffect getEffect(byte modid, String name) { + String s = switch (modid) { + case EXTRABEES -> "extrabees.effect." + name; + case GENDUSTRY -> "gendustry.effect." + name; + case MAGICBEES -> "magicbees.effect" + name; + case GREGTECH -> "gregtech.effect" + name; + default -> "forestry.effect" + name; + }; + return (IAlleleBeeEffect) AlleleManager.alleleRegistry.getAllele(s); + } + + static IAlleleFlowers getFlowers(byte modid, String name) { + String s = switch (modid) { + case EXTRABEES -> "extrabees.flower." + name; + case GENDUSTRY -> "gendustry.flower." + name; + case MAGICBEES -> "magicbees.flower" + name; + case GREGTECH -> "gregtech.flower" + name; + default -> "forestry.flowers" + name; + }; + return (IAlleleFlowers) AlleleManager.alleleRegistry.getAllele(s); + } + + private static IAlleleBeeSpecies getSpecies(byte modid, String name) { + String s = switch (modid) { + case EXTRABEES -> "extrabees.species." + name; + case GENDUSTRY -> "gendustry.bee." + name; + case MAGICBEES -> "magicbees.species" + name; + case GREGTECH -> "gregtech.species" + name; + default -> "forestry.species" + name; + }; + IAlleleBeeSpecies ret = (IAlleleBeeSpecies) AlleleManager.alleleRegistry.getAllele(s); + if (ret == null) { + ret = NAQUADRIA.species; + } + + return ret; + } + + private void setSpeciesProperties(GTAlleleBeeSpecies beeSpecies) { + this.mSpeciesProperties.accept(beeSpecies); + } + + private void setAlleles(IAllele[] template) { + this.mAlleles.accept(template); + } + + private void registerMutations() { + this.mMutations.accept(this); + } + + private void init() { + setSpeciesProperties(species); + + template = branch.getTemplate(); + AlleleHelper.instance.set(template, SPECIES, species); + setAlleles(template); + + genome = BeeManager.beeRoot.templateAsGenome(template); + + BeeManager.beeRoot.registerTemplate(template); + } + + private IBeeMutationCustom registerMutation(IAlleleBeeSpecies parent1, IAlleleBeeSpecies parent2, int chance) { + return registerMutation(parent1, parent2, chance, 1f); + } + + private IBeeMutationCustom registerMutation(GTBeeDefinition parent1, IAlleleBeeSpecies parent2, int chance) { + return registerMutation(parent1, parent2, chance, 1f); + } + + private IBeeMutationCustom registerMutation(IAlleleBeeSpecies parent1, GTBeeDefinition parent2, int chance) { + return registerMutation(parent1, parent2, chance, 1f); + } + + private IBeeMutationCustom registerMutation(GTBeeDefinition parent1, GTBeeDefinition parent2, int chance) { + return registerMutation(parent1, parent2, chance, 1f); + } + + /** + * Diese neue Funtion erlaubt Mutationsraten unter 1%. Setze dazu die Mutationsrate als Bruch mit chance / + * chanceDivider This new function allows Mutation percentages under 1%. Set them as a fraction with chance / + * chanceDivider + */ + private IBeeMutationCustom registerMutation(IAlleleBeeSpecies parent1, IAlleleBeeSpecies parent2, int chance, + float chanceDivider) { + return new GTBeeMutation(parent1, parent2, this.getTemplate(), chance, chanceDivider); + } + + private IBeeMutationCustom registerMutation(GTBeeDefinition parent1, IAlleleBeeSpecies parent2, int chance, + float chanceDivider) { + return registerMutation(parent1.species, parent2, chance, chanceDivider); + } + + private IBeeMutationCustom registerMutation(IAlleleBeeSpecies parent1, GTBeeDefinition parent2, int chance, + float chanceDivider) { + return registerMutation(parent1, parent2.species, chance, chanceDivider); + } + + private IBeeMutationCustom registerMutation(GTBeeDefinition parent1, GTBeeDefinition parent2, int chance, + float chanceDivider) { + return registerMutation(parent1.species, parent2, chance, chanceDivider); + } + + @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) { + return BeeManager.beeRoot.getMemberStack(getIndividual(), beeType.ordinal()); + } +} diff --git a/src/main/java/gregtech/loaders/misc/GTBees.java b/src/main/java/gregtech/loaders/misc/GTBees.java new file mode 100644 index 0000000000..02fb6d19e5 --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/GTBees.java @@ -0,0 +1,231 @@ +package gregtech.loaders.misc; + +import static gregtech.api.enums.Mods.Forestry; +import static gregtech.api.enums.Mods.GalaxySpace; +import static gregtech.api.enums.Mods.TwilightForest; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraft.world.biome.BiomeGenBase; + +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.apiculture.IAlleleBeeEffect; +import forestry.api.core.IClimateProvider; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IAlleleArea; +import forestry.api.genetics.IAlleleFloat; +import forestry.api.genetics.IAlleleInteger; +import forestry.api.genetics.IGenome; +import forestry.api.genetics.IMutationCondition; +import forestry.core.genetics.alleles.Allele; +import forestry.core.utils.StringUtil; +import gregtech.GTMod; +import gregtech.api.metatileentity.BaseMetaTileEntity; +import gregtech.common.bees.GTAlleleHelper; +import gregtech.common.items.ItemComb; +import gregtech.common.items.ItemDrop; +import gregtech.common.items.ItemPollen; +import gregtech.common.items.ItemPropolis; +import gregtech.loaders.misc.bees.GTAlleleEffect; +import gregtech.loaders.misc.bees.GTEffectMachineBoost; +import gregtech.loaders.misc.bees.GTEffectTreeTwister; +import gregtech.loaders.misc.bees.GTFlowers; + +public class GTBees { + + public static IAlleleInteger noFertility; + public static IAlleleInteger superFertility; + + public static IAlleleInteger noFlowering; + public static IAlleleInteger superFlowering; + + public static IAlleleArea noTerritory; + public static IAlleleArea superTerritory; + + public static IAlleleFloat noWork; + public static IAlleleFloat speedBlinding; + public static IAlleleFloat superSpeed; + + public static IAlleleInteger blinkLife; + public static IAlleleInteger superLife; + + public static IAlleleBeeEffect treetwisterEffect; + public static IAlleleBeeEffect machineBoostEffect; + + public static ItemPropolis propolis; + public static ItemPollen pollen; + public static ItemDrop drop; + public static ItemComb combs; + + public GTBees() { + if (!(Forestry.isModLoaded() && GTMod.gregtechproxy.mGTBees)) { + return; + } + GTFlowers.doInit(); + GTAlleleHelper.initialisation(); + setupGTAlleles(); + propolis = new ItemPropolis(); + propolis.initPropolisRecipes(); + pollen = new ItemPollen(); + drop = new ItemDrop(); + drop.initDropsRecipes(); + combs = new ItemComb(); + combs.initCombsRecipes(); + combs.registerOreDict(); + GTBeeDefinition.initBees(); + + } + + private static void setupGTAlleles() { + + noFertility = new AlleleInteger("fertilitySterile", 0, false, EnumBeeChromosome.FERTILITY); + superFertility = new AlleleInteger("fertilityMultiply", 8, false, EnumBeeChromosome.FERTILITY); + + noFlowering = new AlleleInteger("floweringNonpollinating", 0, false, EnumBeeChromosome.FLOWERING); + superFlowering = new AlleleInteger("floweringNaturalistic", 240, false, EnumBeeChromosome.FLOWERING); + + noTerritory = new AlleleArea("areaLethargic", 1, 1, false); + superTerritory = new AlleleArea("areaExploratory", 32, 16, false); + + noWork = new AlleleFloat("speedUnproductive", 0, false); + superSpeed = new AlleleFloat("speedAccelerated", 4F, false); + speedBlinding = AlleleManager.alleleRegistry.getAllele("magicbees.speedBlinding") == null + ? new AlleleFloat("speedBlinding", 2f, false) + : (IAlleleFloat) AlleleManager.alleleRegistry.getAllele("magicbees.speedBlinding"); + + blinkLife = new AlleleInteger("lifeBlink", 2, false, EnumBeeChromosome.LIFESPAN); + superLife = new AlleleInteger("lifeEon", 600, false, EnumBeeChromosome.LIFESPAN); + machineBoostEffect = new GTEffectMachineBoost(); + + if (GalaxySpace.isModLoaded() && TwilightForest.isModLoaded()) { + GTMod.GT_FML_LOGGER.info("treetwisterEffect: GalaxySpace and TwilightForest loaded, using default impl"); + treetwisterEffect = new GTEffectTreeTwister(); + } else { + GTMod.GT_FML_LOGGER + .info("treetwisterEffect: GalaxySpace or TwilightForest was not loaded, using fallback impl"); + treetwisterEffect = GTAlleleEffect.FORESTRY_BASE_EFFECT; + } + } + + private static class AlleleFloat extends Allele implements IAlleleFloat { + + private final float value; + + public AlleleFloat(String id, float val, boolean isDominant) { + super("gregtech." + id, "gregtech." + id, isDominant); + this.value = val; + AlleleManager.alleleRegistry.registerAllele(this, EnumBeeChromosome.SPEED); + } + + @Override + public float getValue() { + return this.value; + } + } + + private static class AlleleInteger extends Allele implements IAlleleInteger { + + private final int value; + + public AlleleInteger(String id, int val, boolean isDominant, EnumBeeChromosome c) { + super("gregtech." + id, "gregtech." + id, isDominant); + this.value = val; + AlleleManager.alleleRegistry.registerAllele(this, c); + } + + @Override + public int getValue() { + return this.value; + } + } + + private static class AlleleArea extends Allele implements IAlleleArea { + + private final int[] value; + + public AlleleArea(String id, int rangeXZ, int rangeY, boolean isDominant) { + super("gregtech." + id, "gregtech." + id, isDominant); + this.value = new int[] { rangeXZ, rangeY, rangeXZ }; + AlleleManager.alleleRegistry.registerAllele(this, EnumBeeChromosome.TERRITORY); + } + + @Override + public int[] getValue() { + return this.value; + } + } + + public static class DimensionMutationCondition implements IMutationCondition { + + final int dimID; + final String dimName; + + public DimensionMutationCondition(int id, String name) { + dimID = id; + dimName = name; + } + + @Override + public float getChance(World world, int x, int y, int z, IAllele allele0, IAllele allele1, IGenome genome0, + IGenome genome1, IClimateProvider climate) { + if (world.provider.dimensionId == dimID) return 1; + return 0; + } + + @Override + public String getDescription() { + return StringUtil.localizeAndFormat("mutation.condition.dim") + " " + dimName; + } + } + + public static class BiomeIDMutationCondition implements IMutationCondition { + + final int biomeID; + final String biomeName; + + public BiomeIDMutationCondition(int id, String name) { + biomeID = id; + biomeName = name; + } + + @Override + public float getChance(World world, int x, int y, int z, IAllele allele0, IAllele allele1, IGenome genome0, + IGenome genome1, IClimateProvider climate) { + if (climate.getBiome().biomeID == biomeID) return 1; + return 0; + } + + @Override + public String getDescription() { + if (BiomeGenBase.getBiome(biomeID) != null) { + return StringUtil.localizeAndFormat("mutation.condition.biomeid") + " " + biomeName; + } + return ""; + } + } + + public static class ActiveGTMachineMutationCondition implements IMutationCondition { + + public ActiveGTMachineMutationCondition() { + + } + + @Override + public float getChance(World world, int x, int y, int z, IAllele allele0, IAllele allele1, IGenome genome0, + IGenome genome1, IClimateProvider climate) { + TileEntity tileEntity = world.getTileEntity(x, y - 1, z); + if (tileEntity instanceof BaseMetaTileEntity machine) { + if (machine.isActive()) { + return 1; + } + } + return 0; + } + + @Override + public String getDescription() { + return "Needs a running GT Machine below to breed"; + } + } +} diff --git a/src/main/java/gregtech/loaders/misc/GTBranchDefinition.java b/src/main/java/gregtech/loaders/misc/GTBranchDefinition.java new file mode 100644 index 0000000000..9bc4acb114 --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/GTBranchDefinition.java @@ -0,0 +1,207 @@ +package gregtech.loaders.misc; + +import static forestry.api.apiculture.EnumBeeChromosome.CAVE_DWELLING; +import static forestry.api.apiculture.EnumBeeChromosome.EFFECT; +import static forestry.api.apiculture.EnumBeeChromosome.FERTILITY; +import static forestry.api.apiculture.EnumBeeChromosome.FLOWERING; +import static forestry.api.apiculture.EnumBeeChromosome.FLOWER_PROVIDER; +import static forestry.api.apiculture.EnumBeeChromosome.HUMIDITY_TOLERANCE; +import static forestry.api.apiculture.EnumBeeChromosome.LIFESPAN; +import static forestry.api.apiculture.EnumBeeChromosome.NOCTURNAL; +import static forestry.api.apiculture.EnumBeeChromosome.SPEED; +import static forestry.api.apiculture.EnumBeeChromosome.TEMPERATURE_TOLERANCE; +import static forestry.api.apiculture.EnumBeeChromosome.TERRITORY; +import static forestry.api.apiculture.EnumBeeChromosome.TOLERANT_FLYER; +import static forestry.core.genetics.alleles.EnumAllele.Fertility; +import static forestry.core.genetics.alleles.EnumAllele.Flowering; +import static forestry.core.genetics.alleles.EnumAllele.Flowers; +import static forestry.core.genetics.alleles.EnumAllele.Lifespan; +import static forestry.core.genetics.alleles.EnumAllele.Speed; +import static forestry.core.genetics.alleles.EnumAllele.Territory; +import static forestry.core.genetics.alleles.EnumAllele.Tolerance; +import static gregtech.loaders.misc.GTBeeDefinition.getEffect; +import static gregtech.loaders.misc.GTBeeDefinition.getFlowers; +import static gregtech.loaders.misc.GTBeeDefinitionReference.EXTRABEES; +import static gregtech.loaders.misc.GTBeeDefinitionReference.MAGICBEES; + +import java.util.Arrays; +import java.util.function.Consumer; + +import forestry.api.apiculture.BeeManager; +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IClassification; +import forestry.apiculture.genetics.alleles.AlleleEffect; +import forestry.core.genetics.alleles.AlleleHelper; + +public enum GTBranchDefinition { + + ORGANIC("Fuelis", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(alleles, HUMIDITY_TOLERANCE, Tolerance.BOTH_2); + AlleleHelper.instance.set(alleles, NOCTURNAL, false); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.WHEAT); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.SLOW); + AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.SHORTER); + AlleleHelper.instance.set(alleles, SPEED, Speed.SLOWEST); + }), + IC2("Industrialis", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.UP_1); + AlleleHelper.instance.set(alleles, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(alleles, NOCTURNAL, false); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.SNOW); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTER); + AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(alleles, SPEED, Speed.SLOW); + }), + GTALLOY("Amalgamis", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(alleles, TOLERANT_FLYER, true); + AlleleHelper.instance.set(alleles, NOCTURNAL, false); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.VANILLA); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.AVERAGE); + AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.SHORTEST); + AlleleHelper.instance.set(alleles, SPEED, Speed.FAST); + }), + THAUMIC("Arcanis", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(alleles, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, getFlowers(EXTRABEES, "book")); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTER); + AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.LONGEST); + }), + GEM("Ornamentis", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(alleles, NOCTURNAL, false); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.NETHER); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.AVERAGE); + }), + METAL("Metaliferis", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.DOWN_2); + AlleleHelper.instance.set(alleles, CAVE_DWELLING, true); + AlleleHelper.instance.set(alleles, NOCTURNAL, false); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.JUNGLE); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.SLOWER); + }), + RAREMETAL("Mineralis", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.DOWN_1); + AlleleHelper.instance.set(alleles, NOCTURNAL, false); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.CACTI); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FAST); + }), + RADIOACTIVE("Criticalis", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(alleles, NOCTURNAL, false); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.END); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.AVERAGE); + AlleleHelper.instance.set(alleles, SPEED, GTBees.speedBlinding); + AlleleHelper.instance.set(alleles, SPEED, getEffect(EXTRABEES, "radioactive")); + }), + TWILIGHT("Nemoris Obscuri", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(alleles, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(alleles, NOCTURNAL, false); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.VANILLA); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTER); + }), + HEE("Finis Expansiones", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_2); + AlleleHelper.instance.set(alleles, HUMIDITY_TOLERANCE, Tolerance.BOTH_2); + AlleleHelper.instance.set(alleles, NOCTURNAL, true); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, getFlowers(EXTRABEES, "book")); + AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.SHORT); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.SLOW); + AlleleHelper.instance.set(alleles, SPEED, Speed.FASTEST); + AlleleHelper.instance.set(alleles, TERRITORY, Territory.LARGER); + }), + SPACE("Cosmicis", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.DOWN_2); + AlleleHelper.instance.set(alleles, TOLERANT_FLYER, true); + AlleleHelper.instance.set(alleles, NOCTURNAL, true); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, getFlowers(EXTRABEES, "rock")); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTEST); + AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.LONGEST); + AlleleHelper.instance.set(alleles, SPEED, Speed.FAST); + AlleleHelper.instance.set(alleles, TERRITORY, Territory.LARGEST); + }), + PLANET("Planetaris", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(alleles, TOLERANT_FLYER, true); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, getFlowers(EXTRABEES, "rock")); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTEST); + AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.NORMAL); + AlleleHelper.instance.set(alleles, SPEED, Speed.FASTEST); + AlleleHelper.instance.set(alleles, TERRITORY, Territory.LARGER); + }), + NOBLEGAS("Nobilis Gasorum", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_2); + AlleleHelper.instance.set(alleles, TOLERANT_FLYER, true); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTEST); + AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.NORMAL); + AlleleHelper.instance.set(alleles, SPEED, Speed.FASTEST); + AlleleHelper.instance.set(alleles, TERRITORY, Territory.AVERAGE); + }), + INFUSEDSHARD("Infusa Shard", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); + AlleleHelper.instance.set(alleles, TOLERANT_FLYER, true); + AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, getFlowers(MAGICBEES, "rock")); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTEST); + AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.SHORTEST); + AlleleHelper.instance.set(alleles, SPEED, Speed.FASTEST); + AlleleHelper.instance.set(alleles, TERRITORY, Territory.LARGEST); + }), + ENDGAME("ENDUS GAMUS", alleles -> { + AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_5); + AlleleHelper.instance.set(alleles, TOLERANT_FLYER, true); + AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTEST); + AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.SHORTEST); + AlleleHelper.instance.set(alleles, SPEED, Speed.FASTEST); + AlleleHelper.instance.set(alleles, TERRITORY, Territory.LARGEST); + }); + + private static IAllele[] defaultTemplate; + private final IClassification branch; + private final Consumer mBranchProperties; + + GTBranchDefinition(String scientific, Consumer aBranchProperties) { + this.branch = BeeManager.beeFactory.createBranch( + this.name() + .toLowerCase(), + scientific); + this.mBranchProperties = aBranchProperties; + } + + private static IAllele[] getDefaultTemplate() { + if (defaultTemplate == null) { + defaultTemplate = new IAllele[EnumBeeChromosome.values().length]; + + AlleleHelper.instance.set(defaultTemplate, SPEED, Speed.SLOWEST); + AlleleHelper.instance.set(defaultTemplate, LIFESPAN, Lifespan.SHORTER); + AlleleHelper.instance.set(defaultTemplate, FERTILITY, Fertility.NORMAL); + AlleleHelper.instance.set(defaultTemplate, TEMPERATURE_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(defaultTemplate, NOCTURNAL, false); + AlleleHelper.instance.set(defaultTemplate, HUMIDITY_TOLERANCE, Tolerance.NONE); + AlleleHelper.instance.set(defaultTemplate, TOLERANT_FLYER, false); + AlleleHelper.instance.set(defaultTemplate, CAVE_DWELLING, false); + AlleleHelper.instance.set(defaultTemplate, FLOWER_PROVIDER, Flowers.VANILLA); + AlleleHelper.instance.set(defaultTemplate, FLOWERING, Flowering.SLOWEST); + AlleleHelper.instance.set(defaultTemplate, TERRITORY, Territory.AVERAGE); + AlleleHelper.instance.set(defaultTemplate, EFFECT, AlleleEffect.effectNone); + } + return Arrays.copyOf(defaultTemplate, defaultTemplate.length); + } + + void setBranchProperties(IAllele[] template) { + this.mBranchProperties.accept(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_Achievements.java b/src/main/java/gregtech/loaders/misc/GT_Achievements.java deleted file mode 100644 index 1245a1dbaf..0000000000 --- a/src/main/java/gregtech/loaders/misc/GT_Achievements.java +++ /dev/null @@ -1,822 +0,0 @@ -package gregtech.loaders.misc; - -import static gregtech.api.enums.Mods.Thaumcraft; - -import java.util.concurrent.ConcurrentHashMap; - -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 cpw.mods.fml.common.FMLCommonHandler; -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.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.recipe.RecipeMaps; -import gregtech.api.util.GT_Log; -import gregtech.api.util.GT_ModHandler; -import gregtech.api.util.GT_OreDictUnificator; -import gregtech.api.util.GT_Recipe; -import gregtech.common.items.GT_MetaGenerated_Tool_01; -import gregtech.common.items.ID_MetaTool_01; -import ic2.core.Ic2Items; -import thaumcraft.api.ThaumcraftApiHelper; - -public class GT_Achievements { - - public static int oreReg = -1; - public static int assReg = -1; - public ConcurrentHashMap achievementList; - public ConcurrentHashMap issuedAchievements; - public int adjX = 5; - public int adjY = 9; - - public GT_Achievements() { - this.achievementList = new ConcurrentHashMap<>(); - this.issuedAchievements = new ConcurrentHashMap<>(); - - for (GT_Recipe recipe : RecipeMaps.assemblylineVisualRecipes.getAllRecipes()) { - registerAssAchievement(recipe); - } - - 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), "crops", false); - registerAchievement("havestcopper", -2, 1, ItemList.Crop_Drop_Coppon.get(1), "crops", false); - registerAchievement("havesttin", -2, -1, ItemList.Crop_Drop_Tine.get(1), "crops", false); - registerAchievement("havestoil", -4, -4, ItemList.Crop_Drop_OilBerry.get(1), "crops", false); - registerAchievement("havestiron", -2, -3, ItemList.Crop_Drop_Ferru.get(1), "crops", false); - registerAchievement("havestgold", -2, -6, ItemList.Crop_Drop_Aurelia.get(1), "havestiron", false); - registerAchievement("havestsilver", -4, -5, ItemList.Crop_Drop_Argentia.get(1), "havestiron", false); - registerAchievement("havestemeralds", -2, -8, ItemList.Crop_Drop_BobsYerUncleRanks.get(1), "havestgold", false); - - registerAchievement( - "tools", - 0, - 4, - GT_MetaGenerated_Tool_01.INSTANCE - .getToolWithStats(ID_MetaTool_01.HARDHAMMER.ID, 1, Materials.Iron, Materials.Wood, null), - "flintpick", - false); - registerAchievement( - "driltime", - 2, - 4, - GT_MetaGenerated_Tool_01.INSTANCE - .getToolWithStats(ID_MetaTool_01.DRILL_LV.ID, 1, Materials.BlueSteel, Materials.StainlessSteel, null), - "tools", - false); - registerAchievement( - "brrrr", - 2, - 6, - GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( - ID_MetaTool_01.CHAINSAW_LV.ID, - 1, - Materials.BlueSteel, - Materials.StainlessSteel, - null), - "driltime", - false); - registerAchievement( - "highpowerdrill", - 3, - 5, - GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( - ID_MetaTool_01.DRILL_HV.ID, - 1, - Materials.TungstenSteel, - Materials.TungstenSteel, - null), - "driltime", - false); - registerAchievement( - "hammertime", - 3, - 7, - GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats( - ID_MetaTool_01.JACKHAMMER.ID, - 1, - Materials.TungstenSteel, - Materials.TungstenSteel, - null), - "highpowerdrill", - false); - - registerAchievement( - "unitool", - -2, - 4, - GT_MetaGenerated_Tool_01.INSTANCE - .getToolWithStats(ID_MetaTool_01.UNIVERSALSPADE.ID, 1, Materials.Steel, Materials.Iron, null), - "tools", - false); - registerAchievement("recycling", -4, 4, ItemList.Machine_LV_ArcFurnace.get(1), "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), "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), "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, ItemList.Machine_HP_Solar.get(1L)), - "bronze", - false); - registerAchievement("firststeam", 2, -2, ItemList.Machine_Bronze_Boiler.get(1), "bronze", false); - registerAchievement("alloysmelter", 2, -4, ItemList.Machine_Bronze_AlloySmelter.get(1), "firststeam", false); - registerAchievement("macerator", 0, -2, ItemList.Machine_Bronze_Macerator.get(1), "firststeam", false); - registerAchievement("extract", 0, -4, ItemList.Machine_Bronze_Extractor.get(1), "alloysmelter", false); - - registerAchievement("smallparts", 0, -5, ItemList.Circuit_Primitive.get(1), "alloysmelter", false); - registerAchievement("gtbasiccircuit", 0, -8, Ic2Items.electronicCircuit.copy(), "smallparts", false); - registerAchievement("bettercircuits", 0, -9, ItemList.Circuit_Good.get(1), "gtbasiccircuit", false); - registerAchievement("stepforward", -2, -9, Ic2Items.advancedCircuit.copy(), "bettercircuits", false); - registerAchievement("gtmonosilicon", -5, -10, ItemList.Circuit_Silicon_Ingot.get(1), "stepforward", false); - registerAchievement("gtlogicwafer", -7, -10, ItemList.Circuit_Wafer_ILC.get(1), "gtmonosilicon", false); - registerAchievement("gtlogiccircuit", -9, -10, ItemList.Circuit_Basic.get(1), "gtlogicwafer", false); - registerAchievement("gtcleanroom", -11, -10, ItemList.Machine_Multi_Cleanroom.get(1), "gtlogiccircuit", false); - registerAchievement("energyflow", -13, -10, ItemList.Circuit_Nanoprocessor.get(1), "gtcleanroom", false); - registerAchievement( - "gtquantumprocessor", - -13, - -12, - ItemList.Circuit_Quantumprocessor.get(1), - "energyflow", - false); - registerAchievement( - "gtcrystalprocessor", - -11, - -12, - ItemList.Circuit_Crystalprocessor.get(1), - "gtquantumprocessor", - false); - registerAchievement("gtwetware", -9, -12, ItemList.Circuit_Neuroprocessor.get(1), "gtcrystalprocessor", false); - registerAchievement("gtwetmain", -7, -12, ItemList.Circuit_Wetwaremainframe.get(1), "gtwetware", false); - - registerAchievement("orbs", -10, -14, ItemList.Energy_LapotronicOrb.get(1), "energyflow", false); - registerAchievement("thatspower", -8, -14, ItemList.Energy_LapotronicOrb2.get(1), "orbs", false); - registerAchievement("datasaving", -2, -12, ItemList.Tool_DataOrb.get(1), "stepforward", false); - registerAchievement("superbuffer", 0, -12, ItemList.Automation_SuperBuffer_LV.get(1), "datasaving", false); - registerAchievement("newstorage", -2, -14, ItemList.Quantum_Chest_HV.get(1), "superbuffer", false); - registerAchievement("whereistheocean", 2, -14, ItemList.Quantum_Tank_IV.get(1), "superbuffer", false); - registerAchievement("luck", 2, -6, ItemList.ZPM.get(1), "", 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), "steel", false); - registerAchievement( - "extremepressure", - 4, - 4, - ItemList.Machine_Multi_LargeBoiler_Steel.get(1), - "highpressure", - false); - registerAchievement("cheapermac", 6, 1, ItemList.Machine_LV_Hammer.get(1), "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), "magneticiron", false); - registerAchievement("pumpcover", 2, -8, ItemList.Electric_Pump_LV.get(1), "lvmotor", false); - registerAchievement("closeit", 2, -10, ItemList.Cover_Shutter.get(1), "pumpcover", false); - registerAchievement("slurp", 2, -12, ItemList.Pump_HV.get(1), "closeit", false); - registerAchievement("transport", 4, -10, ItemList.Conveyor_Module_LV.get(1), "lvmotor", false); - registerAchievement("manipulation", 4, -12, ItemList.Cover_Controller.get(1), "transport", false); - registerAchievement("buffer", 4, -14, ItemList.Automation_ChestBuffer_LV.get(1), "manipulation", false); - registerAchievement("complexmachines", 6, -9, ItemList.Robot_Arm_LV.get(1), "lvmotor", false); - registerAchievement("avengers", 8, -11, ItemList.Machine_LV_Assembler.get(1), "complexmachines", false); - registerAchievement("filterregulate", 10, -11, ItemList.Component_Filter.get(1), "avengers", false); - - registerAchievement("steampower", 6, -6, ItemList.Generator_Steam_Turbine_LV.get(1), "lvmotor", false); - registerAchievement("batterys", 6, -4, ItemList.Battery_Buffer_2by2_MV.get(1), "steampower", false); - registerAchievement("badweather", 6, -8, ItemList.Casing_FireHazard.get(1), "steampower", false); - registerAchievement("electricproblems", 7, -7, ItemList.Casing_ExplosionHazard.get(1), "steampower", false); - registerAchievement("ebf", 8, -6, ItemList.Machine_Multi_BlastFurnace.get(1), "steampower", false); - registerAchievement("energyhatch", 12, -6, ItemList.Hatch_Energy_LV.get(1), "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), "gtaluminium", false); - registerAchievement("oilplant", 8, 4, ItemList.Distillation_Tower.get(1), "highpowersmelt", false); - registerAchievement("factory", 8, 6, ItemList.Processing_Array.get(1), "oilplant", false); - registerAchievement("upgradeebf", 8, -2, ItemList.Hatch_Energy_MV.get(1), "gtaluminium", false); - registerAchievement("maintainance", 10, -2, ItemList.Hatch_Maintenance.get(1), "upgradeebf", false); - - registerAchievement("upgrade", 10, 0, ItemList.Casing_Coil_Kanthal.get(1), "gtaluminium", false); - registerAchievement( - "titan", - 14, - 0, - GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Titanium, 1L), - "upgrade", - false); - registerAchievement("magic", 14, 3, ItemList.MagicEnergyConverter_LV.get(1), "titan", false); - registerAchievement("highmage", 10, 3, ItemList.MagicEnergyAbsorber_HV.get(1), "magic", false); - registerAchievement("artificaldia", 12, 2, ItemList.IC2_Industrial_Diamond.get(1), "titan", false); - registerAchievement("muchsteam", 13, 1, ItemList.LargeSteamTurbine.get(1), "titan", false); - registerAchievement("efficientsteam", 11, 1, ItemList.LargeSteamTurbine.get(1), "muchsteam", false); - - registerAchievement("upgrade2", 16, 0, ItemList.Casing_Coil_Nichrome.get(1), "titan", false); - registerAchievement( - "tungsten", - 16, - 2, - GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Tungsten, 1L), - "upgrade2", - false); - registerAchievement( - "osmium", - 16, - -2, - GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Osmium, 1L), - "upgrade2", - false); - registerAchievement("hightech", 15, -3, ItemList.Field_Generator_LV.get(1), "osmium", false); - registerAchievement("amplifier", 16, -5, ItemList.Machine_LV_Amplifab.get(1), "hightech", false); - registerAchievement("scanning", 13, -3, ItemList.Machine_HV_Scanner.get(1), "hightech", false); - registerAchievement("alienpower", 14, -5, ItemList.Generator_Naquadah_Mark_I.get(1), "hightech", false); - registerAchievement("universal", 15, -6, ItemList.Machine_LV_Massfab.get(1), "hightech", false); - registerAchievement("replication", 17, -6, ItemList.Machine_LV_Replicator.get(1), "universal", false); - - registerAchievement( - "tungstensteel", - 16, - 4, - GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.TungstenSteel, 1L), - "tungsten", - false); - registerAchievement("upgrade3", 15, 5, ItemList.Casing_Coil_TungstenSteel.get(1), "tungstensteel", false); - registerAchievement( - "hssg", - 13, - 5, - GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.HSSG, 1L), - "upgrade3", - false); - registerAchievement("upgrade4", 11, 5, ItemList.Casing_Coil_HSSG.get(1), "hssg", false); - registerAchievement( - "stargatematerial", - 11, - 7, - GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Naquadah, 1L), - "upgrade4", - false); - registerAchievement("conducting", 14, 6, ItemList.Casing_Coil_Superconductor.get(1), "upgrade3", false); - registerAchievement("fusion", 15, 7, ItemList.FusionComputer_LuV.get(1), "tungstensteel", false); - registerAchievement("higherefficency", 15, 9, ItemList.Generator_Plasma_EV.get(1), "fusion", false); - registerAchievement("advancing", 13, 7, ItemList.FusionComputer_ZPMV.get(1), "fusion", false); - - registerAchievement("stargateliquid", 11, 9, ItemList.Generator_Plasma_IV.get(1), "advancing", false); - registerAchievement("tothelimit", 13, 9, ItemList.Generator_Plasma_IV.get(1), "advancing", false); - registerAchievement("fullefficiency", 12, 10, ItemList.Generator_Plasma_LuV.get(1), "tothelimit", false); - registerAchievement("upgrade5", 9, 9, ItemList.Casing_Coil_Naquadah.get(1), "stargateliquid", false); - registerAchievement( - "alienmetallurgy", - 9, - 7, - GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.NaquadahAlloy, 1L), - "upgrade5", - false); - registerAchievement("over9000", 7, 7, ItemList.Casing_Coil_NaquadahAlloy.get(1), "alienmetallurgy", false); - registerAchievement( - "finalpreparations", - 7, - 9, - GT_OreDictUnificator.get(OrePrefixes.ingot, Materials.Naquadria, 1L), - "over9000", - false); - registerAchievement("denseaspossible", 6, 10, ItemList.FusionComputer_UV.get(1), "finalpreparations", false); - - registerAchievement("zpmage", 8, 10, ItemList.Energy_Module.get(1), "denseaspossible", false); - registerAchievement("uvage", 10, 10, ItemList.Energy_Cluster.get(1), "zpmage", false); - registerAchievement("whatnow", 12, 10, ItemList.ZPM2.get(1), "uvage", false); - - if (GT_Mod.gregtechproxy.mAchievements) { - AchievementPage.registerAchievementPage( - new AchievementPage( - "GregTech 5", - this.achievementList.values() - .toArray(new Achievement[0]))); - 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) {} - - 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(); - } - ((StatBase) 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(); - } - ((StatBase) 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) { - return null; - } - - public Achievement registerAssAchievement(GT_Recipe recipe) { - if (recipe == null) { - GT_Mod.GT_FML_LOGGER.error("Invalid achievement registration attempt for null recipe", new Exception()); - return null; - } - if (recipe.getOutput(0) == null) { - GT_Mod.GT_FML_LOGGER - .error("Invalid achievement registration attempt for recipe with null output", new Exception()); - return null; - } - if (this.achievementList.get( - recipe.getOutput(0) - .getUnlocalizedName()) - == null) { - assReg++; - return registerAchievement( - recipe.getOutput(0) - .getUnlocalizedName(), - -(11 + assReg % 5), - ((assReg) / 5) - 8, - recipe.getOutput(0), - AchievementList.openInventory, - false); - } - return null; - } - - public void issueAchievement(EntityPlayer entityplayer, String textId) { - if (entityplayer == null || !GT_Mod.gregtechproxy.mAchievements) { - return; - } - entityplayer.triggerAchievement(this.achievementList.get(textId)); - } - - public Achievement getAchievement(String textId) { - if (this.achievementList.containsKey(textId)) { - return 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) && (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.Osmium) { - issueAchievement(player, "osmium"); - } else if (data.mMaterial.mMaterial == Materials.TungstenSteel) { - issueAchievement(player, "tungstensteel"); - } else if (data.mMaterial.mMaterial == Materials.HSSG) { - issueAchievement(player, "hssg"); - } else if (data.mMaterial.mMaterial == Materials.Naquadah) { - issueAchievement(player, "stargatematerial"); - } else if (data.mMaterial.mMaterial == Materials.NaquadahAlloy) { - issueAchievement(player, "alienmetallurgy"); - } else if (data.mMaterial.mMaterial == Materials.Naquadria) { - issueAchievement(player, "finalpreparations"); - } - } - if (stack.getUnlocalizedName() - .equals("ic2.itemPartIndustrialDiamond")) { - issueAchievement(player, "artificaldia"); - issueAchievement(player, "buildCoalDiamond"); - } - } - - public void issueAchivementHatchFluid(EntityPlayer player, FluidStack fluid) { - if (player == null || fluid == null) { - return; - } - switch (fluid.getFluid() - .getUnlocalizedName()) { - case "fluid.plasma.helium" -> issueAchievement(player, "fusion"); - case "fluid.molten.europium" -> issueAchievement(player, "advancing"); - case "fluid.molten.naquadah" -> issueAchievement(player, "stargateliquid"); - case "fluid.molten.americium" -> issueAchievement(player, "tothelimit"); - case "fluid.molten.neutronium" -> issueAchievement(player, "denseaspossible"); - case "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"); - } - } - switch (stack.getUnlocalizedName()) { - case "gt.metaitem.01.2300" -> issueAchievement(player, "bronze"); - case "gt.metaitem.01.32700" -> issueAchievement(player, "smallparts"); - case "gt.metaitem.01.32702" -> issueAchievement(player, "bettercircuits"); - case "gt.metaitem.01.23354" -> issueAchievement(player, "magneticiron"); - case "gt.metaitem.01.32600" -> { - issueAchievement(player, "lvmotor"); - issueAchievement(player, "buildCable"); - } - case "gt.metaitem.01.32610" -> issueAchievement(player, "pumpcover"); - case "gt.metaitem.01.32630" -> issueAchievement(player, "transport"); - case "gt.metaitem.01.32650" -> issueAchievement(player, "complexmachines"); - case "gt.metaitem.01.32670" -> issueAchievement(player, "hightech"); - case "ic2.blockCrop" -> issueAchievement(player, "crops"); - case "ic2.itemPartCircuit" -> issueAchievement(player, "gtbasiccircuit"); - case "ic2.itemPartCircuitAdv" -> issueAchievement(player, "stepforward"); - case "gt.blockmachines.boiler.solar" -> issueAchievement(player, "simplyeco"); - case "gt.blockmachines.boiler.bronze" -> issueAchievement(player, "firststeam"); - case "gt.blockmachines.boiler.steel" -> issueAchievement(player, "highpressure"); - case "gt.blockmachines.bronzemachine.macerator" -> { - issueAchievement(player, "macerator"); - issueAchievement(player, "buildMacerator"); - } - case "gt.blockmachines.bronzemachine.alloysmelter.tier.3" -> issueAchievement(player, "buildIndFurnace"); - case "gt.blockmachines.bronzemachine.alloysmelter" -> { - issueAchievement(player, "alloysmelter"); - issueAchievement(player, "buildElecFurnace"); - } - - case "gt.blockmachines.bronzemachine.extractor" -> { - issueAchievement(player, "extract"); - issueAchievement(player, "buildCompressor"); - issueAchievement(player, "buildExtractor"); - } - case "gt.blockmachines.basicmachine.pump.tier.03" -> issueAchievement(player, "slurp"); - case "gt.blockmachines.multimachine.blastfurnace" -> issueAchievement(player, "ebf"); - case "gt.blockmachines.hatch.energy.tier.02" -> issueAchievement(player, "upgradeebf"); - case "gt.blockmachines.multimachine.multifurnace" -> issueAchievement(player, "highpowersmelt"); - case "gt.blockmachines.hatch.energy.tier.01" -> issueAchievement(player, "energyhatch"); - case "gt.blockmachines.multimachine.processingarray" -> issueAchievement(player, "factory"); - case "gt.blockmachines.basicgenerator.magicenergyconverter.tier.01" -> issueAchievement(player, "magic"); - case "gt.blockmachines.basicgenerator.magicenergyabsorber.tier.03" -> issueAchievement(player, "highmage"); - case "gt.blockmachines.basicgenerator.plasmagenerator.tier.07" -> issueAchievement( - player, - "fullefficiency"); - case "gt.blockmachines.multimachine.largeturbine" -> issueAchievement(player, "muchsteam"); - case "gt.blockmachines.multimachine.largehpturbine" -> issueAchievement(player, "efficientsteam"); - case "gt.blockmachines.multimachine.cleanroom" -> issueAchievement(player, "gtcleanroom"); - case "gt.neutronreflector" -> issueAchievement(player, "reflect"); - case "gt.blockcasings5.1" -> issueAchievement(player, "upgrade"); - case "gt.blockcasings5.2" -> issueAchievement(player, "upgrade2"); - case "gt.blockcasings5.3" -> issueAchievement(player, "upgrade3"); - case "gt.blockcasings5.4" -> issueAchievement(player, "upgrade4"); - case "gt.blockcasings5.5" -> issueAchievement(player, "upgrade5"); - case "gt.blockcasings5.6" -> issueAchievement(player, "over9000"); - case "gt.blockcasings.15" -> issueAchievement(player, "conducting"); - } - - if (!stack.getUnlocalizedName() - .startsWith("gt.blockmachines.")) { - return; - } - - // from here, it only concerns "gt.blockmachines." kind of achievements - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.basicmachine.arcfurnace.tier.")) { - issueAchievement(player, "recycling"); - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.basicmachine.disassembler.tier.")) { - issueAchievement(player, "repair"); - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.automation.superbuffer.tier.")) { - issueAchievement(player, "superbuffer"); - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.quantum.tank.tier.")) { - issueAchievement(player, "whereistheocean"); - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.quantum.chest.tier.")) { - issueAchievement(player, "newstorage"); - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.basicmachine.hammer.tier.")) { - issueAchievement(player, "cheapermac"); - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.automation.chestbuffer.tier.")) { - issueAchievement(player, "buffer"); - issueAchievement(player, "buildBatBox"); - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.automation.chestbuffer.tier.3")) { - issueAchievement(player, "buildMFE"); - } - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.basicgenerator.steamturbine.tier.")) { - issueAchievement(player, "steampower"); - issueAchievement(player, "buildGenerator"); - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.basicmachine.assembler.tier.")) { - issueAchievement(player, "avengers"); - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.batterybuffer.")) { - issueAchievement(player, "batterys"); - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.basicmachine.amplifab.tier.")) { - issueAchievement(player, "amplifier"); - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.basicmachine.massfab.tier.")) { - issueAchievement(player, "universal"); - issueAchievement(player, "buildMassFab"); - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.basicgenerator.naquadah.tier.")) { - issueAchievement(player, "alienpower"); - return; - } - if (stack.getUnlocalizedName() - .startsWith("gt.blockmachines.basicmachine.replicator.tier.")) { - issueAchievement(player, "replication"); - return; - } - - } - - @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 && data.mPrefix != 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.name() - .startsWith("ore")) { - int data_getAllMaterialStacks_sS = data.getAllMaterialStacks() - .size(); - for (int i = 0; i < data_getAllMaterialStacks_sS; i++) { - issueAchievement( - player, - data.getAllMaterialStacks() - .get(i).mMaterial.mName); - if (data.getAllMaterialStacks() - .get(i).mMaterial == Materials.AnyIron) { - issueAchievement(player, "iron"); - } - if (data.getAllMaterialStacks() - .get(i).mMaterial == Materials.Copper - || data.getAllMaterialStacks() - .get(i).mMaterial == Materials.Tin) { - issueAchievement(event.entityPlayer, "mineOre"); - } - } - } 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 && Thaumcraft.isModLoaded() - && ThaumcraftApiHelper.isResearchComplete(player.getDisplayName(), "GT_IRON_TO_STEEL")) { - issueAchievement(player, "steel"); - } - } - } - // GT_FML_LOGGER.info(stack.getUnlocalizedName()); - switch (stack.getUnlocalizedName()) { - case "gt.metaitem.02.32500" -> issueAchievement(player, "havestlead"); - case "gt.metaitem.02.32501" -> issueAchievement(player, "havestsilver"); - case "gt.metaitem.02.32503" -> issueAchievement(player, "havestiron"); - case "gt.metaitem.02.32504" -> issueAchievement(player, "havestgold"); - case "gt.metaitem.02.32530" -> issueAchievement(player, "havestcopper"); - case "gt.metaitem.02.32540" -> issueAchievement(player, "havesttin"); - case "gt.metaitem.02.32510" -> issueAchievement(player, "havestoil"); - case "gt.metaitem.02.32511" -> issueAchievement(player, "havestemeralds"); - case "gt.metaitem.03.32082" -> issueAchievement(player, "energyflow"); - case "gt.metaitem.01.32702" -> issueAchievement(player, "bettercircuits"); - case "gt.metaitem.01.32707" -> issueAchievement(player, "datasaving"); - case "gt.metaitem.01.32597" -> issueAchievement(player, "orbs"); - case "gt.metaitem.01.32599" -> issueAchievement(player, "thatspower"); - case "gt.metaitem.01.32598" -> issueAchievement(player, "luck"); - case "gt.metaitem.01.32749" -> issueAchievement(player, "closeit"); - case "gt.metaitem.01.32730" -> issueAchievement(player, "manipulation"); - case "gt.metaitem.01.32729" -> issueAchievement(player, "filterregulate"); - case "gt.metaitem.01.32605" -> issueAchievement(player, "whatnow"); - case "gt.metaitem.01.32736" -> issueAchievement(player, "zpmage"); - case "gt.metaitem.01.32737" -> issueAchievement(player, "uvage"); - case "gt.metaitem.03.32030" -> issueAchievement(player, "gtmonosilicon"); - case "gt.metaitem.03.32036" -> issueAchievement(player, "gtlogicwafer"); - case "gt.metaitem.01.32701" -> issueAchievement(player, "gtlogiccircuit"); - case "gt.metaitem.03.32085" -> issueAchievement(player, "gtquantumprocessor"); - case "gt.metaitem.03.32089" -> issueAchievement(player, "gtcrystalprocessor"); - case "gt.metaitem.03.32092" -> issueAchievement(player, "gtwetware"); - case "gt.metaitem.03.32095" -> issueAchievement(player, "gtwetmain"); - case "gt.Thoriumcell" -> issueAchievement(player, "newfuel"); - case "ic2.itemPartCircuitAdv" -> issueAchievement(player, "stepforward"); - case "gt.blockcasings5.1" -> issueAchievement(player, "upgrade"); - case "gt.blockcasings5.2" -> issueAchievement(player, "upgrade2"); - case "gt.blockcasings5.3" -> issueAchievement(player, "upgrade3"); - case "gt.blockcasings5.4" -> issueAchievement(player, "upgrade4"); - case "gt.blockcasings5.5" -> issueAchievement(player, "upgrade5"); - case "gt.blockcasings5.6" -> issueAchievement(player, "over9000"); - case "gt.blockcasings.15" -> issueAchievement(player, "conducting"); - case "gt.metaitem.01.32761" -> { // Debug Scanner pickup shows all assline recipes. - if (player.capabilities.isCreativeMode) { - for (GT_Recipe recipe : RecipeMaps.assemblylineVisualRecipes.getAllRecipes()) { - issueAchievement( - player, - recipe.getOutput(0) - .getUnlocalizedName()); - recipe.mHidden = false; - } - } - } - } - - if ((stack.getItem() == Ic2Items.quantumBodyarmor.getItem()) - || (stack.getItem() == Ic2Items.quantumBoots.getItem()) - || (stack.getItem() == Ic2Items.quantumHelmet.getItem()) - || (stack.getItem() == Ic2Items.quantumLeggings.getItem())) { - issueAchievement(player, "buildQArmor"); - } - - for (GT_Recipe recipe : RecipeMaps.assemblylineVisualRecipes.getAllRecipes()) { - if (recipe.getOutput(0) - .getUnlocalizedName() - .equals(stack.getUnlocalizedName())) { - issueAchievement( - player, - recipe.getOutput(0) - .getUnlocalizedName()); - recipe.mHidden = false; - } - } - } -} diff --git a/src/main/java/gregtech/loaders/misc/GT_BeeDefinition.java b/src/main/java/gregtech/loaders/misc/GT_BeeDefinition.java deleted file mode 100644 index 87292ced62..0000000000 --- a/src/main/java/gregtech/loaders/misc/GT_BeeDefinition.java +++ /dev/null @@ -1,2831 +0,0 @@ -package gregtech.loaders.misc; - -import static forestry.api.apiculture.EnumBeeChromosome.CAVE_DWELLING; -import static forestry.api.apiculture.EnumBeeChromosome.EFFECT; -import static forestry.api.apiculture.EnumBeeChromosome.FERTILITY; -import static forestry.api.apiculture.EnumBeeChromosome.FLOWERING; -import static forestry.api.apiculture.EnumBeeChromosome.FLOWER_PROVIDER; -import static forestry.api.apiculture.EnumBeeChromosome.HUMIDITY_TOLERANCE; -import static forestry.api.apiculture.EnumBeeChromosome.LIFESPAN; -import static forestry.api.apiculture.EnumBeeChromosome.NOCTURNAL; -import static forestry.api.apiculture.EnumBeeChromosome.SPECIES; -import static forestry.api.apiculture.EnumBeeChromosome.SPEED; -import static forestry.api.apiculture.EnumBeeChromosome.TEMPERATURE_TOLERANCE; -import static forestry.api.apiculture.EnumBeeChromosome.TERRITORY; -import static forestry.api.apiculture.EnumBeeChromosome.TOLERANT_FLYER; -import static forestry.api.core.EnumHumidity.ARID; -import static forestry.api.core.EnumHumidity.DAMP; -import static forestry.api.core.EnumTemperature.COLD; -import static forestry.api.core.EnumTemperature.HELLISH; -import static forestry.api.core.EnumTemperature.HOT; -import static forestry.api.core.EnumTemperature.ICY; -import static forestry.api.core.EnumTemperature.NORMAL; -import static forestry.api.core.EnumTemperature.WARM; -import static forestry.core.genetics.alleles.EnumAllele.Fertility; -import static forestry.core.genetics.alleles.EnumAllele.Flowering; -import static forestry.core.genetics.alleles.EnumAllele.Flowers; -import static forestry.core.genetics.alleles.EnumAllele.Lifespan; -import static forestry.core.genetics.alleles.EnumAllele.Speed; -import static forestry.core.genetics.alleles.EnumAllele.Territory; -import static forestry.core.genetics.alleles.EnumAllele.Tolerance; -import static gregtech.api.enums.Mods.AdvancedSolarPanel; -import static gregtech.api.enums.Mods.AppliedEnergistics2; -import static gregtech.api.enums.Mods.Avaritia; -import static gregtech.api.enums.Mods.AvaritiaAddons; -import static gregtech.api.enums.Mods.BiomesOPlenty; -import static gregtech.api.enums.Mods.CropsPlusPlus; -import static gregtech.api.enums.Mods.EnderStorage; -import static gregtech.api.enums.Mods.ExtraBees; -import static gregtech.api.enums.Mods.ExtraCells2; -import static gregtech.api.enums.Mods.ExtraUtilities; -import static gregtech.api.enums.Mods.Forestry; -import static gregtech.api.enums.Mods.GalacticraftCore; -import static gregtech.api.enums.Mods.GalacticraftMars; -import static gregtech.api.enums.Mods.GalaxySpace; -import static gregtech.api.enums.Mods.HardcoreEnderExpansion; -import static gregtech.api.enums.Mods.IndustrialCraft2; -import static gregtech.api.enums.Mods.MagicBees; -import static gregtech.api.enums.Mods.NewHorizonsCoreMod; -import static gregtech.api.enums.Mods.PamsHarvestCraft; -import static gregtech.api.enums.Mods.TaintedMagic; -import static gregtech.api.enums.Mods.Thaumcraft; -import static gregtech.api.enums.Mods.ThaumicBases; -import static gregtech.api.enums.Mods.TinkerConstruct; -import static gregtech.loaders.misc.GT_BeeDefinitionReference.EXTRABEES; -import static gregtech.loaders.misc.GT_BeeDefinitionReference.FORESTRY; -import static gregtech.loaders.misc.GT_BeeDefinitionReference.GENDUSTRY; -import static gregtech.loaders.misc.GT_BeeDefinitionReference.GREGTECH; -import static gregtech.loaders.misc.GT_BeeDefinitionReference.MAGICBEES; - -import java.awt.Color; -import java.util.Arrays; -import java.util.Locale; -import java.util.function.Consumer; - -import net.minecraft.block.Block; -import net.minecraft.init.Blocks; -import net.minecraft.init.Items; -import net.minecraft.item.ItemStack; - -import org.apache.commons.lang3.text.WordUtils; - -import com.elisis.gtnhlanth.common.register.WerkstoffMaterialPool; - -import cpw.mods.fml.common.registry.GameRegistry; -import forestry.api.apiculture.BeeManager; -import forestry.api.apiculture.EnumBeeType; -import forestry.api.apiculture.IAlleleBeeEffect; -import forestry.api.apiculture.IAlleleBeeSpecies; -import forestry.api.apiculture.IBee; -import forestry.api.apiculture.IBeeGenome; -import forestry.api.apiculture.IBeeMutationCustom; -import forestry.api.core.EnumHumidity; -import forestry.api.core.EnumTemperature; -import forestry.api.genetics.AlleleManager; -import forestry.api.genetics.IAllele; -import forestry.api.genetics.IAlleleFlowers; -import forestry.api.genetics.IMutationCustom; -import forestry.apiculture.genetics.Bee; -import forestry.apiculture.genetics.IBeeDefinition; -import forestry.apiculture.genetics.alleles.AlleleEffect; -import forestry.core.genetics.alleles.AlleleHelper; -import gregtech.api.GregTech_API; -import gregtech.api.enums.ItemList; -import gregtech.api.enums.Materials; -import gregtech.api.enums.MaterialsKevlar; -import gregtech.api.enums.OrePrefixes; -import gregtech.api.util.GT_JubilanceMegaApiary; -import gregtech.api.util.GT_LanguageManager; -import gregtech.api.util.GT_ModHandler; -import gregtech.api.util.GT_OreDictUnificator; -import gregtech.common.bees.GT_AlleleBeeSpecies; -import gregtech.common.bees.GT_Bee_Mutation; -import gregtech.common.items.CombType; -import gregtech.common.items.DropType; -import gregtech.common.items.PropolisType; -import gregtech.loaders.misc.bees.GT_Flowers; - -/** - * Bride Class for Lambdas - */ -class GT_BeeDefinitionReference { - - protected static final byte FORESTRY = 0; - protected static final byte EXTRABEES = 1; - protected static final byte GENDUSTRY = 2; - protected static final byte MAGICBEES = 3; - protected static final byte GREGTECH = 4; - - private GT_BeeDefinitionReference() {} -} - -public enum GT_BeeDefinition implements IBeeDefinition { - - // organic - CLAY(GT_BranchDefinition.ORGANIC, "Clay", true, new Color(0xC8C8DA), new Color(0x0000FF), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 0), 0.30f); - beeSpecies.addProduct(new ItemStack(Items.clay_ball, 1), 0.15f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(BiomesOPlenty.ID, "mudball", 1, 0), 0.05f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOWER); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.VANILLA); - }, dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(FORESTRY, "Industrious"), getSpecies(FORESTRY, "Diligent"), 10); - tMutation.requireResource(Blocks.clay, 0); // blockStainedHardenedClay - }), - SLIMEBALL(GT_BranchDefinition.ORGANIC, "SlimeBall", true, new Color(0x4E9E55), new Color(0x00FF15), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 15), 0.30f); - beeSpecies.addProduct(new ItemStack(Items.slime_ball, 1), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.STICKY), 0.05f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - if (TinkerConstruct.isModLoaded()) { - beeSpecies.addProduct(GT_ModHandler.getModItem(TinkerConstruct.ID, "strangeFood", 1, 0), 0.10f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(TinkerConstruct.ID, "slime.gel", 1, 2), 0.02f); - } - }, template -> { - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.MUSHROOMS); - AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOWER); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, getFlowers(EXTRABEES, "water")); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Marshy"), CLAY, 7); - if (TinkerConstruct.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(TinkerConstruct.ID, "slime.gel"), 1); - }), - PEAT(GT_BranchDefinition.ORGANIC, "Peat", true, new Color(0x906237), new Color(0x58300B), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.LIGNIE), 0.30f); - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 0), 0.15f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(Forestry.ID, "peat", 1, 0), 0.15f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(Forestry.ID, "mulch", 1, 0), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTER); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.WHEAT); - AlleleHelper.instance.set(template, FLOWERING, Flowering.FASTER); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); - }, dis -> dis.registerMutation(getSpecies(FORESTRY, "Rural"), CLAY, 10)), - STICKYRESIN(GT_BranchDefinition.ORGANIC, "StickyResin", true, new Color(0x2E8F5B), new Color(0xDCC289), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 0), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.STICKY), 0.15f); - beeSpecies.addSpecialty(ItemList.IC2_Resin.get(1), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOWER); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(SLIMEBALL, PEAT, 15); - tMutation.requireResource("logRubber"); - }), - COAL(GT_BranchDefinition.ORGANIC, "Coal", true, new Color(0x666666), new Color(0x525252), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.LIGNIE), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.COAL), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.CACTI); - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_2); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.DOWN_1); - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectCreeper); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Industrious"), PEAT, 9); - tMutation.requireResource("blockCoal"); - }), - OIL(GT_BranchDefinition.ORGANIC, "Oil", true, new Color(0x4C4C4C), new Color(0x333333), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 0), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.OIL), 0.75f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOWER); - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.NORMAL); - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, getFlowers(EXTRABEES, "water")); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); - }, dis -> dis.registerMutation(COAL, STICKYRESIN, 4)), - SANDWICH(GT_BranchDefinition.ORGANIC, "Sandwich", true, new Color(0x32CD32), new Color(0xDAA520), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(ExtraBees.ID, "honeyComb", 1, 9), 0.15f); - beeSpecies.addSpecialty(ItemList.Food_Sliced_Cucumber.get(1), 0.05f); - beeSpecies.addSpecialty(ItemList.Food_Sliced_Onion.get(1), 0.05f); - beeSpecies.addSpecialty(ItemList.Food_Sliced_Tomato.get(1), 0.05f); - beeSpecies.addSpecialty(ItemList.Food_Sliced_Cheese.get(1), 0.05f); - beeSpecies.addSpecialty(new ItemStack(Items.cooked_porkchop, 1, 0), 0.05f); - beeSpecies.addSpecialty(new ItemStack(Items.cooked_beef, 1, 0), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOW); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_2); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectFertile); - AlleleHelper.instance.set(template, TERRITORY, Territory.LARGE); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTER); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.WHEAT); - AlleleHelper.instance.set(template, FLOWERING, Flowering.FASTER); - }, dis -> dis.registerMutation(getSpecies(FORESTRY, "Agrarian"), getSpecies(MAGICBEES, "TCBatty"), 10)), - ASH(GT_BranchDefinition.ORGANIC, "Ash", true, new Color(0x1e1a18), new Color(0xc6c6c6), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(ExtraBees.ID, "honeyComb", 1, 9), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ASH), 0.15f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.NORMAL); - AlleleHelper.instance.set(template, TERRITORY, Territory.LARGE); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTER); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.WHEAT); - AlleleHelper.instance.set(template, FLOWERING, Flowering.FASTER); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(COAL, CLAY, 10); - tMutation.restrictTemperature(HELLISH); - }), - APATITE(GT_BranchDefinition.ORGANIC, "Apatite", true, new Color(0xc1c1f6), new Color(0x676784), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(ExtraBees.ID, "honeyComb", 1, 9), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.APATITE), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(WARM); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FASTEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.WHEAT); - AlleleHelper.instance.set(template, FLOWERING, Flowering.FASTER); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, getFlowers(EXTRABEES, "rock")); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(ASH, COAL, 10); - tMutation.requireResource("blockApatite"); - }), - FERTILIZER(GT_BranchDefinition.ORGANIC, "Fertilizer", true, new Color(0x7fcef5), new Color(0x654525), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(ExtraBees.ID, "honeyComb", 1, 9), 0.15f); - beeSpecies.addSpecialty(GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1), 0.2f); - beeSpecies.addSpecialty(GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1), 0.2f); - beeSpecies.addSpecialty(ItemList.FR_Fertilizer.get(1), 0.3f); - beeSpecies.addSpecialty(ItemList.IC2_Fertilizer.get(1), 0.3f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(WARM); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FASTEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.WHEAT); - AlleleHelper.instance.set(template, FLOWERING, Flowering.FASTER); - }, dis -> dis.registerMutation(ASH, APATITE, 8)), - // Phosphorus bee, Humidity: normal, Temperature: Hot, Parents: Apatite & Ash, Mutationrate: 12%, Combrate: 55% - PHOSPHORUS(GT_BranchDefinition.ORGANIC, "Phosphorus", false, new Color(0xFFC826), new Color(0xC1C1F6), - beeSpecies -> { - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.PHOSPHORUS), 0.35f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(HOT); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(APATITE, ASH, 12); - tMutation.restrictTemperature(HOT); - GregTech_API.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTech_API.sBlockGem2, 8)); - }), - // Tea bee, Humidity: normal, Parents: Ash and Fertilizer, Mutationrate: 10%, combrate: 10% - TEA(GT_BranchDefinition.ORGANIC, "Tea", false, new Color(0x65D13A), new Color(0x9a9679), beeSpecies -> { - beeSpecies.addProduct( - GT_ModHandler.getModItem(PamsHarvestCraft.ID, "tealeafItem", 1, ItemList.Crop_Drop_TeaLeaf.get(1)), - 0.10f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(NORMAL); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), - dis -> dis.registerMutation(FERTILIZER, ASH, 10)), - // Mica bee, Humidity: normal, Parents: Silicon & PEAT, Mutationrate: 15%, Combrate: 25% - MICA(GT_BranchDefinition.ORGANIC, "Mica", false, new Color(0xFFC826), new Color(0xC1C1F6), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.MICA), 0.25f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(HOT); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(PEAT, getSpecies(MAGICBEES, "Silicon"), 15); - GregTech_API.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTech_API.sBlockCasings5, 0)); - }), - - // gems - REDSTONE(GT_BranchDefinition.GEM, "Redstone", true, new Color(0x7D0F0F), new Color(0xD11919), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.REDSTONE), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.RAREEARTH), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(FORESTRY, "Industrious"), getSpecies(FORESTRY, "Demonic"), 10); - tMutation.requireResource("blockRedstone"); - }), - LAPIS(GT_BranchDefinition.GEM, "Lapis", true, new Color(0x1947D1), new Color(0x476CDA), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.LAPIS), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(FORESTRY, "Demonic"), getSpecies(FORESTRY, "Imperial"), 10); - tMutation.requireResource("blockLapis"); - }), - CERTUS(GT_BranchDefinition.GEM, "CertusQuartz", true, new Color(0x57CFFB), new Color(0xBBEEFF), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.CERTUS), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Hermitic"), LAPIS, 10); - tMutation.requireResource(GameRegistry.findBlock(AppliedEnergistics2.ID, "tile.BlockQuartz"), 0); - }), - FLUIX(GT_BranchDefinition.GEM, "FluixDust", true, new Color(0xA375FF), new Color(0xB591FF), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.FLUIX), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, LAPIS, 7); - tMutation.requireResource(GameRegistry.findBlock(AppliedEnergistics2.ID, "tile.BlockFluix"), 0); - }), - DIAMOND(GT_BranchDefinition.GEM, "Diamond", false, new Color(0xCCFFFF), new Color(0xA3CCCC), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.DIAMOND), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(HOT); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(CERTUS, COAL, 3); - tMutation.requireResource("blockDiamond"); - }), - RUBY(GT_BranchDefinition.GEM, "Ruby", false, new Color(0xE6005C), new Color(0xCC0052), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.RUBY), 0.15f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.REDGARNET), 0.05f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, DIAMOND, 5); - tMutation.requireResource("blockRuby"); - }), - SAPPHIRE(GT_BranchDefinition.GEM, "Sapphire", true, new Color(0x0033CC), new Color(0x00248F), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.SAPPHIRE), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(CERTUS, LAPIS, 5); - tMutation.requireResource(GregTech_API.sBlockGem2, 12); - }), - OLIVINE(GT_BranchDefinition.GEM, "Olivine", true, new Color(0x248F24), new Color(0xCCFFCC), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.OLIVINE), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.MAGNESIUM), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), - dis -> dis.registerMutation(CERTUS, getSpecies(FORESTRY, "Ended"), 5)), - EMERALD(GT_BranchDefinition.GEM, "Emerald", false, new Color(0x248F24), new Color(0x2EB82E), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.EMERALD), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ALUMINIUM), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(COLD); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(OLIVINE, DIAMOND, 4); - tMutation.requireResource("blockEmerald"); - }), - REDGARNET(GT_BranchDefinition.GEM, "RedGarnet", false, new Color(0xBD4C4C), new Color(0xECCECE), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.REDGARNET), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.PYROPE), 0.05f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(WARM); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(DIAMOND, RUBY, 4); - tMutation.requireResource("blockGarnetRed"); - }), - YELLOWGARNET(GT_BranchDefinition.GEM, "YellowGarnet", false, new Color(0xA3A341), new Color(0xEDEDCE), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.YELLOWGARNET), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.GROSSULAR), 0.05f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(WARM); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(EMERALD, REDGARNET, 3); - tMutation.requireResource("blockGarnetYellow"); - }), - FIRESTONE(GT_BranchDefinition.GEM, "Firestone", false, new Color(0xC00000), new Color(0xFF0000), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STONE), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.FIRESTONE), 0.15f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(WARM); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - AlleleHelper.instance.set(template, NOCTURNAL, true); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, RUBY, 4); - tMutation.requireResource("blockFirestone"); - }), - - // Metal Line - COPPER(GT_BranchDefinition.METAL, "Copper", true, new Color(0xFF6600), new Color(0xE65C00), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.COPPER), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.GOLD), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Majestic"), CLAY, 13); - tMutation.requireResource("blockCopper"); - }), - TIN(GT_BranchDefinition.METAL, "Tin", true, new Color(0xD4D4D4), new Color(0xDDDDDD), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.TIN), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ZINC), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(CLAY, getSpecies(FORESTRY, "Diligent"), 13); - tMutation.requireResource("blockTin"); - }), - LEAD(GT_BranchDefinition.METAL, "Lead", true, new Color(0x666699), new Color(0xA3A3CC), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.LEAD), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.SULFUR), 0.05f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(WARM); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(COAL, COPPER, 13); - tMutation.requireResource("blockLead"); - }), - IRON(GT_BranchDefinition.METAL, "Iron", true, new Color(0xDA9147), new Color(0xDE9C59), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.IRON), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.TIN), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(TIN, COPPER, 13); - tMutation.requireResource("blockIron"); - }), - STEEL(GT_BranchDefinition.METAL, "Steel", true, new Color(0x808080), new Color(0x999999), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STEEL), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.IRON), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(WARM); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(IRON, COAL, 10); - tMutation.requireResource(GregTech_API.sBlockMetal6, 13); - }), - NICKEL(GT_BranchDefinition.METAL, "Nickel", true, new Color(0x8585AD), new Color(0x8585AD), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.NICKEL), 0.15f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.PLATINUM), 0.02f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(IRON, COPPER, 13); - tMutation.requireResource("blockNickel"); - }), - ZINC(GT_BranchDefinition.METAL, "Zinc", true, new Color(0xF0DEF0), new Color(0xF2E1F2), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.ZINC), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.GALLIUM), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(IRON, TIN, 13); - tMutation.requireResource("blockZinc"); - }), - SILVER(GT_BranchDefinition.METAL, "Silver", true, new Color(0xC2C2D6), new Color(0xCECEDE), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SILVER), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.SULFUR), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(COLD); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(LEAD, TIN, 10); - tMutation.requireResource("blockSilver"); - }), - CRYOLITE(GT_BranchDefinition.METAL, "Cryolite", true, new Color(0xBFEFFF), new Color(0x73B9D0), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.CRYOLITE), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.SILVER), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(WARM); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.FASTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(LEAD, SILVER, 9); - tMutation.requireResource("blockCryolite"); - }), - GOLD(GT_BranchDefinition.METAL, "Gold", true, new Color(0xEBC633), new Color(0xEDCC47), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.GOLD), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.NICKEL), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(WARM); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(LEAD, COPPER, 13); - tMutation.requireResource("blockGold"); - tMutation.restrictTemperature(HOT); - }), - ARSENIC(GT_BranchDefinition.METAL, "Arsenic", true, new Color(0x736C52), new Color(0x292412), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.ARSENIC), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(WARM); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(ZINC, SILVER, 10); - tMutation.requireResource("blockArsenic"); - }), - - // Rare Metals - ALUMINIUM(GT_BranchDefinition.RAREMETAL, "Aluminium", true, new Color(0xB8B8FF), new Color(0xD6D6FF), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.ALUMINIUM), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.BAUXITE), 0.05f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(NICKEL, ZINC, 9); - tMutation.requireResource("blockAluminium"); - }), - TITANIUM(GT_BranchDefinition.RAREMETAL, "Titanium", true, new Color(0xCC99FF), new Color(0xDBB8FF), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.TITANIUM), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ALMANDINE), 0.05f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, ALUMINIUM, 5); - tMutation.requireResource(GregTech_API.sBlockMetal7, 9); - }), - GLOWSTONE(GT_BranchDefinition.RAREMETAL, "Glowstone", false, new Color(0xE5CA2A), new Color(0xFFBC5E), - beeSpecies -> { - beeSpecies.addSpecialty(Materials.Glowstone.getDust(1), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.NORMAL), - dis -> dis.registerMutation(REDSTONE, GOLD, 10)), - SUNNARIUM(GT_BranchDefinition.RAREMETAL, "Sunnarium", false, new Color(0xFFBC5E), new Color(0xE5CA2A), - beeSpecies -> { - beeSpecies.addProduct(Materials.Glowstone.getDust(1), 0.30f); - beeSpecies.addSpecialty(Materials.Sunnarium.getDust(1), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(GLOWSTONE, GOLD, 5); - GregTech_API.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTech_API.sBlockCasings1, 15)); - }), - CHROME(GT_BranchDefinition.RAREMETAL, "Chrome", true, new Color(0xEBA1EB), new Color(0xF2C3F2), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.CHROME), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.MAGNESIUM), 0.05f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(TITANIUM, RUBY, 5); - tMutation.requireResource(GregTech_API.sBlockMetal2, 3); - }), - MANGANESE(GT_BranchDefinition.RAREMETAL, "Manganese", true, new Color(0xD5D5D5), new Color(0xAAAAAA), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.MANGANESE), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.IRON), 0.05f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(TITANIUM, ALUMINIUM, 5); - tMutation.requireResource(GregTech_API.sBlockMetal4, 6); - }), - TUNGSTEN(GT_BranchDefinition.RAREMETAL, "Tungsten", false, new Color(0x5C5C8A), new Color(0x7D7DA1), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.TUNGSTEN), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.MOLYBDENUM), 0.05f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Heroic"), MANGANESE, 5); - tMutation.requireResource(GregTech_API.sBlockMetal7, 11); - }), - PLATINUM(GT_BranchDefinition.RAREMETAL, "Platinum", false, new Color(0xE6E6E6), new Color(0xFFFFCC), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.PLATINUM), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.IRIDIUM), 0.02f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(DIAMOND, CHROME, 5); - tMutation.requireResource("blockNickel"); - }), - IRIDIUM(GT_BranchDefinition.RAREMETAL, "Iridium", false, new Color(0xDADADA), new Color(0xD1D1E0), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.IRIDIUM), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.OSMIUM), 0.05f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.PALLADIUM), 0.30f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(TUNGSTEN, PLATINUM, 5); - tMutation.requireResource(GregTech_API.sBlockMetal3, 12); - }), - OSMIUM(GT_BranchDefinition.RAREMETAL, "Osmium", false, new Color(0x2B2BDA), new Color(0x8B8B8B), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.OSMIUM), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.IRIDIUM), 0.05f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(COLD); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(TUNGSTEN, PLATINUM, 5); - tMutation.requireResource(GregTech_API.sBlockMetal5, 9); - }), - SALTY(GT_BranchDefinition.RAREMETAL, "Salt", true, new Color(0xF0C8C8), new Color(0xFAFAFA), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.SALT), 0.35f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.LITHIUM), 0.05f); - beeSpecies.addSpecialty(GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Borax, 1L), 0.1f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(WARM); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(CLAY, ALUMINIUM, 5); - tMutation.requireResource("blockSalt"); - }), - LITHIUM(GT_BranchDefinition.RAREMETAL, "Lithium", false, new Color(0xF0328C), new Color(0xE1DCFF), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.LITHIUM), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.SALT), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(COLD); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(SALTY, ALUMINIUM, 5); - tMutation.requireResource("frameGtLithium"); - }), - ELECTROTINE(GT_BranchDefinition.RAREMETAL, "Electrotine", false, new Color(0x1E90FF), new Color(0x3CB4C8), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ELECTROTINE), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.REDSTONE), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWER), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, GOLD, 5); - tMutation.requireResource("blockElectrotine"); - }), - // Sulfur bee, Humidity: normal, Temperature: Hot, Parents: PEAT & Ash, Mutationrate: 15%, Combrate: 80% - SULFUR(GT_BranchDefinition.RAREMETAL, "Sulfur", false, new Color(0x1E90FF), new Color(0x3CB4C8), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SULFUR), 0.70f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.FIRESTONE), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.NORMAL), - dis -> dis.registerMutation(ASH, PEAT, 15)), - - INDIUM(GT_BranchDefinition.RAREMETAL, "Indium", false, new Color(0xFFA9FF), new Color(0x8F5D99), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.INDIUM), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(LEAD, OSMIUM, 1); - tMutation.requireResource("blockIndium"); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(39, "Venus")); // Venus Dim - // Harder mutation that isn't dim locked - tMutation = dis.registerMutation(SILVER, OSMIUM, 1); - tMutation.requireResource("blockCinobiteA243"); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(60, "Bedrock")); // Thaumic Tinkerer - // Bedrock Dim - }), - - // IC2 - COOLANT(GT_BranchDefinition.IC2, "Coolant", false, new Color(0x144F5A), new Color(0x2494A2), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 4), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.COOLANT), 0.15f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(COLD); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOW); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.SNOW); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectGlacial); - }, dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(FORESTRY, "Icy"), getSpecies(FORESTRY, "Glacial"), 10); - tMutation.requireResource( - Block.getBlockFromItem( - GT_ModHandler.getModItem(IndustrialCraft2.ID, "fluidCoolant", 1) - .getItem()), - 0); - tMutation.restrictTemperature(ICY); - }), - ENERGY(GT_BranchDefinition.IC2, "Energy", false, new Color(0xC11F1F), new Color(0xEBB9B9), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(ExtraBees.ID, "honeyComb", 1, 12), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ENERGY), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(WARM); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectIgnition); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_2); - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.NETHER); - AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); - }, dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(FORESTRY, "Demonic"), getSpecies(EXTRABEES, "volcanic"), 10); - tMutation.requireResource( - Block.getBlockFromItem( - GT_ModHandler.getModItem(IndustrialCraft2.ID, "fluidHotCoolant", 1) - .getItem()), - 0); - tMutation.addMutationCondition(new GT_Bees.BiomeIDMutationCondition(128, "Boneyard Biome")); // Boneyard Biome - }), - LAPOTRON(GT_BranchDefinition.IC2, "Lapotron", false, new Color(0x6478FF), new Color(0x1414FF), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.LAPIS), 0.20f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ENERGY), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.LAPOTRON), 0.10f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(ICY); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectIgnition); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_1); - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.SNOW); - AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(LAPIS, ENERGY, 6); - tMutation.requireResource("blockLapis"); - tMutation.restrictTemperature(ICY); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(28, "Moon")); // moon dim - }), - PYROTHEUM(GT_BranchDefinition.IC2, "Pyrotheum", false, new Color(0xffebc4), new Color(0xe36400), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.ENERGY), 0.20f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.PYROTHEUM), 0.15f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FASTEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectIgnition); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.NETHER); - AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, ENERGY, 4); - tMutation.restrictTemperature(HELLISH); - }), - CRYOTHEUM(GT_BranchDefinition.IC2, "Cryotheum", false, new Color(0x2660ff), new Color(0x5af7ff), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.BLIZZ), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.CRYOTHEUM), 0.20f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(ICY); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectSnowing); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.SNOW); - AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, COOLANT, 4); - tMutation.restrictTemperature(ICY); - }), - Explosive(GT_BranchDefinition.IC2, "explosive", false, new Color(0x7E270F), new Color(0x747474), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getIC2Item("industrialTnt", 1L), 0.2f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectSnowing); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.SNOW); - AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(FIRESTONE, COAL, 4); - tMutation.requireResource(GameRegistry.findBlock(IndustrialCraft2.ID, "blockITNT"), 0); - }), - // Alloy - REDALLOY(GT_BranchDefinition.GTALLOY, "RedAlloy", false, new Color(0xE60000), new Color(0xB80000), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.REDALLOY), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTER); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(COPPER, REDSTONE, 10); - tMutation.requireResource("blockRedAlloy"); - }), - REDSTONEALLOY(GT_BranchDefinition.GTALLOY, "RedStoneAlloy", false, new Color(0xA50808), new Color(0xE80000), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.REDSTONEALLOY), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTER); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(REDSTONE, REDALLOY, 8); - tMutation.requireResource("blockRedstoneAlloy"); - }), - CONDUCTIVEIRON(GT_BranchDefinition.GTALLOY, "ConductiveIron", false, new Color(0xCEADA3), new Color(0x817671), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.CONDUCTIVEIRON), 0.15f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(WARM); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(REDSTONEALLOY, IRON, 8); - tMutation.requireResource("blockConductiveIron"); - }), - ENERGETICALLOY(GT_BranchDefinition.GTALLOY, "EnergeticAlloy", false, new Color(0xFF9933), new Color(0xFFAD5C), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ENERGETICALLOY), 0.15f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(REDSTONEALLOY, getSpecies(FORESTRY, "Demonic"), 9); - tMutation.requireResource("blockEnergeticAlloy"); - }), - VIBRANTALLOY(GT_BranchDefinition.GTALLOY, "VibrantAlloy", false, new Color(0x86A12D), new Color(0xC4F2AE), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.VIBRANTALLOY), 0.15f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - AlleleHelper.instance.set(template, FLOWERING, Flowering.FAST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(ENERGETICALLOY, getSpecies(FORESTRY, "Phantasmal"), 6); - tMutation.requireResource("blockVibrantAlloy"); - tMutation.restrictTemperature(HOT, HELLISH); - }), - ELECTRICALSTEEL(GT_BranchDefinition.GTALLOY, "ElectricalSteel", false, new Color(0x787878), new Color(0xD8D8D8), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ELECTRICALSTEEL), 0.15f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTER); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(STEEL, getSpecies(FORESTRY, "Demonic"), 9); - tMutation.requireResource("blockElectricalSteel"); - }), - DARKSTEEL(GT_BranchDefinition.GTALLOY, "DarkSteel", false, new Color(0x252525), new Color(0x443B44), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.DARKSTEEL), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(COLD); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(ELECTRICALSTEEL, getSpecies(FORESTRY, "Demonic"), 7); - tMutation.requireResource("blockDarkSteel"); - }), - PULSATINGIRON(GT_BranchDefinition.GTALLOY, "PulsatingIron", false, new Color(0x6DD284), new Color(0x006600), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 7), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.PULSATINGIRON), 0.15f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(REDALLOY, getSpecies(FORESTRY, "Ended"), 9); - tMutation.requireResource("blockPulsatingIron"); - }), - STAINLESSSTEEL(GT_BranchDefinition.GTALLOY, "StainlessSteel", false, new Color(0xC8C8DC), new Color(0x778899), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.STEEL), 0.10f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.STAINLESSSTEEL), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.CHROME), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(HOT); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectIgnition); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(CHROME, STEEL, 9); - tMutation.requireResource("blockStainlessSteel"); - }), - ENDERIUM(GT_BranchDefinition.GTALLOY, "Enderium", false, new Color(0x599087), new Color(0x2E8B57), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ENDERIUM), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.CHROME), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(HOT); - }, template -> { - AlleleHelper.instance.set(template, SPEED, GT_Bees.speedBlinding); - AlleleHelper.instance.set(template, EFFECT, getEffect(EXTRABEES, "teleport")); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(PLATINUM, getSpecies(FORESTRY, "Phantasmal"), 3); - tMutation.requireResource("blockEnderium"); - }), - BEDROCKIUM(GT_BranchDefinition.GTALLOY, "Bedrockium", false, new Color(0x0C0C0C), new Color(0xC6C6C6), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.20f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.BEDROCKIUM), 0.55f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(HOT); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOW); - AlleleHelper.instance.set(template, EFFECT, getEffect(EXTRABEES, "gravity")); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(Explosive, DIAMOND, 2); - if (ExtraUtilities.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(ExtraUtilities.ID, "block_bedrockium"), 0); - }), - - // thaumic - THAUMIUMDUST(GT_BranchDefinition.THAUMIC, "ThaumiumDust", true, new Color(0x7A007A), new Color(0x5C005C), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 3), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.THAUMIUMDUST), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_2); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectExploration); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.UP_1); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.JUNGLE); - }, dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(MAGICBEES, "TCFire"), getSpecies(FORESTRY, "Edenic"), 10); - tMutation.requireResource("blockThaumium"); - tMutation.addMutationCondition(new GT_Bees.BiomeIDMutationCondition(192, "Magical Forest")); // magical - // forest - }), - THAUMIUMSHARD(GT_BranchDefinition.THAUMIC, "ThaumiumShard", true, new Color(0x9966FF), new Color(0xAD85FF), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.THAUMIUMDUST), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.THAUMIUMSHARD), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.SNOW); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectGlacial); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(THAUMIUMDUST, getSpecies(MAGICBEES, "TCWater"), 10); - tMutation.addMutationCondition(new GT_Bees.BiomeIDMutationCondition(192, "Magical Forest")); // magical - // forest - }), - AMBER(GT_BranchDefinition.THAUMIC, "Amber", true, new Color(0xEE7700), new Color(0x774B15), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 3), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.AMBER), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(THAUMIUMDUST, STICKYRESIN, 10); - tMutation.requireResource("blockAmber"); - }), - QUICKSILVER(GT_BranchDefinition.THAUMIC, "Quicksilver", true, new Color(0x7A007A), new Color(0x5C005C), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 3), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.QUICKSILVER), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.UP_1); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.JUNGLE); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectMiasmic); - }, dis -> dis.registerMutation(THAUMIUMDUST, SILVER, 10)), - SALISMUNDUS(GT_BranchDefinition.THAUMIC, "SalisMundus", true, new Color(0xF7ADDE), new Color(0x592582), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 3), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.SALISMUNDUS), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.UP_1); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.JUNGLE); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectMiasmic); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(THAUMIUMDUST, THAUMIUMSHARD, 8); - tMutation.addMutationCondition(new GT_Bees.BiomeIDMutationCondition(192, "Magical Forest")); // magical - // forest - }), - TAINTED(GT_BranchDefinition.THAUMIC, "Tainted", true, new Color(0x904BB8), new Color(0xE800FF), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 3), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.TAINTED), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, CAVE_DWELLING, true); - AlleleHelper.instance.set(template, TOLERANT_FLYER, true); - AlleleHelper.instance.set(template, FERTILITY, Fertility.LOW); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, getFlowers(EXTRABEES, "rock")); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(THAUMIUMDUST, THAUMIUMSHARD, 7); - tMutation.addMutationCondition(new GT_Bees.BiomeIDMutationCondition(193, "Tainted Land")); // Tainted Land - }), - MITHRIL(GT_BranchDefinition.THAUMIC, "Mithril", true, new Color(0xF0E68C), new Color(0xFFFFD2), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.PLATINUM), 0.20f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.MITHRIL), 0.125f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, CAVE_DWELLING, true); - AlleleHelper.instance.set(template, TOLERANT_FLYER, true); - AlleleHelper.instance.set(template, FERTILITY, Fertility.LOW); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, getFlowers(EXTRABEES, "rock")); - }, new Consumer<>() { - - @Override - public void accept(GT_BeeDefinition dis) { - IBeeMutationCustom tMutation = dis.registerMutation(IO, PLATINUM, 7); - tMutation.requireResource(GregTech_API.sBlockMetal4, 10); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(36, "IO")); // IO Dim - } - }), - ASTRALSILVER(GT_BranchDefinition.THAUMIC, "AstralSilver", true, new Color(0xAFEEEE), new Color(0xE6E6FF), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SILVER), 0.20f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ASTRALSILVER), 0.125f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, CAVE_DWELLING, true); - AlleleHelper.instance.set(template, TOLERANT_FLYER, true); - AlleleHelper.instance.set(template, FERTILITY, Fertility.LOW); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, getFlowers(EXTRABEES, "rock")); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(SILVER, IRON, 3); - tMutation.requireResource(GregTech_API.sBlockMetal1, 6); - }), - THAUMINITE(GT_BranchDefinition.THAUMIC, "Thauminite", true, new Color(0x2E2D79), new Color(0x7581E0), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(MagicBees.ID, "comb", 1, 19), 0.20f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.THAUMINITE), 0.125f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOW); - AlleleHelper.instance.set(template, NOCTURNAL, true); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(MAGICBEES, "TCOrder"), THAUMIUMDUST, 8); - if (ThaumicBases.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(ThaumicBases.ID, "thauminiteBlock"), 0); - }), - SHADOWMETAL(GT_BranchDefinition.THAUMIC, "ShadowMetal", true, new Color(0x100322), new Color(0x100342), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(MagicBees.ID, "comb", 1, 20), 0.20f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.SHADOWMETAL), 0.125f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOW); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(template, NOCTURNAL, true); - }, dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(MAGICBEES, "TCChaos"), getSpecies(MAGICBEES, "TCVoid"), 6); - if (TaintedMagic.isModLoaded()) { - tMutation.requireResource("blockShadow"); - } - }), - DIVIDED(GT_BranchDefinition.THAUMIC, "Unstable", true, new Color(0xF0F0F0), new Color(0xDCDCDC), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(ExtraBees.ID, "honeyComb", 1, 61), 0.20f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.DIVIDED), 0.125f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOW); - AlleleHelper.instance.set(template, NOCTURNAL, true); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(DIAMOND, IRON, 3); - if (ExtraUtilities.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(ExtraUtilities.ID, "decorativeBlock1"), 5); - }), - CAELESTIS(GT_BranchDefinition.THAUMIC, "Caelestis", true, new Color(0xF0F0F0), new Color(0xDCDCDC), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.CAELESTISRED), 0.60f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.CAELESTISBLUE), 0.60f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.CAELESTISGREEN), 0.60f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOW); - AlleleHelper.instance.set(template, NOCTURNAL, true); - }, dis -> dis.registerMutation(DIAMOND, DIVIDED, 10)), - SPARKELING(GT_BranchDefinition.THAUMIC, "NetherStar", true, new Color(0x7A007A), new Color(0xFFFFFF), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(MagicBees.ID, "miscResources", 1, 3), 0.20f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.SPARKLING), 0.125f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_2); - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, CAVE_DWELLING, true); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.NETHER); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectAggressive); - AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); - }, dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(MAGICBEES, "Withering"), getSpecies(MAGICBEES, "Draconic"), 1); - tMutation.requireResource(GregTech_API.sBlockGem3, 3); - tMutation.addMutationCondition(new GT_Bees.BiomeIDMutationCondition(9, "END Biome")); // sky end biome - }), - - ESSENTIA(GT_BranchDefinition.THAUMIC, "Essentia", true, new Color(0x7A007A), new Color(0xFFFFFF), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(MagicBees.ID, "miscResources", 1, 3), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - }, template -> { - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_2); - AlleleHelper.instance.set(template, CAVE_DWELLING, true); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.VANILLA); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectReanimation); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(SHADOWMETAL, SPARKELING, 5); - if (Thaumcraft.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 6); - }), - - DRAKE(GT_BranchDefinition.THAUMIC, "Drake", true, new Color(0x100322), new Color(0x7A007A), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.DRACONIC), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.AWAKENEDDRACONIUM), 0.20f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setJubilanceProvider(GT_JubilanceMegaApiary.instance); - }, template -> { - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_3); - AlleleHelper.instance.set(template, CAVE_DWELLING, false); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.END); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectDrunkard); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(ESSENTIA, THAUMINITE, 5); - GregTech_API.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTech_API.sBlockCasings5, 8)); - }), - - // radioctive - URANIUM(GT_BranchDefinition.RADIOACTIVE, "Uranium", true, new Color(0x19AF19), new Color(0x169E16), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.URANIUM), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(COLD); - beeSpecies.setNocturnal(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Avenging"), PLATINUM, 3); - tMutation.requireResource(GregTech_API.sBlockMetal7, 14); - }), - PLUTONIUM(GT_BranchDefinition.RADIOACTIVE, "Plutonium", true, new Color(0x570000), new Color(0x240000), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.LEAD), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.PLUTONIUM), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(URANIUM, EMERALD, 3); - tMutation.requireResource(GregTech_API.sBlockMetal5, 13); - }), - NAQUADAH(GT_BranchDefinition.RADIOACTIVE, "Naquadah", false, new Color(0x003300), new Color(0x002400), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.NAQUADAH), 0.15f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(PLUTONIUM, IRIDIUM, 3); - tMutation.requireResource(GregTech_API.sBlockMetal4, 12); - }), - NAQUADRIA(GT_BranchDefinition.RADIOACTIVE, "Naquadria", false, new Color(0x000000), new Color(0x002400), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SLAG), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.NAQUADAH), 0.20f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.NAQUADRIA), 0.15f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(PLUTONIUM, IRIDIUM, 8, 10); - tMutation.requireResource(GregTech_API.sBlockMetal4, 15); - }), - DOB(GT_BranchDefinition.RADIOACTIVE, "DOB", false, new Color(0x003300), new Color(0x002400), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.DOB), 0.75f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(NAQUADAH, THAUMIUMSHARD, 2); - if (AdvancedSolarPanel.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(AdvancedSolarPanel.ID, "BlockAdvSolarPanel"), 2); - tMutation.addMutationCondition(new GT_Bees.BiomeIDMutationCondition(9, "END Biome")); // sky end biome - }), - THORIUM(GT_BranchDefinition.RADIOACTIVE, "Thorium", false, new Color(0x005000), new Color(0x001E00), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.THORIUM), 0.75f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(COLD); - beeSpecies.setNocturnal(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - }, dis -> { - IMutationCustom tMutation = dis.registerMutation(COAL, URANIUM, 3) - .setIsSecret(); - tMutation.requireResource(GregTech_API.sBlockMetal7, 5); - }), - LUTETIUM(GT_BranchDefinition.RADIOACTIVE, "Lutetium", false, new Color(0xE6FFE6), new Color(0xFFFFFF), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.LUTETIUM), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - }, dis -> { - IMutationCustom tMutation = dis.registerMutation(THORIUM, getSpecies(EXTRABEES, "rotten"), 1) - .setIsSecret(); - tMutation.requireResource(GregTech_API.sBlockMetal4, 3); - }), - AMERICIUM(GT_BranchDefinition.RADIOACTIVE, "Americium", false, new Color(0xE6E6FF), new Color(0xC8C8C8), - beeSpecies -> { - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.AMERICIUM), 0.075f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - // Makes it only work in the Mega Apiary NOTE: COMB MUST BE SPECIALITY COMB - beeSpecies.setJubilanceProvider(GT_JubilanceMegaApiary.instance); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - }, dis -> { - IMutationCustom tMutation = dis.registerMutation(LUTETIUM, CHROME, 5, 4) - .setIsSecret(); - GregTech_API.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTech_API.sBlockMachines, 32020)); - }), - NEUTRONIUM(GT_BranchDefinition.RADIOACTIVE, "Neutronium", false, new Color(0xFFF0F0), new Color(0xFAFAFA), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.NEUTRONIUM), 0.02f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - AlleleHelper.instance.set(template, NOCTURNAL, true); - }, dis -> { - IMutationCustom tMutation = dis.registerMutation(NAQUADRIA, AMERICIUM, 2, 2) - .setIsSecret(); - tMutation.requireResource(GregTech_API.sBlockMetal5, 2); - }), - // Twilight - NAGA(GT_BranchDefinition.TWILIGHT, "Naga", true, new Color(0x0D5A0D), new Color(0x28874B), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SALISMUNDUS), 0.02f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.NAGA), 0.10f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(MAGICBEES, "Eldritch"), getSpecies(FORESTRY, "Imperial"), 8); - tMutation.restrictHumidity(DAMP); - }), - LICH(GT_BranchDefinition.TWILIGHT, "Lich", true, new Color(0xC5C5C5), new Color(0x5C605E), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SALISMUNDUS), 0.04f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.LICH), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(MAGICBEES, "Supernatural"), NAGA, 7); - tMutation.restrictHumidity(ARID); - }), - HYDRA(GT_BranchDefinition.TWILIGHT, "Hydra", true, new Color(0x872836), new Color(0xB8132C), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SALISMUNDUS), 0.06f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.HYDRA), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(LICH, getSpecies(MAGICBEES, "TCFire"), 6); - tMutation.addMutationCondition(new GT_Bees.BiomeIDMutationCondition(138, "Undergarden")); // undergarden biome - }), - URGHAST(GT_BranchDefinition.TWILIGHT, "UrGhast", true, new Color(0xA7041C), new Color(0x7C0618), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SALISMUNDUS), 0.08f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.URGHAST), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setHasEffect(); - beeSpecies.setNocturnal(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FAST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(HYDRA, THAUMIUMDUST, 5); - if (Thaumcraft.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCosmeticSolid"), 4); - tMutation.restrictTemperature(HELLISH); - }), - SNOWQUEEN(GT_BranchDefinition.TWILIGHT, "SnowQueen", true, new Color(0xD02001), new Color(0x9C0018), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SALISMUNDUS), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.SNOWQUEEN), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(ICY); - beeSpecies.setHasEffect(); - beeSpecies.setNocturnal(); - }, template -> {}, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(URGHAST, SALISMUNDUS, 4); - if (ThaumicBases.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(ThaumicBases.ID, "blockSalisMundus"), 0); - tMutation.restrictTemperature(ICY); - }), - // HEE - ENDDUST(GT_BranchDefinition.HEE, "End Dust", true, new Color(0xCC00FA), new Color(0x003A7D), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ENDDUST), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.NORMAL), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Ended"), STAINLESSSTEEL, 8); - - tMutation.restrictHumidity(ARID); - if (HardcoreEnderExpansion.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "end_powder_ore"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(1, "End")); // End Dim - }), - ENDIUM(GT_BranchDefinition.HEE, "Endium", true, new Color(0xa0ffff), new Color(0x2F5A6C), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ENDIUM), 0.10f); - beeSpecies.addSpecialty(GT_Bees.propolis.getStackForType(PropolisType.Endium), 0.15f); - beeSpecies.addSpecialty(GT_Bees.drop.getStackForType(DropType.ENDERGOO), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.NORMAL), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Ended"), THAUMIUMDUST, 8); - tMutation.restrictHumidity(ARID); - if (HardcoreEnderExpansion.isModLoaded()) tMutation.requireResource("blockHeeEndium"); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(1, "End")); // End Dim - }), - STARDUST(GT_BranchDefinition.HEE, "Star Dust", true, new Color(0xffff00), new Color(0xDCBE13), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.STARDUST), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, GT_Bees.speedBlinding); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - AlleleHelper.instance.set(template, FLOWERING, Flowering.SLOWER); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Ended"), ZINC, 8); - tMutation.restrictHumidity(ARID); - if (HardcoreEnderExpansion.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "stardust_ore"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(1, "End")); // End Dim - }), - ECTOPLASMA(GT_BranchDefinition.HEE, "Ectoplasma", true, new Color(0xDCB0E5), new Color(0x381C40), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ECTOPLASMA), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(FORESTRY, "Ended"), ENDDUST, 5); - tMutation.restrictHumidity(ARID); - if (HardcoreEnderExpansion.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "spooky_log"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(1, "End")); // End Dim - }), - ARCANESHARDS(GT_BranchDefinition.HEE, "Arcane Shards", true, new Color(0x9010AD), new Color(0x333D82), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ARCANESHARD), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONG); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(THAUMIUMSHARD, ENDDUST, 5); - tMutation.restrictHumidity(ARID); - if (HardcoreEnderExpansion.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "laboratory_floor"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(1, "End")); // End Dim - }), - DRAGONESSENCE(GT_BranchDefinition.HEE, "Dragonessence", true, new Color(0xFFA12B), new Color(0x911ECE), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.DRAGONESSENCE), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectBeatific); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_3); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_3); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(ECTOPLASMA, ARCANESHARDS, 4); - tMutation.restrictHumidity(ARID); - if (HardcoreEnderExpansion.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "essence_altar"), 1); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(1, "End")); // End Dim - }), - FIREESSENCE(GT_BranchDefinition.HEE, "Fireessence", true, new Color(0xD41238), new Color(0xFFA157), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.FIREESSENSE), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.ELONGATED); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectIgnition); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_3); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.DOWN_3); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(FIRESTONE, ARCANESHARDS, 4); - tMutation.restrictHumidity(ARID); - if (HardcoreEnderExpansion.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "essence_altar"), 2); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(1, "End")); // End Dim - }), - ENDERMANHEAD(GT_BranchDefinition.HEE, "EndermanHead", true, new Color(0x161616), new Color(0x6200e7), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ENDERMAN), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); - AlleleHelper.instance.set(template, EFFECT, getEffect(EXTRABEES, "teleport")); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.UP_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.UP_1); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(ENDERIUM, STARDUST, 4); - tMutation.restrictHumidity(ARID); - if (HardcoreEnderExpansion.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "ender_goo"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(1, "End")); // End Dim - }), - SILVERFISH(GT_BranchDefinition.HEE, "Silverfisch", true, new Color(0xEE053D), new Color(0x000000), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.SILVERFISH), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); - AlleleHelper.instance.set(template, EFFECT, getEffect(MAGICBEES, "SlowSpeed")); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.DOWN_1); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(ECTOPLASMA, STARDUST, 5); - tMutation.restrictHumidity(ARID); - if (HardcoreEnderExpansion.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(HardcoreEnderExpansion.ID, "ender_goo"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(1, "End")); // End Dim - }), - RUNE(GT_BranchDefinition.HEE, "Rune", true, new Color(0xE31010), new Color(0x0104D9), beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(Forestry.ID, "beeCombs", 1, 8), 0.30f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.RUNEI), 0.025f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.RUNEII), 0.0125f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, LIFESPAN, GT_Bees.superLife); - AlleleHelper.instance.set(template, EFFECT, getEffect(MAGICBEES, "SlowSpeed")); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.NONE); - }, dis -> { - IMutationCustom tMutation = dis.registerMutation(DRAGONESSENCE, STARDUST, 2) - .setIsSecret(); - tMutation.restrictHumidity(ARID); - if (EnderStorage.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(EnderStorage.ID, "enderChest"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(1, "End")); // End Dim - }), - // Walrus Bee, 100% Combchance, Parents: Catty and Watery - WALRUS(GT_BranchDefinition.PLANET, "Walrus", true, new Color(0xD6D580), new Color(0xB5CFC9), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.WALRUS), 1.00f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FASTEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, NOCTURNAL, true); - }, dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(MAGICBEES, "Watery"), getSpecies(MAGICBEES, "Catty"), 45, 2); - if (ExtraCells2.isModLoaded()) { - tMutation.requireResource(GameRegistry.findBlock(ExtraCells2.ID, "walrus"), 0); - } - }), - MACHINIST(GT_BranchDefinition.ORGANIC, "Machinist", true, new Color(85, 37, 130), new Color(253, 185, 39), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.MACHINIST), 0.2f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.FASTEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, GT_Flowers.FLAMING); - AlleleHelper.instance.set(template, FERTILITY, Fertility.MAXIMUM); - AlleleHelper.instance.set(template, EFFECT, getEffect(GREGTECH, "MachineBoost")); - }, dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(FORESTRY, "Industrious"), getSpecies(FORESTRY, "Imperial"), 1); - tMutation.addMutationCondition(new GT_Bees.ActiveGTMachineMutationCondition()); - }), - // Space Bees - SPACE(GT_BranchDefinition.SPACE, "Space", true, new Color(0x003366), new Color(0xC0C0C0), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SPACE), 0.02f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - }, template -> {}, dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(FORESTRY, "Industrious"), getSpecies(FORESTRY, "Heroic"), 10); - tMutation.restrictTemperature(ICY); - }), - METEORICIRON(GT_BranchDefinition.SPACE, "MeteoricIron", true, new Color(0x321928), new Color(0x643250), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SPACE), 0.04f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.METEORICIRON), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - beeSpecies.setNocturnal(); - }, template -> {}, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(SPACE, IRON, 9); - tMutation.requireResource(GregTech_API.sBlockMetal4, 7); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(28, "Moon")); // Moon Dim - }), - DESH(GT_BranchDefinition.SPACE, "Desh", false, new Color(0x323232), new Color(0x282828), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SPACE), 0.06f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.DESH), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - beeSpecies.setNocturnal(); - }, template -> AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectIgnition), new Consumer<>() { - - @Override - public void accept(GT_BeeDefinition dis) { - IBeeMutationCustom tMutation = dis.registerMutation(MARS, TITANIUM, 9); - tMutation.requireResource(GregTech_API.sBlockMetal2, 12); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(29, "Mars")); // Mars Dim - } - }), - LEDOX(GT_BranchDefinition.SPACE, "Ledox", false, new Color(0x0000CD), new Color(0x0074FF), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SPACE), 0.10f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.LEDOX), 0.10f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(COLD); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, EFFECT, getEffect(EXTRABEES, "freezing")), new Consumer<>() { - - @Override - public void accept(GT_BeeDefinition dis) { - IBeeMutationCustom tMutation = dis.registerMutation(CALLISTO, LEAD, 7); - if (NewHorizonsCoreMod.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.Ledox"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(35, "Europa")); // Europa Dim - } - }), - CALLISTOICE(GT_BranchDefinition.SPACE, "CallistoIce", false, new Color(0x0074FF), new Color(0x1EB1FF), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SPACE), 0.10f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.CALLISTOICE), 0.10f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, EFFECT, getEffect(EXTRABEES, "freezing")), new Consumer<>() { - - @Override - public void accept(GT_BeeDefinition dis) { - IBeeMutationCustom tMutation = dis.registerMutation(CALLISTO, getSpecies(EXTRABEES, "freezing"), 7); - if (NewHorizonsCoreMod.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.CallistoColdIce"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(45, "Callisto")); // Callisto - // Dim - } - }), - MYTRYL(GT_BranchDefinition.SPACE, "Mytryl", false, new Color(0xDAA520), new Color(0xF26404), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SPACE), 0.16f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.MYTRYL), 0.10f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> {}, new Consumer<>() { - - @Override - public void accept(GT_BeeDefinition dis) { - IBeeMutationCustom tMutation = dis.registerMutation(IO, MITHRIL, 6); - if (NewHorizonsCoreMod.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.Mytryl"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(36, "IO")); // IO Dim - } - }), - QUANTIUM(GT_BranchDefinition.SPACE, "Quantium", false, new Color(0x00FF00), new Color(0x00D10B), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SPACE), 0.16f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.QUANTIUM), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> {}, new Consumer<>() { - - @Override - public void accept(GT_BeeDefinition dis) { - IBeeMutationCustom tMutation = dis.registerMutation(VENUS, OSMIUM, 6); - if (NewHorizonsCoreMod.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.Quantinum"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(39, "Venus")); // Venus Dim - } - }), - ORIHARUKON(GT_BranchDefinition.SPACE, "Oriharukon", false, new Color(0x228B22), new Color(0x677D68), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SPACE), 0.26f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.ORIHARUKON), 0.10f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(COLD); - beeSpecies.setHasEffect(); - }, template -> {}, new Consumer<>() { - - @Override - public void accept(GT_BeeDefinition dis) { - IBeeMutationCustom tMutation = dis.registerMutation(LEAD, OBERON, 5); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "metalsblock"), 6); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(46, "Oberon")); // Oberon Dim - } - }), - INFUSEDGOLD(GT_BranchDefinition.SPACE, "Infused Gold", false, new Color(0x80641E), new Color(0xFFC83C), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.GOLD), 0.20f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.INFUSEDGOLD), 0.30f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> {}, new Consumer<>() { - - @Override - public void accept(GT_BeeDefinition dis) { - IBeeMutationCustom tMutation = dis.registerMutation(GOLD, HAUMEA, 5); - tMutation.requireResource(GregTech_API.sBlockMetal3, 10); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(83, "Haumea")); // Haumea Dim - } - }), - MYSTERIOUSCRYSTAL(GT_BranchDefinition.SPACE, "MysteriousCrystal", false, new Color(0x3CB371), new Color(0x16856C), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SPACE), 0.42f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.MYSTERIOUSCRYSTAL), 0.30f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> {}, new Consumer<>() { - - @Override - public void accept(GT_BeeDefinition dis) { - IBeeMutationCustom tMutation = dis.registerMutation(ENCELADUS, EMERALD, 3); - if (NewHorizonsCoreMod.isModLoaded()) tMutation - .requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.MysteriousCrystal"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(41, "Enceladus")); // Enceladus - // Dim - } - }), - BLACKPLUTONIUM(GT_BranchDefinition.SPACE, "BlackPlutonium", false, new Color(0x000000), new Color(0x323232), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SPACE), 0.68f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.BLACKPLUTONIUM), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> {}, new Consumer<>() { - - @Override - public void accept(GT_BeeDefinition dis) { - IBeeMutationCustom tMutation = dis.registerMutation(PLUTO, PLUTONIUM, 2); - if (NewHorizonsCoreMod.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.BlackPlutonium"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(49, "Pluto")); // Pluto Dim - } - }), - TRINIUM(GT_BranchDefinition.SPACE, "Trinium", false, new Color(0xB0E0E6), new Color(0xC8C8D2), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.TRINIUM), 0.75f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.QUANTIUM), 0.10f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(COLD); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, SPEED, GT_Bees.speedBlinding), new Consumer<>() { - - @Override - public void accept(GT_BeeDefinition dis) { - IBeeMutationCustom tMutation = dis.registerMutation(ENCELADUS, IRIDIUM, 4); - tMutation.requireResource(GregTech_API.sBlockMetal4, 9); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(41, "Enceladus")); // Enceladus Dim - } - }), - // Planet Line - MOON(GT_BranchDefinition.PLANET, "Moon", false, new Color(0x373735), new Color(0x7E7E78), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.MOON), 0.35f); - if (NewHorizonsCoreMod.isModLoaded()) - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MoonStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(COLD); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(SPACE, CLAY, 25); - if (GalacticraftCore.isModLoaded()) { - tMutation.requireResource(GameRegistry.findBlock(GalacticraftCore.ID, "tile.moonBlock"), 4); - } - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(28, "Moon")); // Moon Dim - }), - MARS(GT_BranchDefinition.PLANET, "Mars", false, new Color(0x220D05), new Color(0x3A1505), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.MARS), 0.35f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MarsStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(MOON, IRON, 20); - if (GalacticraftMars.isModLoaded()) { - tMutation.requireResource(GameRegistry.findBlock(GalacticraftMars.ID, "tile.mars"), 5); - } - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(29, "Mars")); // Mars Dim - }), - PHOBOS(GT_BranchDefinition.PLANET, "Phobos", true, new Color(0x220D05), new Color(0x7a5706), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.MARS), 0.25f); - if (NewHorizonsCoreMod.isModLoaded()) beeSpecies - .addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.PhobosStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - beeSpecies.setNocturnal(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(MARS, MOON, 20); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "phobosblocks"), 2); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(38, "Phobos")); // Phobos Dim - }), - DEIMOS(GT_BranchDefinition.PLANET, "Deimos", true, new Color(0x220D05), new Color(0x7a3206), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.MARS), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.DeimosStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(HOT); - beeSpecies.setNocturnal(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(MARS, SPACE, 20); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "deimosblocks"), 1); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(40, "Deimos")); // Deimos Dim - }), - CERES(GT_BranchDefinition.PLANET, "Ceres", true, new Color(0x3ca5b7), new Color(0x1e7267), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.JUPITER), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CeresStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - beeSpecies.setNocturnal(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(MARS, METEORICIRON, 20); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "ceresblocks"), 1); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(42, "Ceres")); // Ceres Dim - }), - JUPITER(GT_BranchDefinition.PLANET, "Jupiter", false, new Color(0x734B2E), new Color(0xD0CBC4), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.JUPITER), 0.35f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CallistoStoneDust", 1, 0), 0.05f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CallistoIceDust", 1, 0), 0.05f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.IoStoneDust", 1, 0), 0.05f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EuropaStoneDust", 1, 0), 0.05f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EuropaIceDust", 1, 0), 0.05f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.GanymedeStoneDust", 1, 0), 0.05f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(MARS, DESH, 15); - if (NewHorizonsCoreMod.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.Ledox"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(30, "Asteroids")); // Asteroid Dim - }), - IO(GT_BranchDefinition.PLANET, "IO", true, new Color(0x734B2E), new Color(0xe5701b), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.JUPITER), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.IoStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, getSpecies(EXTRABEES, "volcanic"), 15); - tMutation.restrictTemperature(HELLISH); - if (GalaxySpace.isModLoaded()) tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "ioblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(36, "IO")); // IO Dim - }), - EUROPA(GT_BranchDefinition.PLANET, "Europa", true, new Color(0x5982ea), new Color(0x0b36a3), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.JUPITER), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EuropaStoneDust", 1, 0), 0.10f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EuropaIceDust", 1, 0), 0.10f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, IRON, 15); - tMutation.restrictTemperature(ICY); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "europagrunt"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(35, "Europa")); // Europa Dim - }), - GANYMEDE(GT_BranchDefinition.PLANET, "Ganymede", true, new Color(0x3d1b10), new Color(0x190c07), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.JUPITER), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.GanymedeStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(COLD); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, TITANIUM, 15); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "ganymedeblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(43, "Ganymede")); // Ganymede Dim - }), - CALLISTO(GT_BranchDefinition.PLANET, "Callisto", true, new Color(0x0f333d), new Color(0x0d84a5), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.JUPITER), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CallistoStoneDust", 1, 0), 0.10f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CallistoIceDust", 1, 0), 0.10f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, getSpecies(EXTRABEES, "artic"), 15); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "callistoblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(45, "Callisto")); // Callisto Dim - }), - SATURN(GT_BranchDefinition.PLANET, "Saturn", false, new Color(0xD2A472), new Color(0xF8C37B), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SATURN), 0.35f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TitanStoneDust", 1, 0), 0.05f); - beeSpecies - .addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EnceladusStoneDust", 1, 0), 0.05f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EnceladusIceDust", 1, 0), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(COLD); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, LEDOX, 25, 2); - if (NewHorizonsCoreMod.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.Quantinum"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(30, "Asteriods")); // Asteriods Dim - }), - ENCELADUS(GT_BranchDefinition.PLANET, "Enceladus", true, new Color(0xD2A472), new Color(0x193fa0), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SATURN), 0.25f); - beeSpecies - .addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EnceladusStoneDust", 1, 0), 0.10f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EnceladusIceDust", 1, 0), 0.10f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(SATURN, CHROME, 25, 2); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "enceladusblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(41, "Enceladus")); // Enceladus Dim - }), - TITAN(GT_BranchDefinition.PLANET, "Titan", true, new Color(0xa0641b), new Color(0x7c1024), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SATURN), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TitanStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(SATURN, NICKEL, 25, 2); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "titanblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(44, "Titan")); // Titan Dim - }), - URANUS(GT_BranchDefinition.PLANET, "Uranus", false, new Color(0x75C0C9), new Color(0x84D8EC), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.URANUS), 0.35f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MirandaStoneDust", 1, 0), 0.05f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.OberonStoneDust", 1, 0), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(SATURN, TRINIUM, 10); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "metalsblock"), 6); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(30, "Asteroids")); // Asteroids Dim - }), - MIRANDA(GT_BranchDefinition.PLANET, "Miranda", true, new Color(0x75C0C9), new Color(0x0d211c), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.URANUS), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MirandaStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(URANUS, TIN, 10); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "mirandablocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(86, "Miranda")); // Miranda Dim - }), - OBERON(GT_BranchDefinition.PLANET, "Oberon", true, new Color(0x4A4033), new Color(0xB5A288), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.URANUS), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.OberonStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(ICY); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(URANUS, IRIDIUM, 10); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "oberonblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(46, "Oberon")); // Oberon Dim - }), - NEPTUNE(GT_BranchDefinition.PLANET, "Neptune", false, new Color(0x334CFF), new Color(0x576DFF), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.NEPTUNE), 0.35f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.ProteusStoneDust", 1, 0), 0.05f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TritonStoneDust", 1, 0), 0.05f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(COLD); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(URANUS, ORIHARUKON, 7); - if (NewHorizonsCoreMod.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(NewHorizonsCoreMod.ID, "tile.MysteriousCrystal"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(30, "Asteroids")); // Asteroids Dim - }), - PROTEUS(GT_BranchDefinition.PLANET, "Proteus", true, new Color(0x334CFF), new Color(0x592610), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.NEPTUNE), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.ProteusStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(COLD); - beeSpecies.setNocturnal(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(NEPTUNE, COPPER, 7); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "proteusblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(47, "Proteus")); // Proteus Dim - }), - TRITON(GT_BranchDefinition.PLANET, "Triton", true, new Color(0x334CFF), new Color(0x421118), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.NEPTUNE), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TritonStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(NEPTUNE, GOLD, 7); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "tritonblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(48, "Triton")); // Triton Dim - }), - PLUTO(GT_BranchDefinition.PLANET, "Pluto", false, new Color(0x34271E), new Color(0x69503D), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.PLUTO), 0.35f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.PlutoStoneDust", 1, 0), 0.10f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.PlutoIceDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(NEPTUNE, PLUTONIUM, 5); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "plutoblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(49, "Pluto")); // Pluto Dim - }), - HAUMEA(GT_BranchDefinition.PLANET, "Haumea", false, new Color(0x1C1413), new Color(0x392B28), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.HAUMEA), 0.35f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.HaumeaStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(ICY); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(PLUTO, NAQUADAH, 7, 2); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "haumeablocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(83, "Haumea")); // Haumea Dim - }), - MAKEMAKE(GT_BranchDefinition.PLANET, "MakeMake", false, new Color(0x301811), new Color(0x120A07), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.MAKEMAKE), 0.35f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.MakeMakeStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(PLUTO, NAQUADRIA, 7, 2); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "makemakegrunt"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(25, "MakeMake")); // MakeMake Dim - }), - CENTAURI(GT_BranchDefinition.PLANET, "Centauri", false, new Color(0x2F2A14), new Color(0xB06B32), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.CENTAURI), 0.35f); - beeSpecies - .addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CentauriASurfaceDust", 1, 0), 0.05f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(MAKEMAKE, DESH, 3); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "acentauribbgrunt"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(33, "Kuiper Belt")); // Kuiper Belt Dim - }), - ACENTAURI(GT_BranchDefinition.PLANET, "aCentauri", false, new Color(0x2F2A14), new Color(0xa01e14), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.CENTAURI), 0.25f); - beeSpecies - .addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.CentauriASurfaceDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), new Consumer<>() { - - @Override - public void accept(GT_BeeDefinition dis) { - IBeeMutationCustom tMutation = dis.registerMutation(CENTAURI, INFINITYCATALYST, 3); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "acentauribbgrunt"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(31, "aCentauri")); // aCentauri Dim - } - }), - TCETI(GT_BranchDefinition.PLANET, "tCeti", false, new Color(0x46241A), new Color(0x7B412F), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.TCETI), 0.35f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TCetiEStoneDust", 1, 0), 0.05f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(MAKEMAKE, HAUMEA, 5, 2); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "tcetieblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(33, "Kuiper Belt")); // Kuiper Belt Dim - }), - TCETIE(GT_BranchDefinition.PLANET, "tCetiE", false, new Color(0x2d561b), new Color(0x0c0f60), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.TCETI), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TCetiEStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(TCETI, getSpecies(MAGICBEES, "TCWater"), 5, 2); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "tcetieblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(85, "tCeti E")); // tCeti E Dim - }), - // Parents: TCETI and TCETIE, 25% combchance, needs Damp Humidity and Normal temperature. Is Mycophilic - SEAWEED(GT_BranchDefinition.PLANET, "SeaWeed", true, new Color(0xCBCBCB), new Color(0x83FF83), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.SEAWEED), 0.25f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.TCetiEStoneDust", 1, 0), 0.15f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(EnumTemperature.NORMAL); - beeSpecies.setHasEffect(); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGER); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.DOWN_1); - AlleleHelper.instance.set(template, HUMIDITY_TOLERANCE, Tolerance.DOWN_1); - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectMycophilic); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(TCETI, TCETIE, 5, 2); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "tcetieblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(85, "tCeti E")); // tCeti E Dim - }), - - BARNARDA(GT_BranchDefinition.PLANET, "Barnarda", false, new Color(0x0D5A0D), new Color(0xE6C18D), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.BARNARDA), 0.35f); - beeSpecies - .addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.BarnardaEStoneDust", 1, 0), 0.05f); - beeSpecies - .addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.BarnardaFStoneDust", 1, 0), 0.05f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(MAKEMAKE, THORIUM, 3, 2); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "barnardaEgrunt"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(33, "Kuiper Belt")); // Kuiper Belt Dim - }), - BARNARDAC(GT_BranchDefinition.PLANET, "BarnardaC", false, new Color(0x0D5A0D), new Color(0x473f0a), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.BARNARDA), 0.25f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - }, template -> { - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - AlleleHelper.instance.set(template, EFFECT, getEffect(GREGTECH, "Treetwister")); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(BARNARDA, AMERICIUM, 3, 2); - if (GalaxySpace.isModLoaded()) { - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "barnardaEgrunt"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(32, "Barnarda C")); // Barnarda C Dim - } - }), - BARNARDAE(GT_BranchDefinition.PLANET, "BarnardaE", false, new Color(0x0D5A0D), new Color(0x4c1f0a), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.BARNARDA), 0.25f); - beeSpecies - .addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.BarnardaEStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(BARNARDA, DIVIDED, 3, 2); - if (GalaxySpace.isModLoaded()) { - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "barnardaEgrunt"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(81, "Barnard E")); // "Barnard E Dim - } - }), - BARNARDAF(GT_BranchDefinition.PLANET, "BarnardaF", false, new Color(0x0D5A0D), new Color(0x1e0b49), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.BARNARDA), 0.25f); - beeSpecies - .addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.BarnardaFStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(BARNARDA, NEUTRONIUM, 3, 2); - if (GalaxySpace.isModLoaded()) { - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "barnardaFgrunt"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(82, "Barnard F")); // "Barnard F Dim - } - }), - VEGA(GT_BranchDefinition.PLANET, "Vega", false, new Color(0x1A2036), new Color(0xB5C0DE), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.VEGA), 0.35f); - beeSpecies.addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.VegaBStoneDust", 1, 0), 0.05f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(COLD); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(MAKEMAKE, NAQUADAH, 2); - if (GalaxySpace.isModLoaded()) { - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "vegabgrunt"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(33, "Kuiper Belt")); // Kuiper Belt - // Dim - } - }), - VEGAB(GT_BranchDefinition.PLANET, "VegaB", false, new Color(0x1A2036), new Color(0x81e261), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.VEGA), 0.35f); - if (NewHorizonsCoreMod.isModLoaded()) beeSpecies - .addSpecialty(GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.VegaBStoneDust", 1, 0), 0.10f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(COLD); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(VEGA, NAQUADRIA, 2); - if (GalaxySpace.isModLoaded()) { - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "vegabgrunt"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(84, "VegaB")); // VegaB Dim - } - }), - MERCURY(GT_BranchDefinition.PLANET, "Mercury", false, new Color(0x4A4033), new Color(0xB5A288), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.MERCURY), 0.35f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, TUNGSTEN, 25, 2); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "mercuryblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(37, "Mercury")); // Mercury Dim - }), - VENUS(GT_BranchDefinition.PLANET, "Venus", false, new Color(0x4A4033), new Color(0xB5A288), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.VENUS), 0.35f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(JUPITER, MITHRIL, 25, 2); - if (GalaxySpace.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(GalaxySpace.ID, "venusblocks"), 0); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(39, "Venus")); // Venus Dim - }), - - // Infinity Line - COSMICNEUTRONIUM(GT_BranchDefinition.PLANET, "CosmicNeutronium", false, new Color(0x484848), new Color(0x323232), - beeSpecies -> { - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.COSMICNEUTRONIUM), 0.375f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - // Makes it only work in the Mega Apiary NOTE: COMB MUST BE SPECIALITY COMB - beeSpecies.setJubilanceProvider(GT_JubilanceMegaApiary.instance); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(NEUTRONIUM, BARNARDAF, 7, 10); - if (Avaritia.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(Avaritia.ID, "Resource_Block"), 0); - }), - INFINITYCATALYST(GT_BranchDefinition.PLANET, "InfinityCatalyst", false, new Color(0xFFFFFF), new Color(0xFFFFFF), - beeSpecies -> { - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.INFINITYCATALYST), 0.015f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(HELLISH); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - // Makes it only work in the Mega Apiary NOTE: COMB MUST BE SPECIALITY COMB - beeSpecies.setJubilanceProvider(GT_JubilanceMegaApiary.instance); - }, template -> { - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST); - AlleleHelper.instance.set(template, EFFECT, getEffect(EXTRABEES, "blindness")); - }, dis -> { - IMutationCustom tMutation = dis.registerMutation(DOB, COSMICNEUTRONIUM, 3, 10) - .setIsSecret(); - if (Avaritia.isModLoaded()) { - tMutation.requireResource(GameRegistry.findBlock(Avaritia.ID, "Resource_Block"), 1); - } - }), - INFINITY(GT_BranchDefinition.PLANET, "Infinity", false, new Color(0xFFFFFF), new Color(0xFFFFFF), beeSpecies -> { - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.INFINITY), 0.015f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - // Makes it only work in the Mega Apiary NOTE: COMB MUST BE SPECIALITY COMB - beeSpecies.setJubilanceProvider(GT_JubilanceMegaApiary.instance); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(INFINITYCATALYST, COSMICNEUTRONIUM, 1, 10); - if (AvaritiaAddons.isModLoaded()) { - tMutation.requireResource(GameRegistry.findBlock(AvaritiaAddons.ID, "InfinityChest"), 0); - } - }), - KEVLAR(GT_BranchDefinition.IC2, "Kevlar", false, new Color(0x2d542f), new Color(0xa2baa3), beeSpecies -> { - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.KEVLAR), 0.075f); - beeSpecies.addSpecialty(MaterialsKevlar.Kevlar.getNuggets(1), 0.01f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setTemperature(COLD); - beeSpecies.setHasEffect(); - beeSpecies.setJubilanceProvider(GT_JubilanceMegaApiary.instance); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - AlleleHelper.instance.set(template, EFFECT, AlleleEffect.effectSnowing); - AlleleHelper.instance.set(template, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(template, NOCTURNAL, true); - AlleleHelper.instance.set(template, FLOWER_PROVIDER, Flowers.SNOW); - AlleleHelper.instance.set(template, FLOWERING, Flowering.AVERAGE); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(OIL, INFINITYCATALYST, 4); - // UHV Replicator (UU-Matter) - GregTech_API.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTech_API.sBlockMachines, 11003)); - }), - - // Noble Gas Line - // Helium bee, Humidity: normal, Temperature: Icy, Parents: Space & Mars, Mutationrate: 10%, Combrate: 50% - HELIUM(GT_BranchDefinition.NOBLEGAS, "Helium", false, new Color(0xFFA9FF), new Color(0xC8B8B4), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.HELIUM), 0.35f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(MAGICBEES, "Watery"), ENDDUST, 10); - tMutation.restrictTemperature(ICY); - }), - // Argon bee, Humidity: normal, Temperature: Icy, Parents: Helium & Phobos, Mutationrate: 8%, Combrate: 50% - ARGON(GT_BranchDefinition.NOBLEGAS, "Argon", false, new Color(0x89D9E1), new Color(0xBDA5C2), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.ARGON), 0.35f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(HELIUM, LICH, 8); - tMutation.restrictTemperature(ICY); - }), - // Neon bee, Humidity: normal, Temperature: Icy, Parents: Xenon & Ceres, Mutationrate: 6%, Combrate: 50% - NEON(GT_BranchDefinition.NOBLEGAS, "Neon", false, new Color(0xFFC826), new Color(0xFF7200), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.NEON), 0.35f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(ARGON, HYDRA, 6); - tMutation.restrictTemperature(ICY); - }), - // Krypton bee, Humidity: normal, Temperature: Icy, Parents: Neon & Jupiter, Mutationrate: 4%, Combrate: 50% - KRYPTON(GT_BranchDefinition.NOBLEGAS, "Krypton", false, new Color(0x8A97B0), new Color(0x160822), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.KRYPTON), 0.35f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(NEON, URGHAST, 4); - tMutation.restrictTemperature(ICY); - }), - // Xenon bee, Humidity: normal, Temperature: Icy, Parents: Argon & Deimos, Mutationrate: 6%, Combrate: 50% - XENON(GT_BranchDefinition.NOBLEGAS, "Xenon", false, new Color(0x8A97B0), new Color(0x160822), beeSpecies -> { - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.XENON), 0.525f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - // Makes it only work in the Mega Apiary NOTE: COMB MUST BE SPECIALITY COMB - beeSpecies.setJubilanceProvider(GT_JubilanceMegaApiary.instance); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(KRYPTON, SNOWQUEEN, 2); - tMutation.restrictTemperature(ICY); - }), - // Oxygen bee, Humidity: normal, Temperature: Icy, Parents: Space & Callisto, Mutationrate: 15%, Combrate: 50% - OXYGEN(GT_BranchDefinition.NOBLEGAS, "Oxygen", false, new Color(0xFFFFFF), new Color(0x8F8FFF), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.OXYGEN), 0.45f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.HYDROGEN), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(HELIUM, DRAGONESSENCE, 15); - tMutation.restrictTemperature(ICY); - }), - // Hydrogen bee, Humidity: normal, Temperature: Icy, Parents: Oxygen & Watery, Mutationrate: 15%, Combrate: 50% - HYDROGEN(GT_BranchDefinition.NOBLEGAS, "Oxygen", false, new Color(0xFFFFFF), new Color(0xFF1493), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.HYDROGEN), 0.45f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.NITROGEN), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(OXYGEN, getSpecies(MAGICBEES, "Watery"), 15); - tMutation.restrictTemperature(ICY); - }), - // Nitrogen bee, Humidity: normal, Temperature: Icy, Parents: Oxygen & Hydrogen, Mutationrate: 15%, Combrate: 50% - NITROGEN(GT_BranchDefinition.NOBLEGAS, "Nitrogen", false, new Color(0xFFC832), new Color(0xA52A2A), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.NITROGEN), 0.45f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.FLUORINE), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(OXYGEN, HYDROGEN, 15); - tMutation.restrictTemperature(ICY); - }), - // Fluorine bee, Humidity: normal, Temperature: Icy, Parents: Nitrogen & Hydrogen, Mutationrate: 15%, Combrate: 50% - FLUORINE(GT_BranchDefinition.NOBLEGAS, "Fluorine", false, new Color(0x86AFF0), new Color(0xFF6D00), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.FLUORINE), 0.45f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.OXYGEN), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(ICY); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(NITROGEN, HYDROGEN, 15); - tMutation.restrictTemperature(ICY); - }), - // Europium line, needed after fluorine definition - RAREEARTH(GT_BranchDefinition.RAREMETAL, "RareEarth", false, new Color(0x555643), new Color(0x343428), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.RAREEARTH), 0.20f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.NEODYMIUM), 0.05f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(NORMAL); - }, template -> AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST), - dis -> dis.registerMutation(FLUORINE, REDSTONE, 10)), - NEODYMIUM(GT_BranchDefinition.RAREMETAL, "Neodymium", false, new Color(0x555555), new Color(0x4F4F4F), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.RAREEARTH), 0.15f); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.NEODYMIUM), 0.15f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(HOT); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(RAREEARTH, IRON, 10); - tMutation.requireResource(GregTech_API.sBlockMetal5, 0); - }), - EUROPIUM(GT_BranchDefinition.RAREMETAL, "Europium", false, new Color(0xDAA0E2), new Color(0xAB7EB1), beeSpecies -> { - beeSpecies.addProduct(WerkstoffMaterialPool.EuropiumIIIOxide.get(OrePrefixes.dust, 1), 0.10F); - beeSpecies.addSpecialty(GT_Bees.combs.getStackForType(CombType.EUROPIUM), 0.075f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setTemperature(HOT); - beeSpecies.setNocturnal(); - // Makes it only work in the Mega Apiary NOTE: COMB MUST BE SPECIALITY COMB - beeSpecies.setJubilanceProvider(GT_JubilanceMegaApiary.instance); - }, template -> { - AlleleHelper.instance.set(template, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(template, LIFESPAN, Lifespan.LONGEST); - }, dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(NEODYMIUM, HYDROGEN, 5, 4); - // Compact fusion reactor mark 1 controller - GregTech_API.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTech_API.sBlockMachines, 32019)); - }), - // infused Shards line - AIR(GT_BranchDefinition.INFUSEDSHARD, "Air", false, new Color(0xFFFF7E), new Color(0x60602F), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.INFUSEDAER), 0.30f); - beeSpecies.setHumidity(DAMP); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis - .registerMutation(getSpecies(MAGICBEES, "Supernatural"), getSpecies(MAGICBEES, "Windy"), 15); - tMutation.restrictTemperature(HOT); - if (Thaumcraft.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 0); - }), - FIRE(GT_BranchDefinition.INFUSEDSHARD, "Fire", false, new Color(0xED3801), new Color(0x3B0E00), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.INFUSEDIGNIS), 0.30f); - beeSpecies.setHumidity(ARID); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(getSpecies(MAGICBEES, "Supernatural"), AIR, 15); - tMutation.restrictTemperature(HELLISH); - if (Thaumcraft.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 1); - }), - WATER(GT_BranchDefinition.INFUSEDSHARD, "Water", false, new Color(0x0090FF), new Color(0x002542), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.INFUSEDAQUA), 0.30f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(FIRE, AIR, 15); - tMutation.restrictTemperature(ICY); - if (Thaumcraft.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 2); - }), - EARTH(GT_BranchDefinition.INFUSEDSHARD, "Earth", false, new Color(0x008600), new Color(0x003300), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.INFUSEDTERRA), 0.30f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(WATER, FIRE, 15); - tMutation.restrictTemperature(WARM); - if (Thaumcraft.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 3); - }), - ORDER(GT_BranchDefinition.INFUSEDSHARD, "Order", false, new Color(0x8A97B0), new Color(0x5C5F62), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.INFUSEDORDO), 0.30f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(EARTH, FIRE, 15); - tMutation.restrictTemperature(ICY); - if (Thaumcraft.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 4); - }), - CHAOS(GT_BranchDefinition.INFUSEDSHARD, "Chaos", false, new Color(0x2E2E41), new Color(0x232129), beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.INFUSEDPERDITIO), 0.30f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(ORDER, FIRE, 15); - tMutation.restrictTemperature(ICY); - if (Thaumcraft.isModLoaded()) - tMutation.requireResource(GameRegistry.findBlock(Thaumcraft.ID, "blockCrystal"), 5); - }), - NETHERSHARD(GT_BranchDefinition.INFUSEDSHARD, "NetherShard", false, new Color(0xBE0135), new Color(0x350211), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.NETHERSHARD), 0.30f); - beeSpecies.setHumidity(ARID); - beeSpecies.setTemperature(HOT); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(CHAOS, FIRE, 15); - GregTech_API.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTech_API.sBlockGem3, 3)); - }), - ENDSHARD(GT_BranchDefinition.INFUSEDSHARD, "EnderShard", false, new Color(0x2E2E41), new Color(0x232129), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.ENDERSHARD), 0.30f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(NETHERSHARD, ENDDUST, 15); - tMutation.restrictTemperature(ICY); - GregTech_API.sGTCompleteLoad.add(() -> tMutation.requireResource(GregTech_API.sBlockGem1, 7)); - }), - // Organic branch 2.0 - UNKNOWNWATER(GT_BranchDefinition.ORGANIC, "UnknownLiquid", false, new Color(0x4333A5), new Color(0x36ABFF), - beeSpecies -> { - beeSpecies.addProduct(GT_Bees.combs.getStackForType(CombType.UNKNOWNLIQUID), 0.20f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), - dis -> dis.registerMutation(INFINITYCATALYST, MYSTERIOUSCRYSTAL, 5)), - // Endgame bees - JAEGERMEISTER(GT_BranchDefinition.ENDGAME, "JaegerMeister", false, new Color(0x05AD18), new Color(0xE7DAC3), - beeSpecies -> { - beeSpecies.addProduct(GT_ModHandler.getModItem(CropsPlusPlus.ID, "BppPotions", 1L, 8), 0.01f); - beeSpecies.setHumidity(EnumHumidity.NORMAL); - beeSpecies.setNocturnal(); - beeSpecies.setHasEffect(); - }, template -> AlleleHelper.instance.set(template, LIFESPAN, Lifespan.SHORTEST), dis -> { - IBeeMutationCustom tMutation = dis.registerMutation(INFINITYCATALYST, NAQUADRIA, 5); - tMutation.requireResource(GregTech_API.sBlockMachines, 4684); - tMutation.addMutationCondition(new GT_Bees.DimensionMutationCondition(100, "Deep Dark")); // Deep Dark - // dim - }); - - private final GT_BranchDefinition branch; - private final GT_AlleleBeeSpecies species; - private final Consumer mSpeciesProperties; - private final Consumer mAlleles; - private final Consumer mMutations; - private IAllele[] template; - private IBeeGenome genome; - - GT_BeeDefinition(GT_BranchDefinition branch, String binomial, boolean dominant, Color primary, Color secondary, - Consumer aSpeciesProperties, Consumer aAlleles, - Consumer aMutations) { - this.mAlleles = aAlleles; - this.mMutations = aMutations; - this.mSpeciesProperties = aSpeciesProperties; - String lowercaseName = this.toString() - .toLowerCase(Locale.ENGLISH); - String species = WordUtils.capitalize(lowercaseName); - - String uid = "gregtech.bee.species" + species; - String description = "for.description." + lowercaseName; - String name = "for.bees.species." + lowercaseName; - GT_LanguageManager.addStringLocalization("for.bees.species." + lowercaseName, species); - - String authority = GT_LanguageManager.getTranslation("for.bees.authority." + lowercaseName); - if (authority.equals("for.bees.authority." + lowercaseName)) { - authority = "GTNH"; - } - this.branch = branch; - this.species = new GT_AlleleBeeSpecies( - uid, - dominant, - name, - authority, - description, - branch.getBranch(), - binomial, - primary, - secondary); - } - - public static void initBees() { - for (GT_BeeDefinition bee : values()) { - bee.init(); - } - for (GT_BeeDefinition bee : values()) { - bee.registerMutations(); - } - } - - static IAlleleBeeEffect getEffect(byte modid, String name) { - String s = switch (modid) { - case EXTRABEES -> "extrabees.effect." + name; - case GENDUSTRY -> "gendustry.effect." + name; - case MAGICBEES -> "magicbees.effect" + name; - case GREGTECH -> "gregtech.effect" + name; - default -> "forestry.effect" + name; - }; - return (IAlleleBeeEffect) AlleleManager.alleleRegistry.getAllele(s); - } - - static IAlleleFlowers getFlowers(byte modid, String name) { - String s = switch (modid) { - case EXTRABEES -> "extrabees.flower." + name; - case GENDUSTRY -> "gendustry.flower." + name; - case MAGICBEES -> "magicbees.flower" + name; - case GREGTECH -> "gregtech.flower" + name; - default -> "forestry.flowers" + name; - }; - return (IAlleleFlowers) AlleleManager.alleleRegistry.getAllele(s); - } - - private static IAlleleBeeSpecies getSpecies(byte modid, String name) { - String s = switch (modid) { - case EXTRABEES -> "extrabees.species." + name; - case GENDUSTRY -> "gendustry.bee." + name; - case MAGICBEES -> "magicbees.species" + name; - case GREGTECH -> "gregtech.species" + name; - default -> "forestry.species" + name; - }; - IAlleleBeeSpecies ret = (IAlleleBeeSpecies) AlleleManager.alleleRegistry.getAllele(s); - if (ret == null) { - ret = NAQUADRIA.species; - } - - return ret; - } - - private void setSpeciesProperties(GT_AlleleBeeSpecies beeSpecies) { - this.mSpeciesProperties.accept(beeSpecies); - } - - private void setAlleles(IAllele[] template) { - this.mAlleles.accept(template); - } - - private void registerMutations() { - this.mMutations.accept(this); - } - - private void init() { - setSpeciesProperties(species); - - template = branch.getTemplate(); - AlleleHelper.instance.set(template, SPECIES, species); - setAlleles(template); - - genome = BeeManager.beeRoot.templateAsGenome(template); - - BeeManager.beeRoot.registerTemplate(template); - } - - private IBeeMutationCustom registerMutation(IAlleleBeeSpecies parent1, IAlleleBeeSpecies parent2, int chance) { - return registerMutation(parent1, parent2, chance, 1f); - } - - private IBeeMutationCustom registerMutation(GT_BeeDefinition parent1, IAlleleBeeSpecies parent2, int chance) { - return registerMutation(parent1, parent2, chance, 1f); - } - - private IBeeMutationCustom registerMutation(IAlleleBeeSpecies parent1, GT_BeeDefinition parent2, int chance) { - return registerMutation(parent1, parent2, chance, 1f); - } - - private IBeeMutationCustom registerMutation(GT_BeeDefinition parent1, GT_BeeDefinition parent2, int chance) { - return registerMutation(parent1, parent2, chance, 1f); - } - - /** - * Diese neue Funtion erlaubt Mutationsraten unter 1%. Setze dazu die Mutationsrate als Bruch mit chance / - * chanceDivider This new function allows Mutation percentages under 1%. Set them as a fraction with chance / - * chanceDivider - */ - private IBeeMutationCustom registerMutation(IAlleleBeeSpecies parent1, IAlleleBeeSpecies parent2, int chance, - float chanceDivider) { - return new GT_Bee_Mutation(parent1, parent2, this.getTemplate(), chance, chanceDivider); - } - - private IBeeMutationCustom registerMutation(GT_BeeDefinition parent1, IAlleleBeeSpecies parent2, int chance, - float chanceDivider) { - return registerMutation(parent1.species, parent2, chance, chanceDivider); - } - - private IBeeMutationCustom registerMutation(IAlleleBeeSpecies parent1, GT_BeeDefinition parent2, int chance, - float chanceDivider) { - return registerMutation(parent1, parent2.species, chance, chanceDivider); - } - - private IBeeMutationCustom registerMutation(GT_BeeDefinition parent1, GT_BeeDefinition parent2, int chance, - float chanceDivider) { - return registerMutation(parent1.species, parent2, chance, chanceDivider); - } - - @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) { - return BeeManager.beeRoot.getMemberStack(getIndividual(), beeType.ordinal()); - } -} diff --git a/src/main/java/gregtech/loaders/misc/GT_Bees.java b/src/main/java/gregtech/loaders/misc/GT_Bees.java deleted file mode 100644 index a8246360cf..0000000000 --- a/src/main/java/gregtech/loaders/misc/GT_Bees.java +++ /dev/null @@ -1,231 +0,0 @@ -package gregtech.loaders.misc; - -import static gregtech.api.enums.Mods.Forestry; -import static gregtech.api.enums.Mods.GalaxySpace; -import static gregtech.api.enums.Mods.TwilightForest; - -import net.minecraft.tileentity.TileEntity; -import net.minecraft.world.World; -import net.minecraft.world.biome.BiomeGenBase; - -import forestry.api.apiculture.EnumBeeChromosome; -import forestry.api.apiculture.IAlleleBeeEffect; -import forestry.api.core.IClimateProvider; -import forestry.api.genetics.AlleleManager; -import forestry.api.genetics.IAllele; -import forestry.api.genetics.IAlleleArea; -import forestry.api.genetics.IAlleleFloat; -import forestry.api.genetics.IAlleleInteger; -import forestry.api.genetics.IGenome; -import forestry.api.genetics.IMutationCondition; -import forestry.core.genetics.alleles.Allele; -import forestry.core.utils.StringUtil; -import gregtech.GT_Mod; -import gregtech.api.metatileentity.BaseMetaTileEntity; -import gregtech.common.bees.GT_AlleleHelper; -import gregtech.common.items.ItemComb; -import gregtech.common.items.ItemDrop; -import gregtech.common.items.ItemPollen; -import gregtech.common.items.ItemPropolis; -import gregtech.loaders.misc.bees.GT_AlleleEffect; -import gregtech.loaders.misc.bees.GT_EffectMachineBoost; -import gregtech.loaders.misc.bees.GT_EffectTreeTwister; -import gregtech.loaders.misc.bees.GT_Flowers; - -public class GT_Bees { - - public static IAlleleInteger noFertility; - public static IAlleleInteger superFertility; - - public static IAlleleInteger noFlowering; - public static IAlleleInteger superFlowering; - - public static IAlleleArea noTerritory; - public static IAlleleArea superTerritory; - - public static IAlleleFloat noWork; - public static IAlleleFloat speedBlinding; - public static IAlleleFloat superSpeed; - - public static IAlleleInteger blinkLife; - public static IAlleleInteger superLife; - - public static IAlleleBeeEffect treetwisterEffect; - public static IAlleleBeeEffect machineBoostEffect; - - public static ItemPropolis propolis; - public static ItemPollen pollen; - public static ItemDrop drop; - public static ItemComb combs; - - public GT_Bees() { - if (!(Forestry.isModLoaded() && GT_Mod.gregtechproxy.mGTBees)) { - return; - } - GT_Flowers.doInit(); - GT_AlleleHelper.initialisation(); - setupGTAlleles(); - propolis = new ItemPropolis(); - propolis.initPropolisRecipes(); - pollen = new ItemPollen(); - drop = new ItemDrop(); - drop.initDropsRecipes(); - combs = new ItemComb(); - combs.initCombsRecipes(); - combs.registerOreDict(); - GT_BeeDefinition.initBees(); - - } - - private static void setupGTAlleles() { - - noFertility = new AlleleInteger("fertilitySterile", 0, false, EnumBeeChromosome.FERTILITY); - superFertility = new AlleleInteger("fertilityMultiply", 8, false, EnumBeeChromosome.FERTILITY); - - noFlowering = new AlleleInteger("floweringNonpollinating", 0, false, EnumBeeChromosome.FLOWERING); - superFlowering = new AlleleInteger("floweringNaturalistic", 240, false, EnumBeeChromosome.FLOWERING); - - noTerritory = new AlleleArea("areaLethargic", 1, 1, false); - superTerritory = new AlleleArea("areaExploratory", 32, 16, false); - - noWork = new AlleleFloat("speedUnproductive", 0, false); - superSpeed = new AlleleFloat("speedAccelerated", 4F, false); - speedBlinding = AlleleManager.alleleRegistry.getAllele("magicbees.speedBlinding") == null - ? new AlleleFloat("speedBlinding", 2f, false) - : (IAlleleFloat) AlleleManager.alleleRegistry.getAllele("magicbees.speedBlinding"); - - blinkLife = new AlleleInteger("lifeBlink", 2, false, EnumBeeChromosome.LIFESPAN); - superLife = new AlleleInteger("lifeEon", 600, false, EnumBeeChromosome.LIFESPAN); - machineBoostEffect = new GT_EffectMachineBoost(); - - if (GalaxySpace.isModLoaded() && TwilightForest.isModLoaded()) { - GT_Mod.GT_FML_LOGGER.info("treetwisterEffect: GalaxySpace and TwilightForest loaded, using default impl"); - treetwisterEffect = new GT_EffectTreeTwister(); - } else { - GT_Mod.GT_FML_LOGGER - .info("treetwisterEffect: GalaxySpace or TwilightForest was not loaded, using fallback impl"); - treetwisterEffect = GT_AlleleEffect.FORESTRY_BASE_EFFECT; - } - } - - private static class AlleleFloat extends Allele implements IAlleleFloat { - - private final float value; - - public AlleleFloat(String id, float val, boolean isDominant) { - super("gregtech." + id, "gregtech." + id, isDominant); - this.value = val; - AlleleManager.alleleRegistry.registerAllele(this, EnumBeeChromosome.SPEED); - } - - @Override - public float getValue() { - return this.value; - } - } - - private static class AlleleInteger extends Allele implements IAlleleInteger { - - private final int value; - - public AlleleInteger(String id, int val, boolean isDominant, EnumBeeChromosome c) { - super("gregtech." + id, "gregtech." + id, isDominant); - this.value = val; - AlleleManager.alleleRegistry.registerAllele(this, c); - } - - @Override - public int getValue() { - return this.value; - } - } - - private static class AlleleArea extends Allele implements IAlleleArea { - - private final int[] value; - - public AlleleArea(String id, int rangeXZ, int rangeY, boolean isDominant) { - super("gregtech." + id, "gregtech." + id, isDominant); - this.value = new int[] { rangeXZ, rangeY, rangeXZ }; - AlleleManager.alleleRegistry.registerAllele(this, EnumBeeChromosome.TERRITORY); - } - - @Override - public int[] getValue() { - return this.value; - } - } - - public static class DimensionMutationCondition implements IMutationCondition { - - final int dimID; - final String dimName; - - public DimensionMutationCondition(int id, String name) { - dimID = id; - dimName = name; - } - - @Override - public float getChance(World world, int x, int y, int z, IAllele allele0, IAllele allele1, IGenome genome0, - IGenome genome1, IClimateProvider climate) { - if (world.provider.dimensionId == dimID) return 1; - return 0; - } - - @Override - public String getDescription() { - return StringUtil.localizeAndFormat("mutation.condition.dim") + " " + dimName; - } - } - - public static class BiomeIDMutationCondition implements IMutationCondition { - - final int biomeID; - final String biomeName; - - public BiomeIDMutationCondition(int id, String name) { - biomeID = id; - biomeName = name; - } - - @Override - public float getChance(World world, int x, int y, int z, IAllele allele0, IAllele allele1, IGenome genome0, - IGenome genome1, IClimateProvider climate) { - if (climate.getBiome().biomeID == biomeID) return 1; - return 0; - } - - @Override - public String getDescription() { - if (BiomeGenBase.getBiome(biomeID) != null) { - return StringUtil.localizeAndFormat("mutation.condition.biomeid") + " " + biomeName; - } - return ""; - } - } - - public static class ActiveGTMachineMutationCondition implements IMutationCondition { - - public ActiveGTMachineMutationCondition() { - - } - - @Override - public float getChance(World world, int x, int y, int z, IAllele allele0, IAllele allele1, IGenome genome0, - IGenome genome1, IClimateProvider climate) { - TileEntity tileEntity = world.getTileEntity(x, y - 1, z); - if (tileEntity instanceof BaseMetaTileEntity machine) { - if (machine.isActive()) { - return 1; - } - } - return 0; - } - - @Override - public String getDescription() { - return "Needs a running GT Machine below to breed"; - } - } -} diff --git a/src/main/java/gregtech/loaders/misc/GT_BranchDefinition.java b/src/main/java/gregtech/loaders/misc/GT_BranchDefinition.java deleted file mode 100644 index 3eae8c73e2..0000000000 --- a/src/main/java/gregtech/loaders/misc/GT_BranchDefinition.java +++ /dev/null @@ -1,207 +0,0 @@ -package gregtech.loaders.misc; - -import static forestry.api.apiculture.EnumBeeChromosome.CAVE_DWELLING; -import static forestry.api.apiculture.EnumBeeChromosome.EFFECT; -import static forestry.api.apiculture.EnumBeeChromosome.FERTILITY; -import static forestry.api.apiculture.EnumBeeChromosome.FLOWERING; -import static forestry.api.apiculture.EnumBeeChromosome.FLOWER_PROVIDER; -import static forestry.api.apiculture.EnumBeeChromosome.HUMIDITY_TOLERANCE; -import static forestry.api.apiculture.EnumBeeChromosome.LIFESPAN; -import static forestry.api.apiculture.EnumBeeChromosome.NOCTURNAL; -import static forestry.api.apiculture.EnumBeeChromosome.SPEED; -import static forestry.api.apiculture.EnumBeeChromosome.TEMPERATURE_TOLERANCE; -import static forestry.api.apiculture.EnumBeeChromosome.TERRITORY; -import static forestry.api.apiculture.EnumBeeChromosome.TOLERANT_FLYER; -import static forestry.core.genetics.alleles.EnumAllele.Fertility; -import static forestry.core.genetics.alleles.EnumAllele.Flowering; -import static forestry.core.genetics.alleles.EnumAllele.Flowers; -import static forestry.core.genetics.alleles.EnumAllele.Lifespan; -import static forestry.core.genetics.alleles.EnumAllele.Speed; -import static forestry.core.genetics.alleles.EnumAllele.Territory; -import static forestry.core.genetics.alleles.EnumAllele.Tolerance; -import static gregtech.loaders.misc.GT_BeeDefinition.getEffect; -import static gregtech.loaders.misc.GT_BeeDefinition.getFlowers; -import static gregtech.loaders.misc.GT_BeeDefinitionReference.EXTRABEES; -import static gregtech.loaders.misc.GT_BeeDefinitionReference.MAGICBEES; - -import java.util.Arrays; -import java.util.function.Consumer; - -import forestry.api.apiculture.BeeManager; -import forestry.api.apiculture.EnumBeeChromosome; -import forestry.api.genetics.IAllele; -import forestry.api.genetics.IClassification; -import forestry.apiculture.genetics.alleles.AlleleEffect; -import forestry.core.genetics.alleles.AlleleHelper; - -public enum GT_BranchDefinition { - - ORGANIC("Fuelis", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(alleles, HUMIDITY_TOLERANCE, Tolerance.BOTH_2); - AlleleHelper.instance.set(alleles, NOCTURNAL, false); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.WHEAT); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.SLOW); - AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.SHORTER); - AlleleHelper.instance.set(alleles, SPEED, Speed.SLOWEST); - }), - IC2("Industrialis", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.UP_1); - AlleleHelper.instance.set(alleles, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(alleles, NOCTURNAL, false); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.SNOW); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTER); - AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(alleles, SPEED, Speed.SLOW); - }), - GTALLOY("Amalgamis", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(alleles, TOLERANT_FLYER, true); - AlleleHelper.instance.set(alleles, NOCTURNAL, false); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.VANILLA); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.AVERAGE); - AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.SHORTEST); - AlleleHelper.instance.set(alleles, SPEED, Speed.FAST); - }), - THAUMIC("Arcanis", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(alleles, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, getFlowers(EXTRABEES, "book")); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTER); - AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.LONGEST); - }), - GEM("Ornamentis", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(alleles, NOCTURNAL, false); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.NETHER); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.AVERAGE); - }), - METAL("Metaliferis", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.DOWN_2); - AlleleHelper.instance.set(alleles, CAVE_DWELLING, true); - AlleleHelper.instance.set(alleles, NOCTURNAL, false); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.JUNGLE); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.SLOWER); - }), - RAREMETAL("Mineralis", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.DOWN_1); - AlleleHelper.instance.set(alleles, NOCTURNAL, false); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.CACTI); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FAST); - }), - RADIOACTIVE("Criticalis", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(alleles, NOCTURNAL, false); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.END); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.AVERAGE); - AlleleHelper.instance.set(alleles, SPEED, GT_Bees.speedBlinding); - AlleleHelper.instance.set(alleles, SPEED, getEffect(EXTRABEES, "radioactive")); - }), - TWILIGHT("Nemoris Obscuri", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(alleles, HUMIDITY_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(alleles, NOCTURNAL, false); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, Flowers.VANILLA); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTER); - }), - HEE("Finis Expansiones", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_2); - AlleleHelper.instance.set(alleles, HUMIDITY_TOLERANCE, Tolerance.BOTH_2); - AlleleHelper.instance.set(alleles, NOCTURNAL, true); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, getFlowers(EXTRABEES, "book")); - AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.SHORT); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.SLOW); - AlleleHelper.instance.set(alleles, SPEED, Speed.FASTEST); - AlleleHelper.instance.set(alleles, TERRITORY, Territory.LARGER); - }), - SPACE("Cosmicis", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.DOWN_2); - AlleleHelper.instance.set(alleles, TOLERANT_FLYER, true); - AlleleHelper.instance.set(alleles, NOCTURNAL, true); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, getFlowers(EXTRABEES, "rock")); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTEST); - AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.LONGEST); - AlleleHelper.instance.set(alleles, SPEED, Speed.FAST); - AlleleHelper.instance.set(alleles, TERRITORY, Territory.LARGEST); - }), - PLANET("Planetaris", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(alleles, TOLERANT_FLYER, true); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, getFlowers(EXTRABEES, "rock")); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTEST); - AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.NORMAL); - AlleleHelper.instance.set(alleles, SPEED, Speed.FASTEST); - AlleleHelper.instance.set(alleles, TERRITORY, Territory.LARGER); - }), - NOBLEGAS("Nobilis Gasorum", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_2); - AlleleHelper.instance.set(alleles, TOLERANT_FLYER, true); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTEST); - AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.NORMAL); - AlleleHelper.instance.set(alleles, SPEED, Speed.FASTEST); - AlleleHelper.instance.set(alleles, TERRITORY, Territory.AVERAGE); - }), - INFUSEDSHARD("Infusa Shard", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_1); - AlleleHelper.instance.set(alleles, TOLERANT_FLYER, true); - AlleleHelper.instance.set(alleles, FLOWER_PROVIDER, getFlowers(MAGICBEES, "rock")); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTEST); - AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.SHORTEST); - AlleleHelper.instance.set(alleles, SPEED, Speed.FASTEST); - AlleleHelper.instance.set(alleles, TERRITORY, Territory.LARGEST); - }), - ENDGAME("ENDUS GAMUS", alleles -> { - AlleleHelper.instance.set(alleles, TEMPERATURE_TOLERANCE, Tolerance.BOTH_5); - AlleleHelper.instance.set(alleles, TOLERANT_FLYER, true); - AlleleHelper.instance.set(alleles, FLOWERING, Flowering.FASTEST); - AlleleHelper.instance.set(alleles, LIFESPAN, Lifespan.SHORTEST); - AlleleHelper.instance.set(alleles, SPEED, Speed.FASTEST); - AlleleHelper.instance.set(alleles, TERRITORY, Territory.LARGEST); - }); - - private static IAllele[] defaultTemplate; - private final IClassification branch; - private final Consumer mBranchProperties; - - GT_BranchDefinition(String scientific, Consumer aBranchProperties) { - this.branch = BeeManager.beeFactory.createBranch( - this.name() - .toLowerCase(), - scientific); - this.mBranchProperties = aBranchProperties; - } - - private static IAllele[] getDefaultTemplate() { - if (defaultTemplate == null) { - defaultTemplate = new IAllele[EnumBeeChromosome.values().length]; - - AlleleHelper.instance.set(defaultTemplate, SPEED, Speed.SLOWEST); - AlleleHelper.instance.set(defaultTemplate, LIFESPAN, Lifespan.SHORTER); - AlleleHelper.instance.set(defaultTemplate, FERTILITY, Fertility.NORMAL); - AlleleHelper.instance.set(defaultTemplate, TEMPERATURE_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(defaultTemplate, NOCTURNAL, false); - AlleleHelper.instance.set(defaultTemplate, HUMIDITY_TOLERANCE, Tolerance.NONE); - AlleleHelper.instance.set(defaultTemplate, TOLERANT_FLYER, false); - AlleleHelper.instance.set(defaultTemplate, CAVE_DWELLING, false); - AlleleHelper.instance.set(defaultTemplate, FLOWER_PROVIDER, Flowers.VANILLA); - AlleleHelper.instance.set(defaultTemplate, FLOWERING, Flowering.SLOWEST); - AlleleHelper.instance.set(defaultTemplate, TERRITORY, Territory.AVERAGE); - AlleleHelper.instance.set(defaultTemplate, EFFECT, AlleleEffect.effectNone); - } - return Arrays.copyOf(defaultTemplate, defaultTemplate.length); - } - - void setBranchProperties(IAllele[] template) { - this.mBranchProperties.accept(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 deleted file mode 100644 index dc83202724..0000000000 --- a/src/main/java/gregtech/loaders/misc/GT_CoverLoader.java +++ /dev/null @@ -1,42 +0,0 @@ -package gregtech.loaders.misc; - -import static gregtech.api.enums.Textures.BlockIcons.VENT_ADVANCED; -import static gregtech.api.enums.Textures.BlockIcons.VENT_NORMAL; - -import net.minecraft.init.Blocks; -import net.minecraft.item.ItemStack; - -import gregtech.api.GregTech_API; -import gregtech.api.render.TextureFactory; -import gregtech.api.util.GT_ModHandler; -import gregtech.common.covers.GT_Cover_Vent; - -public class GT_CoverLoader implements Runnable { - - @Override - public void run() { - for (byte i = 0; i < 16; i = (byte) (i + 1)) { - GregTech_API.registerCover(new ItemStack(Blocks.carpet, 1, i), TextureFactory.of(Blocks.wool, i), null); - } - GregTech_API.registerCover( - GT_ModHandler.getIC2Item("reactorVent", 1L, 1), - TextureFactory.of(VENT_NORMAL), - new GT_Cover_Vent(1)); - GregTech_API.registerCover( - GT_ModHandler.getIC2Item("reactorVentCore", 1L, 1), - TextureFactory.of(VENT_NORMAL), - new GT_Cover_Vent(1)); - GregTech_API.registerCover( - GT_ModHandler.getIC2Item("reactorVentGold", 1L, 1), - TextureFactory.of(VENT_ADVANCED), - new GT_Cover_Vent(2)); - GregTech_API.registerCover( - GT_ModHandler.getIC2Item("reactorVentSpread", 1L), - TextureFactory.of(VENT_NORMAL), - new GT_Cover_Vent(2)); - GregTech_API.registerCover( - GT_ModHandler.getIC2Item("reactorVentDiamond", 1L, 1), - TextureFactory.of(VENT_ADVANCED), - new GT_Cover_Vent(3)); - } -} diff --git a/src/main/java/gregtech/loaders/misc/bees/GTAlleleEffect.java b/src/main/java/gregtech/loaders/misc/bees/GTAlleleEffect.java new file mode 100644 index 0000000000..128e3dfeb1 --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/bees/GTAlleleEffect.java @@ -0,0 +1,57 @@ +package gregtech.loaders.misc.bees; + +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.apiculture.IAlleleBeeEffect; +import forestry.api.apiculture.IBeeGenome; +import forestry.api.apiculture.IBeeHousing; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IEffectData; +import forestry.core.genetics.alleles.Allele; + +// helper class for implementing custom bee effects, based on MagicBees' implementation +public abstract class GTAlleleEffect extends Allele implements IAlleleBeeEffect { + + public static final IAlleleBeeEffect FORESTRY_BASE_EFFECT = (IAlleleBeeEffect) AlleleManager.alleleRegistry + .getAllele("forestry.effectNone"); + protected boolean combinable; + protected int tickThrottle; // If set, this amount of ticks have to pass before an effect ticks + + public GTAlleleEffect(String id, boolean isDominant, int tickThrottle) { + super("gregtech." + id, "gregtech." + id, isDominant); + AlleleManager.alleleRegistry.registerAllele(this, EnumBeeChromosome.EFFECT); + combinable = false; + this.tickThrottle = tickThrottle; + } + + @Override + public boolean isCombinable() { + return combinable; + } + + public GTAlleleEffect setIsCombinable(boolean canCombine) { + combinable = canCombine; + return this; + } + + @Override + public abstract IEffectData validateStorage(IEffectData storedData); + + @Override + public IEffectData doEffect(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) { + int ticksPassed = storedData.getInteger(0); + if (ticksPassed >= this.tickThrottle) { + storedData = this.doEffectTickThrottled(genome, storedData, housing); + } else { + storedData.setInteger(0, ticksPassed + 1); + } + return storedData; + } + + protected abstract IEffectData doEffectTickThrottled(IBeeGenome genome, IEffectData storedData, + IBeeHousing housing); + + @Override + public IEffectData doFX(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) { + return FORESTRY_BASE_EFFECT.doFX(genome, storedData, housing); + } +} diff --git a/src/main/java/gregtech/loaders/misc/bees/GTEffectMachineBoost.java b/src/main/java/gregtech/loaders/misc/bees/GTEffectMachineBoost.java new file mode 100644 index 0000000000..e0454e0d27 --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/bees/GTEffectMachineBoost.java @@ -0,0 +1,61 @@ +package gregtech.loaders.misc.bees; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ChunkCoordinates; +import net.minecraft.world.World; + +import forestry.api.apiculture.BeeManager; +import forestry.api.apiculture.IBeeGenome; +import forestry.api.apiculture.IBeeHousing; +import forestry.api.apiculture.IBeeModifier; +import forestry.api.genetics.IEffectData; +import forestry.core.genetics.EffectData; +import gregtech.api.metatileentity.BaseMetaTileEntity; +import gregtech.api.metatileentity.implementations.MTETieredMachineBlock; + +public class GTEffectMachineBoost extends GTAlleleEffect { + + public GTEffectMachineBoost() { + super("effectMachineBoost", false, 600); + } + + @Override + public IEffectData validateStorage(IEffectData storedData) { + if (storedData == null) { + storedData = new EffectData(1, 1); + } + return storedData; + } + + @Override + protected IEffectData doEffectTickThrottled(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) { + World world = housing.getWorld(); + ChunkCoordinates coords = housing.getCoordinates(); + IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(housing); + + // Get random coords within territory + int xRange = (int) (beeModifier.getTerritoryModifier(genome, 1f) * genome.getTerritory()[0]); + int yRange = (int) (beeModifier.getTerritoryModifier(genome, 1f) * genome.getTerritory()[1]); + int zRange = (int) (beeModifier.getTerritoryModifier(genome, 1f) * genome.getTerritory()[2]); + + int xCoord = coords.posX + world.rand.nextInt(xRange) - xRange / 2; + int yCoord = coords.posY + world.rand.nextInt(yRange) - yRange / 2; + int zCoord = coords.posZ + world.rand.nextInt(zRange) - zRange / 2; + + // If gt machine of tier lower equal than ev, boost recipe by 2s + TileEntity tileEntity = world.getTileEntity(xCoord, yCoord, zCoord); + if (tileEntity instanceof BaseMetaTileEntity machine) { + if (machine.getMetaTileEntity() instanceof MTETieredMachineBlock tieredMachine) { + if (tieredMachine.mTier <= 4) { // EV + if (machine.isActive() && machine.getMaxProgress() > 60) { + machine.increaseProgress(40); + } + } + } + } + + storedData.setInteger(0, 0); + + return storedData; + } +} diff --git a/src/main/java/gregtech/loaders/misc/bees/GTEffectTreeTwister.java b/src/main/java/gregtech/loaders/misc/bees/GTEffectTreeTwister.java new file mode 100644 index 0000000000..65c150bd1d --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/bees/GTEffectTreeTwister.java @@ -0,0 +1,87 @@ +package gregtech.loaders.misc.bees; + +import static gregtech.api.enums.Mods.GalaxySpace; +import static gregtech.api.enums.Mods.TwilightForest; + +import java.util.Arrays; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ChunkCoordinates; +import net.minecraft.world.World; + +import forestry.api.apiculture.BeeManager; +import forestry.api.apiculture.IBeeGenome; +import forestry.api.apiculture.IBeeHousing; +import forestry.api.apiculture.IBeeModifier; +import forestry.api.genetics.IEffectData; +import gregtech.GTMod; +import gregtech.api.util.GTModHandler; + +public class GTEffectTreeTwister extends GTAlleleEffect { + + private static final Integer[] ALLOWED_DIMS = { 2, // spectre + 112, // last millenium + 60, // bedrock + 69, // pocket plane + }; + + private static final ItemStack TF_TRANS_SAPLING = GTModHandler + .getModItem(TwilightForest.ID, "tile.TFSapling", 1, 6); + private static final ItemStack BARN_SAPLING = GTModHandler.getModItem(GalaxySpace.ID, "barnardaCsapling", 1, 1); + + static { + if (TF_TRANS_SAPLING == null) { + GTMod.GT_FML_LOGGER.info("GT_EffectTreeTwister(): Could not get ItemStack for BarnardaC sapling"); + } + if (BARN_SAPLING == null) { + GTMod.GT_FML_LOGGER.info("GT_EffectTreeTwister(): Could not get ItemStack for BarnardaC sapling"); + } + } + + public GTEffectTreeTwister() { + super("effectTreetwister", false, 0); + } + + public IEffectData validateStorage(IEffectData storedData) { + return storedData; // unused for this effect + } + + @Override + protected IEffectData doEffectTickThrottled(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) { + if (TF_TRANS_SAPLING == null || BARN_SAPLING == null) { + return storedData; + } + World world = housing.getWorld(); + if (!Arrays.asList(ALLOWED_DIMS) + .contains(world.provider.dimensionId)) { + return storedData; + } + ChunkCoordinates coords = housing.getCoordinates(); + IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(housing); + + // Get random coords within territory + int xRange = (int) (beeModifier.getTerritoryModifier(genome, 1f) * genome.getTerritory()[0]); + int yRange = (int) (beeModifier.getTerritoryModifier(genome, 1f) * genome.getTerritory()[1]); + int zRange = (int) (beeModifier.getTerritoryModifier(genome, 1f) * genome.getTerritory()[2]); + + int xCoord = coords.posX + world.rand.nextInt(xRange) - xRange / 2; + int yCoord = coords.posY + world.rand.nextInt(yRange) - yRange / 2; + int zCoord = coords.posZ + world.rand.nextInt(zRange) - zRange / 2; + + ItemStack sourceBlock = new ItemStack( + world.getBlock(xCoord, yCoord, zCoord), + 1, + world.getBlockMetadata(xCoord, yCoord, zCoord)); + if (TF_TRANS_SAPLING != null && BARN_SAPLING != null && TF_TRANS_SAPLING.isItemEqual(sourceBlock)) { + world.setBlock( + xCoord, + yCoord, + zCoord, + Block.getBlockFromItem(BARN_SAPLING.getItem()), + BARN_SAPLING.getItemDamage(), + 2); + } + return storedData; + } +} diff --git a/src/main/java/gregtech/loaders/misc/bees/GTFlowers.java b/src/main/java/gregtech/loaders/misc/bees/GTFlowers.java new file mode 100644 index 0000000000..db96bfb454 --- /dev/null +++ b/src/main/java/gregtech/loaders/misc/bees/GTFlowers.java @@ -0,0 +1,135 @@ +package gregtech.loaders.misc.bees; + +import java.util.EnumSet; +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.block.Block; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.common.EnumPlantType; + +import forestry.api.apiculture.FlowerManager; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IAlleleFlowers; +import forestry.api.genetics.IChromosomeType; +import forestry.api.genetics.IFlower; +import forestry.api.genetics.IFlowerProvider; +import forestry.api.genetics.IIndividual; +import forestry.api.genetics.IPollinatable; +import forestry.api.genetics.ISpeciesRoot; +import gregtech.api.util.GTLanguageManager; + +public enum GTFlowers implements IFlowerProvider, IAlleleFlowers, IChromosomeType { + + FLAMING; + + protected boolean dominant; + + GTFlowers() { + dominant = true; + } + + public static void doInit() { + for (GTFlowers effect : values()) { + effect.register(); + } + } + + @Override + public String getUID() { + return "for.flowers." + toString().toLowerCase(); + } + + @Override + public boolean isDominant() { + return dominant; + } + + @Override + public IFlowerProvider getProvider() { + return this; + } + + @Override + public String getDescription() { + return GTLanguageManager.getTranslation("for.flowers." + name().toLowerCase()); + } + + public void register() { + for (ItemStack stack : getItemStacks()) { + FlowerManager.flowerRegistry.registerAcceptableFlower(Block.getBlockFromItem(stack.getItem()), getUID()); + } + + AlleleManager.alleleRegistry.registerAllele(this, this); + } + + public ItemStack[] getItemStacks() { + switch (this) { + case FLAMING: + return new ItemStack[] { new ItemStack(Blocks.fire) }; + } + return new ItemStack[0]; + } + + @Override + public boolean isAcceptedPollinatable(World world, IPollinatable pollinatable) { + EnumSet types = pollinatable.getPlantType(); + return types.size() > 1 || !types.contains(EnumPlantType.Nether); + } + + public boolean isAcceptedFlower(World world, int x, int y, int z) { + Block block = world.getBlock(x, y, z); + if (block == null) { + return false; + } + + switch (this) { + case FLAMING: + return block == Blocks.fire; + } + return false; + } + + @Override + public boolean growFlower(World world, IIndividual individual, int x, int y, int z) { + return false; + } + + @Override + public ItemStack[] affectProducts(World world, IIndividual individual, int x, int y, int z, ItemStack[] products) { + return products; + } + + @Override + public String getName() { + return getDescription(); + } + + @Override + public String getUnlocalizedName() { + return getUID(); + } + + @Override + public String getFlowerType() { + return getUID(); + } + + @Override + public Set getFlowers() { + return new HashSet<>(); + } + + @Override + public Class getAlleleClass() { + return getClass(); + } + + @Override + public ISpeciesRoot getSpeciesRoot() { + return AlleleManager.alleleRegistry.getSpeciesRoot(getUID()); + } +} diff --git a/src/main/java/gregtech/loaders/misc/bees/GT_AlleleEffect.java b/src/main/java/gregtech/loaders/misc/bees/GT_AlleleEffect.java deleted file mode 100644 index 25198968d2..0000000000 --- a/src/main/java/gregtech/loaders/misc/bees/GT_AlleleEffect.java +++ /dev/null @@ -1,57 +0,0 @@ -package gregtech.loaders.misc.bees; - -import forestry.api.apiculture.EnumBeeChromosome; -import forestry.api.apiculture.IAlleleBeeEffect; -import forestry.api.apiculture.IBeeGenome; -import forestry.api.apiculture.IBeeHousing; -import forestry.api.genetics.AlleleManager; -import forestry.api.genetics.IEffectData; -import forestry.core.genetics.alleles.Allele; - -// helper class for implementing custom bee effects, based on MagicBees' implementation -public abstract class GT_AlleleEffect extends Allele implements IAlleleBeeEffect { - - public static final IAlleleBeeEffect FORESTRY_BASE_EFFECT = (IAlleleBeeEffect) AlleleManager.alleleRegistry - .getAllele("forestry.effectNone"); - protected boolean combinable; - protected int tickThrottle; // If set, this amount of ticks have to pass before an effect ticks - - public GT_AlleleEffect(String id, boolean isDominant, int tickThrottle) { - super("gregtech." + id, "gregtech." + id, isDominant); - AlleleManager.alleleRegistry.registerAllele(this, EnumBeeChromosome.EFFECT); - combinable = false; - this.tickThrottle = tickThrottle; - } - - @Override - public boolean isCombinable() { - return combinable; - } - - public GT_AlleleEffect setIsCombinable(boolean canCombine) { - combinable = canCombine; - return this; - } - - @Override - public abstract IEffectData validateStorage(IEffectData storedData); - - @Override - public IEffectData doEffect(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) { - int ticksPassed = storedData.getInteger(0); - if (ticksPassed >= this.tickThrottle) { - storedData = this.doEffectTickThrottled(genome, storedData, housing); - } else { - storedData.setInteger(0, ticksPassed + 1); - } - return storedData; - } - - protected abstract IEffectData doEffectTickThrottled(IBeeGenome genome, IEffectData storedData, - IBeeHousing housing); - - @Override - public IEffectData doFX(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) { - return FORESTRY_BASE_EFFECT.doFX(genome, storedData, housing); - } -} diff --git a/src/main/java/gregtech/loaders/misc/bees/GT_EffectMachineBoost.java b/src/main/java/gregtech/loaders/misc/bees/GT_EffectMachineBoost.java deleted file mode 100644 index a50c0452bb..0000000000 --- a/src/main/java/gregtech/loaders/misc/bees/GT_EffectMachineBoost.java +++ /dev/null @@ -1,61 +0,0 @@ -package gregtech.loaders.misc.bees; - -import net.minecraft.tileentity.TileEntity; -import net.minecraft.util.ChunkCoordinates; -import net.minecraft.world.World; - -import forestry.api.apiculture.BeeManager; -import forestry.api.apiculture.IBeeGenome; -import forestry.api.apiculture.IBeeHousing; -import forestry.api.apiculture.IBeeModifier; -import forestry.api.genetics.IEffectData; -import forestry.core.genetics.EffectData; -import gregtech.api.metatileentity.BaseMetaTileEntity; -import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock; - -public class GT_EffectMachineBoost extends GT_AlleleEffect { - - public GT_EffectMachineBoost() { - super("effectMachineBoost", false, 600); - } - - @Override - public IEffectData validateStorage(IEffectData storedData) { - if (storedData == null) { - storedData = new EffectData(1, 1); - } - return storedData; - } - - @Override - protected IEffectData doEffectTickThrottled(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) { - World world = housing.getWorld(); - ChunkCoordinates coords = housing.getCoordinates(); - IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(housing); - - // Get random coords within territory - int xRange = (int) (beeModifier.getTerritoryModifier(genome, 1f) * genome.getTerritory()[0]); - int yRange = (int) (beeModifier.getTerritoryModifier(genome, 1f) * genome.getTerritory()[1]); - int zRange = (int) (beeModifier.getTerritoryModifier(genome, 1f) * genome.getTerritory()[2]); - - int xCoord = coords.posX + world.rand.nextInt(xRange) - xRange / 2; - int yCoord = coords.posY + world.rand.nextInt(yRange) - yRange / 2; - int zCoord = coords.posZ + world.rand.nextInt(zRange) - zRange / 2; - - // If gt machine of tier lower equal than ev, boost recipe by 2s - TileEntity tileEntity = world.getTileEntity(xCoord, yCoord, zCoord); - if (tileEntity instanceof BaseMetaTileEntity machine) { - if (machine.getMetaTileEntity() instanceof GT_MetaTileEntity_TieredMachineBlock tieredMachine) { - if (tieredMachine.mTier <= 4) { // EV - if (machine.isActive() && machine.getMaxProgress() > 60) { - machine.increaseProgress(40); - } - } - } - } - - storedData.setInteger(0, 0); - - return storedData; - } -} diff --git a/src/main/java/gregtech/loaders/misc/bees/GT_EffectTreeTwister.java b/src/main/java/gregtech/loaders/misc/bees/GT_EffectTreeTwister.java deleted file mode 100644 index a36635db57..0000000000 --- a/src/main/java/gregtech/loaders/misc/bees/GT_EffectTreeTwister.java +++ /dev/null @@ -1,87 +0,0 @@ -package gregtech.loaders.misc.bees; - -import static gregtech.api.enums.Mods.GalaxySpace; -import static gregtech.api.enums.Mods.TwilightForest; - -import java.util.Arrays; - -import net.minecraft.block.Block; -import net.minecraft.item.ItemStack; -import net.minecraft.util.ChunkCoordinates; -import net.minecraft.world.World; - -import forestry.api.apiculture.BeeManager; -import forestry.api.apiculture.IBeeGenome; -import forestry.api.apiculture.IBeeHousing; -import forestry.api.apiculture.IBeeModifier; -import forestry.api.genetics.IEffectData; -import gregtech.GT_Mod; -import gregtech.api.util.GT_ModHandler; - -public class GT_EffectTreeTwister extends GT_AlleleEffect { - - private static final Integer[] ALLOWED_DIMS = { 2, // spectre - 112, // last millenium - 60, // bedrock - 69, // pocket plane - }; - - private static final ItemStack TF_TRANS_SAPLING = GT_ModHandler - .getModItem(TwilightForest.ID, "tile.TFSapling", 1, 6); - private static final ItemStack BARN_SAPLING = GT_ModHandler.getModItem(GalaxySpace.ID, "barnardaCsapling", 1, 1); - - static { - if (TF_TRANS_SAPLING == null) { - GT_Mod.GT_FML_LOGGER.info("GT_EffectTreeTwister(): Could not get ItemStack for BarnardaC sapling"); - } - if (BARN_SAPLING == null) { - GT_Mod.GT_FML_LOGGER.info("GT_EffectTreeTwister(): Could not get ItemStack for BarnardaC sapling"); - } - } - - public GT_EffectTreeTwister() { - super("effectTreetwister", false, 0); - } - - public IEffectData validateStorage(IEffectData storedData) { - return storedData; // unused for this effect - } - - @Override - protected IEffectData doEffectTickThrottled(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) { - if (TF_TRANS_SAPLING == null || BARN_SAPLING == null) { - return storedData; - } - World world = housing.getWorld(); - if (!Arrays.asList(ALLOWED_DIMS) - .contains(world.provider.dimensionId)) { - return storedData; - } - ChunkCoordinates coords = housing.getCoordinates(); - IBeeModifier beeModifier = BeeManager.beeRoot.createBeeHousingModifier(housing); - - // Get random coords within territory - int xRange = (int) (beeModifier.getTerritoryModifier(genome, 1f) * genome.getTerritory()[0]); - int yRange = (int) (beeModifier.getTerritoryModifier(genome, 1f) * genome.getTerritory()[1]); - int zRange = (int) (beeModifier.getTerritoryModifier(genome, 1f) * genome.getTerritory()[2]); - - int xCoord = coords.posX + world.rand.nextInt(xRange) - xRange / 2; - int yCoord = coords.posY + world.rand.nextInt(yRange) - yRange / 2; - int zCoord = coords.posZ + world.rand.nextInt(zRange) - zRange / 2; - - ItemStack sourceBlock = new ItemStack( - world.getBlock(xCoord, yCoord, zCoord), - 1, - world.getBlockMetadata(xCoord, yCoord, zCoord)); - if (TF_TRANS_SAPLING != null && BARN_SAPLING != null && TF_TRANS_SAPLING.isItemEqual(sourceBlock)) { - world.setBlock( - xCoord, - yCoord, - zCoord, - Block.getBlockFromItem(BARN_SAPLING.getItem()), - BARN_SAPLING.getItemDamage(), - 2); - } - return storedData; - } -} diff --git a/src/main/java/gregtech/loaders/misc/bees/GT_Flowers.java b/src/main/java/gregtech/loaders/misc/bees/GT_Flowers.java deleted file mode 100644 index d2ab1d6297..0000000000 --- a/src/main/java/gregtech/loaders/misc/bees/GT_Flowers.java +++ /dev/null @@ -1,135 +0,0 @@ -package gregtech.loaders.misc.bees; - -import java.util.EnumSet; -import java.util.HashSet; -import java.util.Set; - -import net.minecraft.block.Block; -import net.minecraft.init.Blocks; -import net.minecraft.item.ItemStack; -import net.minecraft.world.World; -import net.minecraftforge.common.EnumPlantType; - -import forestry.api.apiculture.FlowerManager; -import forestry.api.genetics.AlleleManager; -import forestry.api.genetics.IAllele; -import forestry.api.genetics.IAlleleFlowers; -import forestry.api.genetics.IChromosomeType; -import forestry.api.genetics.IFlower; -import forestry.api.genetics.IFlowerProvider; -import forestry.api.genetics.IIndividual; -import forestry.api.genetics.IPollinatable; -import forestry.api.genetics.ISpeciesRoot; -import gregtech.api.util.GT_LanguageManager; - -public enum GT_Flowers implements IFlowerProvider, IAlleleFlowers, IChromosomeType { - - FLAMING; - - protected boolean dominant; - - GT_Flowers() { - dominant = true; - } - - public static void doInit() { - for (GT_Flowers effect : values()) { - effect.register(); - } - } - - @Override - public String getUID() { - return "for.flowers." + toString().toLowerCase(); - } - - @Override - public boolean isDominant() { - return dominant; - } - - @Override - public IFlowerProvider getProvider() { - return this; - } - - @Override - public String getDescription() { - return GT_LanguageManager.getTranslation("for.flowers." + name().toLowerCase()); - } - - public void register() { - for (ItemStack stack : getItemStacks()) { - FlowerManager.flowerRegistry.registerAcceptableFlower(Block.getBlockFromItem(stack.getItem()), getUID()); - } - - AlleleManager.alleleRegistry.registerAllele(this, this); - } - - public ItemStack[] getItemStacks() { - switch (this) { - case FLAMING: - return new ItemStack[] { new ItemStack(Blocks.fire) }; - } - return new ItemStack[0]; - } - - @Override - public boolean isAcceptedPollinatable(World world, IPollinatable pollinatable) { - EnumSet types = pollinatable.getPlantType(); - return types.size() > 1 || !types.contains(EnumPlantType.Nether); - } - - public boolean isAcceptedFlower(World world, int x, int y, int z) { - Block block = world.getBlock(x, y, z); - if (block == null) { - return false; - } - - switch (this) { - case FLAMING: - return block == Blocks.fire; - } - return false; - } - - @Override - public boolean growFlower(World world, IIndividual individual, int x, int y, int z) { - return false; - } - - @Override - public ItemStack[] affectProducts(World world, IIndividual individual, int x, int y, int z, ItemStack[] products) { - return products; - } - - @Override - public String getName() { - return getDescription(); - } - - @Override - public String getUnlocalizedName() { - return getUID(); - } - - @Override - public String getFlowerType() { - return getUID(); - } - - @Override - public Set getFlowers() { - return new HashSet<>(); - } - - @Override - public Class getAlleleClass() { - return getClass(); - } - - @Override - public ISpeciesRoot getSpeciesRoot() { - return AlleleManager.alleleRegistry.getSpeciesRoot(getUID()); - } -} -- cgit