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); +