diff --git a/src/main/java/binnie/botany/gardening/BlockSoil.java b/src/main/java/binnie/botany/gardening/BlockSoil.java index 64a2d93c..b8db54fd 100644 --- a/src/main/java/binnie/botany/gardening/BlockSoil.java +++ b/src/main/java/binnie/botany/gardening/BlockSoil.java @@ -54,9 +54,9 @@ public class BlockSoil extends Block implements IBlockSoil { @Override @SideOnly(Side.CLIENT) - public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List) { + public void getSubBlocks(Item item, CreativeTabs tab, List list) { for (int i = 0; i < 9; ++i) { - par3List.add(new ItemStack(this, 1, i)); + list.add(new ItemStack(this, 1, i)); } } diff --git a/src/main/java/binnie/core/genetics/BreedingSystem.java b/src/main/java/binnie/core/genetics/BreedingSystem.java index 08f8bc92..822e2874 100644 --- a/src/main/java/binnie/core/genetics/BreedingSystem.java +++ b/src/main/java/binnie/core/genetics/BreedingSystem.java @@ -145,12 +145,15 @@ public abstract class BreedingSystem implements IItemStackRepresentative { allBranches.add(branch); } } + if (getSpeciesRoot().getMutations(false) != null) { Set mutations = new LinkedHashSet<>(); mutations.addAll(getSpeciesRoot().getMutations(false)); + // TODO Why is this necessary? if (this == Binnie.Genetics.beeBreedingSystem) { mutations.addAll(ExtraBeeMutation.mutations); } + for (IMutation mutation : mutations) { allMutations.add(mutation); Set participatingSpecies = new LinkedHashSet<>(); @@ -179,13 +182,6 @@ public abstract class BreedingSystem implements IItemStackRepresentative { return AlleleManager.alleleRegistry.isBlacklisted(allele.getUID()); } - public List getResultantMutations(IAlleleSpecies species, boolean includeInactive) { - if (resultantMutations.isEmpty()) { - calculateArrays(); - } - return includeInactive ? allResultantMutations.get(species) : resultantMutations.get(species); - } - public List getResultantMutations(IAlleleSpecies species) { if (resultantMutations.isEmpty()) { calculateArrays(); @@ -193,13 +189,6 @@ public abstract class BreedingSystem implements IItemStackRepresentative { return resultantMutations.get(species); } - public List getFurtherMutations(IAlleleSpecies species, boolean includeInactive) { - if (furtherMutations.isEmpty()) { - calculateArrays(); - } - return includeInactive ? allFurtherMutations.get(species) : furtherMutations.get(species); - } - public List getFurtherMutations(IAlleleSpecies species) { if (furtherMutations.isEmpty()) { calculateArrays(); @@ -298,26 +287,6 @@ public abstract class BreedingSystem implements IItemStackRepresentative { return speciesList; } - public List getDiscoveredMutations(IBreedingTracker tracker) { - List speciesList = new ArrayList<>(); - for (IMutation species : getAllMutations()) { - if (isMutationDiscovered(species, tracker)) { - speciesList.add(species); - } - } - return speciesList; - } - - public int getDiscoveredBranchMembers(IClassification branch, IBreedingTracker tracker) { - int discoveredSpecies = 0; - for (IAlleleSpecies species : branch.getMemberSpecies()) { - if (isSpeciesDiscovered(species, tracker)) { - discoveredSpecies++; - } - } - return discoveredSpecies; - } - public IIcon getUndiscoveredIcon() { return iconUndiscovered.getIcon(); } @@ -345,7 +314,6 @@ public abstract class BreedingSystem implements IItemStackRepresentative { discoveredSpeciesCount = 0; totalSecretCount = 0; discoveredSecretCount = 0; - Collection discoveredSpecies = getDiscoveredSpecies(tracker); Collection allSpecies = getAllSpecies(); for (IAlleleSpecies species : allSpecies) { @@ -388,7 +356,6 @@ public abstract class BreedingSystem implements IItemStackRepresentative { discoveredSpeciesPercentage = discoveredSpeciesCount / totalSpeciesCount; discoveredBranchPercentage = discoveredBranchCount / totalBranchCount; - String epithet = getEpitome(); onSyncBreedingTracker(tracker); } diff --git a/src/main/java/binnie/core/genetics/ForestryAllele.java b/src/main/java/binnie/core/genetics/ForestryAllele.java index 3b338f53..737c7daf 100644 --- a/src/main/java/binnie/core/genetics/ForestryAllele.java +++ b/src/main/java/binnie/core/genetics/ForestryAllele.java @@ -1,7 +1,5 @@ package binnie.core.genetics; -import binnie.Binnie; -import forestry.api.apiculture.IAlleleBeeSpecies; import forestry.api.genetics.AlleleManager; import forestry.api.genetics.IAllele; @@ -73,35 +71,6 @@ public class ForestryAllele { } } - public enum Sappiness { - Lowest, - Lower, - Low, - Average, - High, - Higher, - Highest; - - public IAllele getAllele() { - return AlleleManager.alleleRegistry.getAllele("forestry.sappiness" + toString()); - } - } - - public enum TreeHeight { - Smallest, - Smaller, - Small, - Average, - Large, - Larger, - Largest, - Gigantic; - - public IAllele getAllele() { - return AlleleManager.alleleRegistry.getAllele("forestry.height" + ((this == TreeHeight.Average) ? "Max10" : toString())); - } - } - public enum Size { Smallest, Smaller, @@ -116,58 +85,6 @@ public class ForestryAllele { } } - public enum Saplings { - Lowest, - Lower, - Low, - Average, - High, - Higher, - Highest; - - public IAllele getAllele() { - String s = toString(); - if (this == Saplings.Average) { - s = "Default"; - } - if (this == Saplings.High) { - s = "Double"; - } - if (this == Saplings.Higher) { - s = "Triple"; - } - return AlleleManager.alleleRegistry.getAllele("forestry.saplings" + s); - } - } - - public enum Yield { - Lowest, - Lower, - Low, - Average, - High, - Higher, - Highest; - - public IAllele getAllele() { - return AlleleManager.alleleRegistry.getAllele("forestry.yield" + ((this == Yield.Average) ? "Default" : toString())); - } - } - - public enum Maturation { - Slowest, - Slower, - Slow, - Average, - Fast, - Faster, - Fastest; - - public IAllele getAllele() { - return AlleleManager.alleleRegistry.getAllele("forestry.maturation" + toString()); - } - } - public enum Bool { True, False; @@ -181,14 +98,6 @@ public class ForestryAllele { } } - public enum Growth { - Tropical; - - public IAllele getAllele() { - return AlleleManager.alleleRegistry.getAllele("forestry.growth" + toString()); - } - } - public enum Int { Int1, Int2, @@ -205,47 +114,4 @@ public class ForestryAllele { return AlleleManager.alleleRegistry.getAllele("forestry.i" + (ordinal() + 1) + "d"); } } - - public enum BeeSpecies { - Modest, - Noble, - Forest, - Rural, - Marshy, - Sinister, - Tropical, - Wintry, - Merry, - Austere, - Imperial, - Ended, - Meadows, - Common, - Frugal, - Unweary, - Diligent, - Majestic, - Cultivated, - Industrious, - Valiant, - Secluded, - Hermitic, - Spectral, - Exotic, - Fiendish, - Monastic, - Steadfast, - Miry, - Farmerly, - Boggy, - Demonic; - - public IAlleleBeeSpecies getAllele() { - return (IAlleleBeeSpecies) AlleleManager.alleleRegistry.getAllele("forestry.species" + toString()); - } - - public IAllele[] getTemplate() { - return Binnie.Genetics.getBeeRoot().getTemplate(getAllele().getUID()); - } - } } diff --git a/src/main/java/binnie/extrabees/genetics/EnumBeeSpeciesState.java b/src/main/java/binnie/extrabees/genetics/EnumBeeSpeciesState.java deleted file mode 100644 index d01eba61..00000000 --- a/src/main/java/binnie/extrabees/genetics/EnumBeeSpeciesState.java +++ /dev/null @@ -1,7 +0,0 @@ -package binnie.extrabees.genetics; - -public enum EnumBeeSpeciesState { - ACTIVE, - INACTIVE, - DEPRECATED -} diff --git a/src/main/java/binnie/extrabees/genetics/ExtraBeeBranchDefinition.java b/src/main/java/binnie/extrabees/genetics/ExtraBeeBranchDefinition.java new file mode 100644 index 00000000..9df027ca --- /dev/null +++ b/src/main/java/binnie/extrabees/genetics/ExtraBeeBranchDefinition.java @@ -0,0 +1,320 @@ +package binnie.extrabees.genetics; + +import binnie.extrabees.genetics.effect.ExtraBeesEffect; +import binnie.genetics.genetics.AlleleHelper; +import forestry.api.apiculture.BeeManager; +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IClassification; +import forestry.apiculture.genetics.alleles.AlleleEffect; +import forestry.core.genetics.IBranchDefinition; +import forestry.core.genetics.alleles.EnumAllele; + +import java.util.Arrays; +import java.util.Locale; + +@SuppressWarnings("Duplicates") +public enum ExtraBeeBranchDefinition implements IBranchDefinition { + BARREN("Vacapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.DOWN_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.DEAD.getUID())); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + } + }, + HOSTILE("Infenapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.DOWN_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.TOLERANT_FLYER, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.DEAD.getUID())); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + } + }, + ROCKY("Monapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.TOLERANT_FLYER, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + } + }, + METALLIC("Lamminapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.TOLERANT_FLYER, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + } + }, + METALLIC2("Metalapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.TOLERANT_FLYER, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + } + }, + ALLOY("Allapis"), + PRECIOUS("Pluriapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.TOLERANT_FLYER, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + } + }, + MINERAL("Niphapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.TOLERANT_FLYER, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + } + }, + GEMSTONE("Gemmapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.TOLERANT_FLYER, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + } + }, + NUCLEAR("Levapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.TOLERANT_FLYER, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTEST); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.RADIOACTIVE.getUID())); + } + }, + HISTORIC("Priscapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.ELONGATED); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOW); + } + }, + FOSSILIZED("Fosiapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.NORMAL); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOW); + } + }, + REFINED("Petrapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.NORMAL); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOW); + } + }, + AQUATIC("Aquapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.TOLERANT_FLYER, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOWEST); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.WATER.getUID())); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.WATER.getUID())); + } + }, + SACCHARINE("Sacchapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.SUGAR.getUID())); + } + }, + CLASSICAL("Grecapis"), + VOLCANIC("Irrapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.NORMAL); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.METEOR.getUID())); + } + }, + VIRULENT("Virapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.JUNGLE); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleEffect.effectMiasmic); + } + }, + VISCOUS("Viscapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.JUNGLE); + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.ECTOPLASM.getUID())); + } + }, + CAUSTIC("Morbapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.JUNGLE); + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.FAST); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.AVERAGE); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.ACID.getUID())); + } + }, + ENERGETIC("Incitapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.REDSTONE.getUID())); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.LIGHTNING.getUID())); + } + }, + FARMING("Agriapis"), + SHADOW("Pullapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.NORMAL); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.BLINDNESS.getUID())); + } + }, + PRIMARY("Primapis"), + SECONDARY("Secapis"), + TERTIARY("Tertiapis"), + FTB("Eftebeapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.NORMAL); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleEffect.effectBeatific); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.MAXIMUM); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.MAXIMUM); + AlleleHelper.instance.set(template, EnumBeeChromosome.TERRITORY, EnumAllele.Territory.LARGEST); + } + }, + QUANTUM("Quantapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.LONGER); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.instance.set(template, EnumBeeChromosome.TERRITORY, EnumAllele.Territory.LARGE); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.END); + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.GRAVITY.getUID())); + } + }, + BOTANIA("Botaniapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.MYSTICAL.getUID())); + } + }; + + private final IClassification branch; + + ExtraBeeBranchDefinition(String scientific) { + branch = BeeManager.beeFactory.createBranch(name().toLowerCase(Locale.ENGLISH), scientific); + IClassification parent = AlleleManager.alleleRegistry.getClassification("family.apidae"); + if (parent != null) { + parent.addMemberGroup(branch); + } + } + + protected void setBranchProperties(IAllele[] template) { + // ignored + } + + @Override + public final IAllele[] getTemplate() { + IAllele[] template = getDefaultTemplate(); + setBranchProperties(template); + return template; + } + + @Override + public final IClassification getBranch() { + return branch; + } + + private static IAllele[] defaultTemplate; + + private static IAllele[] getDefaultTemplate() { + if (defaultTemplate == null) { + defaultTemplate = new IAllele[EnumBeeChromosome.values().length]; + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWEST); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTER); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.NORMAL); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.NONE); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.NOCTURNAL, false); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.NONE); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.TOLERANT_FLYER, false); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.CAVE_DWELLING, false); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.VANILLA); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOWEST); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.TERRITORY, EnumAllele.Territory.AVERAGE); + AlleleHelper.instance.set(defaultTemplate, EnumBeeChromosome.EFFECT, AlleleEffect.effectNone); + } + return Arrays.copyOf(defaultTemplate, defaultTemplate.length); + } +} diff --git a/src/main/java/binnie/extrabees/genetics/ExtraBeeDefinition.java b/src/main/java/binnie/extrabees/genetics/ExtraBeeDefinition.java new file mode 100644 index 00000000..d1526450 --- /dev/null +++ b/src/main/java/binnie/extrabees/genetics/ExtraBeeDefinition.java @@ -0,0 +1,1903 @@ +package binnie.extrabees.genetics; + +import binnie.core.Mods; +import binnie.extrabees.genetics.effect.ExtraBeesEffect; +import binnie.extrabees.products.EnumHoneyComb; +import binnie.extrabees.products.ItemHoneyComb; +import binnie.genetics.genetics.AlleleHelper; +import forestry.api.apiculture.BeeManager; +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.apiculture.EnumBeeType; +import forestry.api.apiculture.IAlleleBeeSpecies; +import forestry.api.apiculture.IAlleleBeeSpeciesCustom; +import forestry.api.apiculture.IBee; +import forestry.api.apiculture.IBeeGenome; +import forestry.api.core.EnumHumidity; +import forestry.api.core.EnumTemperature; +import forestry.api.genetics.IAllele; +import forestry.apiculture.genetics.Bee; +import forestry.apiculture.genetics.BeeBranchDefinition; +import forestry.apiculture.genetics.BeeDefinition; +import forestry.apiculture.genetics.IBeeDefinition; +import forestry.apiculture.genetics.alleles.AlleleEffect; +import forestry.core.genetics.IBranchDefinition; +import forestry.core.genetics.alleles.EnumAllele; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.BiomeDictionary; + +import java.awt.Color; +import java.util.Arrays; +import java.util.EnumSet; +import java.util.Locale; +import java.util.Map; + +public enum ExtraBeeDefinition implements IBeeDefinition { + /* BARREN BRANCH */ + ARID(ExtraBeeBranchDefinition.BARREN, "aridus", true, new Color(0xbee854), new Color(0xcbe374)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.30f) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.NORMAL); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MEADOWS, BeeDefinition.FRUGAL, 10); + registerMutation(BeeDefinition.FOREST, BeeDefinition.FRUGAL, 10); + } + }, + BARREN(ExtraBeeBranchDefinition.BARREN, "infelix", true, new Color(0xe0d263), new Color(0xcbe374)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.30f) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.COMMON, ARID, 10); + } + }, + DESOLATE(ExtraBeeBranchDefinition.BARREN, "desolo", false, new Color(0xd1b890), new Color(0xcbe374)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.30f) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.HUNGER.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(ARID, BARREN, 10); + } + }, + DECOMPOSING(ExtraBeeBranchDefinition.BARREN, "aegrus", true, new Color(0x523711), new Color(0xffffff)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.30f) + .addSpecialty(EnumHoneyComb.COMPOST.get(1), 0.08f) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MARSHY, BARREN, 15); + } + }, + GNAWING(ExtraBeeBranchDefinition.BARREN, "apica", true, new Color(0xe874b0), new Color(0xcbe374)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.25f) + .addSpecialty(EnumHoneyComb.SAWDUST.get(1), 0.25f) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.WOOD.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FOREST, BARREN, 15); + } + }, + + /* HOSTILE BRANCH */ + ROTTEN(ExtraBeeBranchDefinition.HOSTILE, "caries", true, new Color(0xbfe0b6), new Color(0xcbe374)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.30f) + .addSpecialty(EnumHoneyComb.ROTTEN.get(1), 0.10f) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.SPAWN_ZOMBIE.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MEADOWS, DESOLATE, 15); + } + }, + BONE(ExtraBeeBranchDefinition.HOSTILE, "os", true, new Color(0xe9ede8), new Color(0xcbe374)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.30f) + .addSpecialty(EnumHoneyComb.BONE.get(1), 0.10f) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.SPAWN_SKELETON.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FOREST, DESOLATE, 15); + } + }, + CREEPER(ExtraBeeBranchDefinition.HOSTILE, "erepo", true, new Color(0x2ce615), new Color(0xcbe374)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.30f) + .addSpecialty(ItemHoneyComb.VanillaComb.POWDERY.get(), 0.08f) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.SPAWN_CREEPER.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MODEST, DESOLATE, 15); + } + }, + + /* ROCKY BRANCH */ + ROCK(ExtraBeeBranchDefinition.ROCKY, "saxum", true, new Color(0xa8a8a8), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.STONE.get(1), 0.30f); + } + }, + STONE(ExtraBeeBranchDefinition.ROCKY, "lapis", false, new Color(0x757575), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.STONE.get(1), 0.30f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.DILIGENT, ROCK, 12); + } + }, + GRANITE(ExtraBeeBranchDefinition.ROCKY, "granum", true, new Color(0x695555), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.STONE.get(1), 0.30f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.UNWEARY, STONE, 10); + } + }, + MINERAL(ExtraBeeBranchDefinition.ROCKY, "minerale", true, new Color(0x6e757d), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.STONE.get(1), 0.30f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.instance.set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.INDUSTRIOUS, GRANITE, 6); + } + }, + + /* METALLIC BRANCH */ + COPPER(ExtraBeeBranchDefinition.METALLIC, "cuprous", true, new Color(0xd16308), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.COPPER.get(1), 0.06f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.WINTRY, MINERAL, 5); + registerMutation(BeeDefinition.MODEST, MINERAL, 5); + } + }, + TIN(ExtraBeeBranchDefinition.METALLIC, "stannus", true, new Color(0xbdb1bd), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.TIN.get(1), 0.06f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MARSHY, MINERAL, 5); + registerMutation(BeeDefinition.TROPICAL, MINERAL, 5); + } + }, + IRON(ExtraBeeBranchDefinition.METALLIC, "ferrous", false, new Color(0xa87058), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.IRON.get(1), 0.05f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MEADOWS, MINERAL, 5); + registerMutation(BeeDefinition.FOREST, MINERAL, 5); + } + }, + LEAD(ExtraBeeBranchDefinition.METALLIC, "plumbous", true, new Color(0xad8bab), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.LEAD.get(1), 0.05f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MEADOWS, MINERAL, 5); + registerMutation(BeeDefinition.MODEST, MINERAL, 5); + } + }, + + /* METALLIC2 BRANCH */ + ZINC(ExtraBeeBranchDefinition.METALLIC2, "spelta", true, new Color(0xedebff), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.ZINC.get(1), 0.05f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.WINTRY, MINERAL, 5); + registerMutation(BeeDefinition.TROPICAL, MINERAL, 5); + } + }, + TITANIUM(ExtraBeeBranchDefinition.METALLIC2, "titania", true, new Color(0xb0aae3), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.TITANIUM.get(1), 0.02f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.CULTIVATED, MINERAL, 3); + } + }, + TUNGSTATE(ExtraBeeBranchDefinition.METALLIC2, "wolfram", true, new Color(0x131214), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.TUNGSTEN.get(1), 0.01f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.COMMON, MINERAL, 3); + } + }, + NICKEL(ExtraBeeBranchDefinition.METALLIC2, "claro", true, new Color(0xffdefc), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.NICKEL.get(1), 0.05f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FOREST, MINERAL, 5); + registerMutation(BeeDefinition.MARSHY, MINERAL, 5); + } + }, + + /* PRECIOUS BRANCH */ + GOLD(ExtraBeeBranchDefinition.PRECIOUS, "aureus", true, new Color(0xe6cc0b), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.GOLD.get(1), 0.02f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MAJESTIC, IRON, 2); + registerMutation(BeeDefinition.MAJESTIC, COPPER, 2); + registerMutation(BeeDefinition.MAJESTIC, NICKEL, 2); + registerMutation(BeeDefinition.MAJESTIC, TUNGSTATE, 2); + } + }, + SILVER(ExtraBeeBranchDefinition.PRECIOUS, "argentus", false, new Color(0x43455b), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.SILVER.get(1), 0.02f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MAJESTIC, ZINC, 2); + registerMutation(BeeDefinition.MAJESTIC, TIN, 2); + registerMutation(BeeDefinition.MAJESTIC, LEAD, 2); + registerMutation(BeeDefinition.MAJESTIC, TITANIUM, 2); + } + }, + //ELECTRUM, + PLATINUM(ExtraBeeBranchDefinition.PRECIOUS, "platina", false, new Color(0xdbdbdb), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.PLATINUM.get(1), 0.01f); + } + + @Override + protected void registerMutations() { + registerMutation(GOLD, SILVER, 2); + } + }, + + /* MINERAL BRANCH */ + LAPIS(ExtraBeeBranchDefinition.MINERAL, "lazuli", true, new Color(0x3d2cdb), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.LAPIS.get(1), 0.05f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.IMPERIAL, MINERAL, 5); + } + }, + //SODALITE, + //PYRITE, + //BAUXITE, + //CINNABAR, + //SPHALERITE, + + /* GEMSTONE BRANCH */ + EMERALD(ExtraBeeBranchDefinition.GEMSTONE, "emerala", true, new Color(0x1cff03), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.EMERALD.get(1), 0.04f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FOREST, LAPIS, 5); + } + }, + RUBY(ExtraBeeBranchDefinition.GEMSTONE, "ruba", true, new Color(0xd60000), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.RUBY.get(1), 0.03f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MODEST, LAPIS, 5); + } + }, + SAPPHIRE(ExtraBeeBranchDefinition.GEMSTONE, "saphhira", true, new Color(0x0a47ff), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.SAPPHIRE.get(1), 0.03f); + } + + @Override + protected void registerMutations() { + registerMutation(WATER, LAPIS, 5); + } + }, + //OLIVINE, + DIAMOND(ExtraBeeBranchDefinition.GEMSTONE, "diama", true, new Color(0x7fbdfa), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.STONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.DIAMOND.get(1), 0.01f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.CULTIVATED, LAPIS, 5); + } + }, + + /* NUCLEAR BRANCH */ + UNSTABLE(ExtraBeeBranchDefinition.NUCLEAR, "levis", false, new Color(0x3e8c34), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.BARREN.get(1), 0.20f); + } + + @Override + protected void registerMutations() { + registerMutation(PREHISTORIC, MINERAL, 5); + } + }, + NUCLEAR(ExtraBeeBranchDefinition.NUCLEAR, "nucleus", false, new Color(0x41cc2f), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.BARREN.get(1), 0.20f); + } + + @Override + protected void registerMutations() { + registerMutation(UNSTABLE, IRON, 5); + registerMutation(UNSTABLE, COPPER, 5); + registerMutation(UNSTABLE, TIN, 5); + registerMutation(UNSTABLE, ZINC, 5); + registerMutation(UNSTABLE, NICKEL, 5); + registerMutation(UNSTABLE, LEAD, 5); + } + }, + RADIOACTIVE(ExtraBeeBranchDefinition.NUCLEAR, "fervens", false, new Color(0x1eff00), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.URANIUM.get(1), 0.02f) + .setHasEffect(); + } + + @Override + protected void registerMutations() { + registerMutation(NUCLEAR, GOLD, 5); + registerMutation(NUCLEAR, SILVER, 5); + } + }, + YELLORIUM(ExtraBeeBranchDefinition.NUCLEAR, "yellori", true, new Color(0xd5ed00), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.YELLORIUM.get(1), 0.02f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTEST); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.RADIOACTIVE.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FRUGAL, NUCLEAR, 5); + } + }, + CYANITE(ExtraBeeBranchDefinition.NUCLEAR, "cyanita", true, new Color(0x0086ed), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.CYANITE.get(1), 0.01f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTEST); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.RADIOACTIVE.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(NUCLEAR, YELLORIUM, 5); + } + }, + BLUTONIUM(ExtraBeeBranchDefinition.NUCLEAR, "caruthus", true, new Color(0x1b00e6), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.BLUTONIUM.get(1), 0.01f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTEST); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.RADIOACTIVE.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(CYANITE, YELLORIUM, 5); + } + }, + + /* HISTORIC BRANCH */ + ANCIENT(ExtraBeeBranchDefinition.HISTORIC, "antiquus", true, new Color(0xf2db8f), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.OLD.get(1), 0.30f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.NOBLE, BeeDefinition.DILIGENT, 10); + } + }, + PRIMEVAL(ExtraBeeBranchDefinition.HISTORIC, "priscus", true, new Color(0xb3a67b), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.OLD.get(1), 0.30f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.LONG); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.SECLUDED, ANCIENT, 8); + } + }, + PREHISTORIC(ExtraBeeBranchDefinition.HISTORIC, "pristinus", false, new Color(0x6e5a40), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.OLD.get(1), 0.30f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.LONGER); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + } + + @Override + protected void registerMutations() { + registerMutation(PRIMEVAL, ANCIENT, 8); + } + }, + RELIC(ExtraBeeBranchDefinition.HISTORIC, "sapiens", true, new Color(0x4d3e16), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.OLD.get(1), 0.30f) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.LONGEST); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.IMPERIAL, PREHISTORIC, 8); + } + }, + + /* FOSSILIZED BRANCH */ + COAL(ExtraBeeBranchDefinition.FOSSILIZED, "carbo", true, new Color(0x7a7648), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.OLD.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.COAL.get(1), 0.08f); + } + + @Override + protected void registerMutations() { + registerMutation(PRIMEVAL, GROWING, 8); + registerMutation(BeeDefinition.RURAL, PRIMEVAL, 8); + } + }, + RESIN(ExtraBeeBranchDefinition.FOSSILIZED, "lacrima", false, new Color(0xa6731b), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.OLD.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.RESIN.get(1), 0.05f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MIRY, PRIMEVAL, 8); + } + }, + OIL(ExtraBeeBranchDefinition.FOSSILIZED, "lubricus", true, new Color(0x574770), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.OLD.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.OIL.get(1), 0.05f); + } + + @Override + protected void registerMutations() { + registerMutation(OCEAN, PRIMEVAL, 8); + registerMutation(BeeDefinition.FRUGAL, PRIMEVAL, 8); + } + }, + // PEAT, + + /* REFINED BRANCH */ + DISTILLED(ExtraBeeBranchDefinition.REFINED, "distilli", false, new Color(0x356356), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.OLD.get(1), 0.10f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.INDUSTRIOUS, OIL, 8); + } + }, + FUEL(ExtraBeeBranchDefinition.REFINED, "refina", true, new Color(0xffc003), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.OIL.get(1), 0.10f) + .addSpecialty(EnumHoneyComb.FUEL.get(1), 0.04f) + .setHasEffect(); + } + + @Override + protected void registerMutations() { + registerMutation(DISTILLED, OIL, 8); + } + }, + CREOSOTE(ExtraBeeBranchDefinition.REFINED, "creosota", true, new Color(0x979e13), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.COAL.get(1), 0.10f) + .addSpecialty(EnumHoneyComb.CREOSOTE.get(1), 0.07f) + .setHasEffect(); + } + + @Override + protected void registerMutations() { + registerMutation(DISTILLED, COAL, 8); + } + }, + LATEX(ExtraBeeBranchDefinition.REFINED, "latex", true, new Color(0x494a3e), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.RESIN.get(1), 0.10f) + .addSpecialty(EnumHoneyComb.LATEX.get(1), 0.05f) + .setHasEffect(); + } + + @Override + protected void registerMutations() { + registerMutation(DISTILLED, RESIN, 8); + } + }, + + /* AQUATIC BRANCH */ + WATER(ExtraBeeBranchDefinition.AQUATIC, "aqua", true, new Color(0x94a2ff), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.WATER.get(1), 0.30f) + .setHumidity(EnumHumidity.DAMP); + } + }, + RIVER(ExtraBeeBranchDefinition.AQUATIC, "flumen", true, new Color(0x83b3d4), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.WATER.get(1), 0.30f) + .addSpecialty(EnumHoneyComb.CLAY.get(1), 0.20f) + .setHumidity(EnumHumidity.DAMP); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.DILIGENT, WATER, 10) + .restrictBiomeType(BiomeDictionary.Type.RIVER); + } + }, + OCEAN(ExtraBeeBranchDefinition.AQUATIC, "mare", false, new Color(0x1d2ead), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.WATER.get(1), 0.30f) + .setHumidity(EnumHumidity.DAMP); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.DILIGENT, WATER, 10) + .restrictBiomeType(BiomeDictionary.Type.OCEAN); + } + }, + INK(ExtraBeeBranchDefinition.AQUATIC, "atramentum", true, new Color(0xe1447), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.WATER.get(1), 0.30f) + .addSpecialty(new ItemStack(Items.dye, 1, 0), 0.10f) + .setHumidity(EnumHumidity.DAMP); + } + + @Override + protected void registerMutations() { + registerMutation(BLACK, OCEAN, 8); + } + }, + + /* AGRARIAN BRANCH */ + GROWING(BeeBranchDefinition.AGRARIAN, "tyrelli", true, new Color(0x5bebd8), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.35f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.HIGH); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.AVERAGE); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.LEAVES.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FOREST, BeeDefinition.DILIGENT, 10); + } + }, + FARM(BeeBranchDefinition.AGRARIAN, "ager", true, new Color(0x75db60), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.WHEATEN.get(), 0.30f) + .addSpecialty(EnumHoneyComb.SEED.get(1), 0.10f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FARMERLY, BeeDefinition.MEADOWS, 10); + } + }, + THRIVING(BeeBranchDefinition.AGRARIAN, "thriva", true, new Color(0x34e37d), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.35f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.HIGH); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.FAST); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.LEAVES.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.UNWEARY, GROWING, 10); + } + }, + BLOOMING(BeeBranchDefinition.AGRARIAN, "blooma", true, new Color(0x0abf34), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.35f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.HIGH); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.FASTEST); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.SAPLING.getUID())); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.BONEMEAL_SAPLING.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.INDUSTRIOUS, THRIVING, 8); + } + }, + + /* SACCHARINE BRANCH */ + SWEET(ExtraBeeBranchDefinition.SACCHARINE, "mellitus", true, new Color(0xfc51f1), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.40f) + .addProduct(new ItemStack(Items.sugar, 1, 0), 0.10f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.VALIANT, BeeDefinition.DILIGENT, 15); + } + }, + SUGAR(ExtraBeeBranchDefinition.SACCHARINE, "dulcis", true, new Color(0xe6d3e0), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.40f) + .addProduct(new ItemStack(Items.sugar, 1, 0), 0.20f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.RURAL, SWEET, 15); + } + }, + RIPENING(ExtraBeeBranchDefinition.SACCHARINE, "ripa", true, new Color(0xb2c75d), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f) + .addProduct(new ItemStack(Items.sugar, 1, 0), 0.10f) + .addSpecialty(EnumHoneyComb.FRUIT.get(1), 0.10f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.FRUIT.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(SWEET, GROWING, 5); + } + }, + FRUIT(ExtraBeeBranchDefinition.SACCHARINE, "pomum", true, new Color(0xdb5876), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f) + .addProduct(new ItemStack(Items.sugar, 1, 0), 0.15f) + .addSpecialty(EnumHoneyComb.FRUIT.get(1), 0.20f) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.BONEMEAL_FRUIT.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(SWEET, THRIVING, 5); + } + }, + + /* FARMING BRANCH */ + ALCOHOL(ExtraBeeBranchDefinition.FARMING, "vinum", false, new Color(0xe88a61), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.WHEATEN.get(), 0.30f) + .addSpecialty(EnumHoneyComb.ALCOHOL.get(1), 0.10f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele("forestry.effectDrunkard")); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FARMERLY, BeeDefinition.MEADOWS, 10); + } + }, + MILK(ExtraBeeBranchDefinition.FARMING, "lacteus", true, new Color(0xe3e8e8), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.WHEATEN.get(), 0.30f) + .addSpecialty(EnumHoneyComb.MILK.get(1), 0.10f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FARMERLY, ExtraBeeDefinition.WATER, 10); + } + }, + COFFEE(ExtraBeeBranchDefinition.FARMING, "arabica", true, new Color(0x8c5e30), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.WHEATEN.get(), 0.30f) + .addSpecialty(EnumHoneyComb.COFFEE.get(1), 0.08f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FARMERLY, BeeDefinition.TROPICAL, 10); + } + }, + //CITRUS, + //MINT, + + /* BOGGY BRANCH */ + SWAMP(BeeBranchDefinition.BOGGY, "paludis", true, new Color(0x356933), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.MOSSY.get(), 0.30f) + .setHumidity(EnumHumidity.DAMP); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.SLOW.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MIRY, WATER, 10); + } + }, + BOGGY(BeeBranchDefinition.BOGGY, "lama", false, new Color(0x785c29), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.MOSSY.get(), 0.30f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.SLOW.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.BOGGY, SWAMP, 8); + } + }, + FUNGAL(BeeBranchDefinition.BOGGY, "boletus", true, new Color(0xd16200), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.MOSSY.get(), 0.30f) + .addSpecialty(EnumHoneyComb.FUNGAL.get(1), 0.15f) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.BONEMEAL_MUSHROOM.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.BOGGY, BeeDefinition.MIRY, 8); + registerMutation(BeeDefinition.BOGGY, FUNGAL, 8); + } + }, + + /* CLASSICAL BRANCH */ + //MARBLE, + //ROMAN, + //GREEK, + //CLASSICAL, + + /* VOLCANIC BRANCH */ + BASALT(ExtraBeeBranchDefinition.VOLCANIC, "aceri", true, new Color(0x8c6969), new Color(0x9a2323)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SIMMERING.get(), 0.25f) + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleEffect.effectAggressive); + } + }, + TEMPERED(ExtraBeeBranchDefinition.VOLCANIC, "iratus", false, new Color(0x8a4848), new Color(0x9a2323)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SIMMERING.get(), 0.25f) + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FIENDISH, ExtraBeeDefinition.BASALT, 30) + .restrictBiomeType(BiomeDictionary.Type.NETHER); + } + }, + //ANGRY, + VOLCANIC(ExtraBeeBranchDefinition.VOLCANIC, "volcano", true, new Color(0x4d0c0c), new Color(0x9a2323)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SIMMERING.get(), 0.25f) + .addSpecialty(EnumHoneyComb.BLAZE.get(1), 0.10f) + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID) + .setHasEffect(); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.DEMONIC, ExtraBeeDefinition.TEMPERED, 20) + .restrictBiomeType(BiomeDictionary.Type.NETHER); + } + }, + GLOWSTONE(ExtraBeeBranchDefinition.VOLCANIC, "glowia", true, new Color(0xe0c61b), new Color(0x9a2323)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.GLOWSTONE.get(1), 0.15f) + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleEffect.effectAggressive); + } + + @Override + protected void registerMutations() { + registerMutation(ExtraBeeDefinition.TEMPERED, ExtraBeeDefinition.EXCITED, 5); + } + }, + + /* VIRULENT BRANCH */ + MALICIOUS(ExtraBeeBranchDefinition.VIRULENT, "acerbus", true, new Color(0x782a77), new Color(0x069764)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f) + .setHumidity(EnumHumidity.DAMP) + .setTemperature(EnumTemperature.WARM); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.SINISTER, BeeDefinition.TROPICAL, 10); + } + }, + INFECTIOUS(ExtraBeeBranchDefinition.VIRULENT, "contagio", true, new Color(0xb82eb5), new Color(0x069764)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOW); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.TROPICAL, ExtraBeeDefinition.MALICIOUS, 8); + } + }, + VIRULENT(ExtraBeeBranchDefinition.VIRULENT, "morbus", false, new Color(0xf013ec), new Color(0x069764)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f) + .addSpecialty(EnumHoneyComb.VENOMOUS.get(1), 0.12f) + .setHumidity(EnumHumidity.DAMP) + .setTemperature(EnumTemperature.WARM) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.AVERAGE); + } + + @Override + protected void registerMutations() { + registerMutation(ExtraBeeDefinition.MALICIOUS, ExtraBeeDefinition.INFECTIOUS, 8); + } + }, + + /* VISCOUS BRANCH */ + VISCOUS(ExtraBeeBranchDefinition.VISCOUS, "liquidus", true, new Color(0x9470e), new Color(0x069764)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f) + .setHumidity(EnumHumidity.DAMP) + .setTemperature(EnumTemperature.WARM); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.EXOTIC, ExtraBeeDefinition.WATER, 10); + } + }, + GLUTINOUS(ExtraBeeBranchDefinition.VISCOUS, "glutina", true, new Color(0x1d8c27), new Color(0x069764)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f) + .setHumidity(EnumHumidity.DAMP) + .setTemperature(EnumTemperature.WARM); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.NORMAL); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.EXOTIC, ExtraBeeDefinition.VISCOUS, 8); + } + }, + STICKY(ExtraBeeBranchDefinition.VISCOUS, "lentesco", true, new Color(0x17e328), new Color(0x069764)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f) + .addSpecialty(EnumHoneyComb.SLIME.get(1), 0.12f) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.FAST); + } + + @Override + protected void registerMutations() { + registerMutation(ExtraBeeDefinition.VISCOUS, ExtraBeeDefinition.GLUTINOUS, 8); + } + }, + + /* CAUSTIC BRANCH */ + CORROSIVE(ExtraBeeBranchDefinition.CAUSTIC, "corrumpo", false, new Color(0x4a5c0b), new Color(0x069764)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.20f) + .setHumidity(EnumHumidity.DAMP) + .setTemperature(EnumTemperature.WARM); + } + + @Override + protected void registerMutations() { + registerMutation(ExtraBeeDefinition.MALICIOUS, ExtraBeeDefinition.VISCOUS, 10); + } + }, + CAUSTIC(ExtraBeeBranchDefinition.CAUSTIC, "torrens", true, new Color(0x84a11d), new Color(0x069764)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f) + .addSpecialty(EnumHoneyComb.ACIDIC.get(1), 0.03f) + .setHumidity(EnumHumidity.DAMP) + .setTemperature(EnumTemperature.WARM); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FIENDISH, ExtraBeeDefinition.CORROSIVE, 8); + } + }, + ACIDIC(ExtraBeeBranchDefinition.CAUSTIC, "acidus", true, new Color(0xc0f016), new Color(0x069764)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.20f) + .addSpecialty(EnumHoneyComb.ACIDIC.get(1), 0.16f) + .setHumidity(EnumHumidity.DAMP) + .setTemperature(EnumTemperature.WARM) + .setHasEffect(); + } + + @Override + protected void registerMutations() { + registerMutation(ExtraBeeDefinition.CORROSIVE, ExtraBeeDefinition.CAUSTIC, 4); + } + }, + + /* ENERGETIC BRANCH */ + EXCITED(ExtraBeeBranchDefinition.ENERGETIC, "excita", true, new Color(0xff4545), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.REDSTONE.get(1), 0.10f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.VALIANT, BeeDefinition.CULTIVATED, 10); + } + }, + ENERGETIC(ExtraBeeBranchDefinition.ENERGETIC, "energia", false, new Color(0xe835c7), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.REDSTONE.get(1), 0.12f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.DILIGENT, ExtraBeeDefinition.EXCITED, 8); + } + }, + ECSTATIC(ExtraBeeBranchDefinition.ENERGETIC, "ecstatica", true, new Color(0xaf35e8), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.REDSTONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.IC2ENERGY.get(1), 0.08f) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.POWER.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(ExtraBeeDefinition.EXCITED, ExtraBeeDefinition.ENERGETIC, 8); + } + }, + + /* FROZEN BRANCH */ + ARTIC(BeeBranchDefinition.FROZEN, "artica", true, new Color(0xade0e0), new Color(0xdaf5f3)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.FROZEN.get(), 0.25f) + .setTemperature(EnumTemperature.ICY); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.MAXIMUM); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.WINTRY, BeeDefinition.DILIGENT, 10); + } + }, + FREEZING(BeeBranchDefinition.FROZEN, "glacia", true, new Color(0x7be3e3), new Color(0xdaf5f3)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.FROZEN.get(), 0.20f) + .addSpecialty(EnumHoneyComb.GLACIAL.get(1), 0.10f) + .setTemperature(EnumTemperature.ICY); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.MAXIMUM); + } + + @Override + protected void registerMutations() { + registerMutation(ExtraBeeDefinition.OCEAN, ExtraBeeDefinition.ARTIC, 10); + } + }, + + /* SHADOW BRANCH */ + SHADOW(ExtraBeeBranchDefinition.SHADOW, "shadowa", false, new Color(0x595959), new Color(0x333333)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.SHADOW.get(1), 0.05f) + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.SINISTER, ExtraBeeDefinition.ROCK, 10); + } + }, + DARKENED(ExtraBeeBranchDefinition.SHADOW, "darka", true, new Color(0x332e33), new Color(0x333333)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.SHADOW.get(1), 0.10f) + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void registerMutations() { + registerMutation(ExtraBeeDefinition.SHADOW, ExtraBeeDefinition.ROCK, 8); + } + }, + ABYSS(ExtraBeeBranchDefinition.SHADOW, "abyssba", true, new Color(0x210821), new Color(0x333333)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.SHADOW.get(1), 0.25f) + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.WITHER.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(ExtraBeeDefinition.SHADOW, ExtraBeeDefinition.DARKENED, 8); + } + }, + + /* PRIMARY BRNCH */ + RED(ExtraBeeBranchDefinition.PRIMARY, "rubra", true, new Color(0xff0000), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.RED.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.FOREST, BeeDefinition.VALIANT, 5); + } + }, + YELLOW(ExtraBeeBranchDefinition.PRIMARY, "fulvus", true, new Color(0xffdd00), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.YELLOW.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MEADOWS, BeeDefinition.VALIANT, 5); + } + }, + BLUE(ExtraBeeBranchDefinition.PRIMARY, "caeruleus", true, new Color(0x0022ff), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.BLUE.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.VALIANT, ExtraBeeDefinition.WATER, 5); + } + }, + GREEN(ExtraBeeBranchDefinition.PRIMARY, "prasinus", true, new Color(0x009900), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.GREEN.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.TROPICAL, BeeDefinition.VALIANT, 5); + } + }, + BLACK(ExtraBeeBranchDefinition.PRIMARY, "niger", true, new Color(0x575757), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.BLACK.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.VALIANT, ExtraBeeDefinition.ROCK, 5); + } + }, + WHITE(ExtraBeeBranchDefinition.PRIMARY, "albus", true, new Color(0xffffff), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.WHITE.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.WINTRY, BeeDefinition.VALIANT, 5); + } + }, + BROWN(ExtraBeeBranchDefinition.PRIMARY, "fuscus", true, new Color(0x5c350f), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.BROWN.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.MARSHY, BeeDefinition.VALIANT, 5); + } + }, + + /* SECONDARY BRANCH */ + ORANGE(ExtraBeeBranchDefinition.SECONDARY, "flammeus", true, new Color(0xff9d00), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.ORANGE.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(RED, YELLOW, 5); + } + }, + CYAN(ExtraBeeBranchDefinition.SECONDARY, "cyana", true, new Color(0x00ffe5), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.CYAN.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(GREEN, BLUE, 5); + } + }, + PURPLE(ExtraBeeBranchDefinition.SECONDARY, "purpureus", true, new Color(0xae00ff), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.PURPLE.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(RED, BLUE, 5); + } + }, + GRAY(ExtraBeeBranchDefinition.SECONDARY, "ravus", true, new Color(0xbababa), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.GRAY.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(BLACK, WHITE, 5); + } + }, + LIGHTBLUE(ExtraBeeBranchDefinition.SECONDARY, "aqua", true, new Color(0x009dff), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.LIGHTBLUE.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(BLUE, WHITE, 5); + } + }, + PINK(ExtraBeeBranchDefinition.SECONDARY, "rosaceus", true, new Color(0xff80df), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.PINK.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(RED, WHITE, 5); + } + }, + LIMEGREEN(ExtraBeeBranchDefinition.SECONDARY, "lima", true, new Color(0x00ff08), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.LIMEGREEN.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(GREEN, WHITE, 5); + } + }, + + /* TERTIARY BRANCH */ + MAGENTA(ExtraBeeBranchDefinition.TERTIARY, "fuchsia", true, new Color(0xff00cc), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.MAGENTA.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(PURPLE, PINK, 5); + } + }, + LIGHTGRAY(ExtraBeeBranchDefinition.TERTIARY, "canus", true, new Color(0xc9c9c9), new Color(0x8cff00)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f) + .addSpecialty(EnumHoneyComb.LIGHTGRAY.get(1), 0.25f); + } + + @Override + protected void registerMutations() { + registerMutation(GRAY, WHITE, 5); + } + }, + + /* FESTIVE BRANCH */ + CELEBRATORY(BeeBranchDefinition.FESTIVE, "celeba", true, new Color(0xfa0a6a), new Color(0xd40000)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies.setTemperature(EnumTemperature.ICY); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, true); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.FIREWORKS.getUID())); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.AUSTERE, EXCITED, 5); + } + }, + + /* FTB BRANCH */ + JADED(ExtraBeeBranchDefinition.FTB, "jadeca", true, new Color(0xfa0a6a), new Color(0xdc8aeb)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f) + .addSpecialty(Mods.Forestry.stack("pollen"), 0.20f) + .addSpecialty(EnumHoneyComb.PURPLE.get(1), 0.15f) + .setIsNotCounted() + .setHasEffect(); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.ENDED, RELIC, 2) + .restrictPerson("jadedcat"); + } + }, + + /* AUSTERE BRANCH */ + HAZARDOUS(BeeBranchDefinition.AUSTERE, "infensus", true, new Color(0xb06c28), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.SALTPETER.get(1), 0.12f) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWEST); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.LONGER); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.DOWN_2); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleEffect.effectCreeper); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.AUSTERE, DESOLATE, 5); + } + }, + + /* ALLOY BRANCH */ + //INVAR, + //BRONZE, + //BRASS, + //STEEL, + + /* QUANTUM BRANCH */ + QUANTUM(ExtraBeeBranchDefinition.QUANTUM, "quanta", true, new Color(0x37c5db), new Color(0xd50fdb)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.QUARTZ.get(), 0.25f) + .addSpecialty(EnumHoneyComb.CERTUS.get(1), 0.15f) + .addSpecialty(EnumHoneyComb.ENDERPEARL.get(1), 0.15f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.instance.set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.NORMAL); + AlleleHelper.instance.set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWEST); + AlleleHelper.instance.set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTER); + AlleleHelper.instance.set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.NONE); + AlleleHelper.instance.set(template, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.VANILLA); + AlleleHelper.instance.set(template, EnumBeeChromosome.NOCTURNAL, false); + AlleleHelper.instance.set(template, EnumBeeChromosome.TERRITORY, EnumAllele.Territory.AVERAGE); + AlleleHelper.instance.set(template, EnumBeeChromosome.EFFECT, AlleleEffect.effectNone); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.SPECTRAL, SPATIAL, 5); + } + }, + UNUSUAL(ExtraBeeBranchDefinition.QUANTUM, "daniella", true, new Color(0x59a4ba), new Color(0xbaa2eb)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.QUARTZ.get(), 0.25f) + .setTemperature(EnumTemperature.COLD); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.SECLUDED, BeeDefinition.ENDED, 5); + } + }, + SPATIAL(ExtraBeeBranchDefinition.QUANTUM, "spatia", true, new Color(0x4c1be0), new Color(0xa44ecc)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.QUARTZ.get(), 0.25f) + .addSpecialty(EnumHoneyComb.CERTUS.get(1), 0.05f) + .setTemperature(EnumTemperature.COLD); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.HERMITIC, UNUSUAL, 5); + } + }, + + /* BOTANIA BRANCH */ + MYSTICAL(ExtraBeeBranchDefinition.BOTANIA, "mystica", true, new Color(0x46a722), new Color(0xffffff)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + Map products = BeeDefinition.NOBLE.getGenome().getPrimary().getProductChances(); + for (Map.Entry entry : products.entrySet()) { + beeSpecies.addProduct(entry.getKey(), entry.getValue()); + } + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.NOBLE, BeeDefinition.MONASTIC, 5); + } + }; + + private static final EnumSet overworldHiveBees = EnumSet.of(ROCK, WATER, BASALT); + + private final IBranchDefinition branch; + private final IAlleleBeeSpeciesCustom species; + + private IAllele[] template; + private IBeeGenome genome; + + ExtraBeeDefinition(IBranchDefinition branch, String binomial, boolean dominant, Color primary, Color secondary) { + String species = toString().toLowerCase(Locale.ENGLISH); + String uid = "extrabees.species." + species; + String description = "extrabees.species." + species + ".desc"; + String name = "extrabees.species." + species + ".name"; + + this.branch = branch; + if (branch != null) { + this.species = BeeManager.beeFactory.createSpecies(uid, dominant, "Binnie", name, description, branch.getBranch(), binomial, primary.getRGB(), secondary.getRGB()); + } else { + this.species = null; + } + } + + protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) { + // ignored + } + + protected void setAlleles(IAllele[] template) { + // ignored + } + + protected void registerMutations() { + // can be found in hive + } + + protected boolean isNeedRegister() { + return branch != null; + } + + public static void initBees() { + for (ExtraBeeDefinition bee : values()) { + if (bee.isNeedRegister()) { + bee.init(); + bee.registerMutations(); + } + } + + registerMutation(BeeDefinition.FOREST, ExtraBeeDefinition.WATER, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.MEADOWS, ExtraBeeDefinition.WATER, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.MODEST, ExtraBeeDefinition.WATER, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.TROPICAL, ExtraBeeDefinition.WATER, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.MARSHY, ExtraBeeDefinition.WATER, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.WINTRY, ExtraBeeDefinition.WATER, BeeDefinition.COMMON, 15); + registerMutation(ExtraBeeDefinition.ROCK, ExtraBeeDefinition.WATER, BeeDefinition.COMMON, 15); + registerMutation(ExtraBeeDefinition.BASALT, ExtraBeeDefinition.WATER, BeeDefinition.COMMON, 15); + + registerMutation(BeeDefinition.FOREST, ExtraBeeDefinition.ROCK, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.MEADOWS, ExtraBeeDefinition.ROCK, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.MODEST, ExtraBeeDefinition.ROCK, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.TROPICAL, ExtraBeeDefinition.ROCK, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.MARSHY, ExtraBeeDefinition.ROCK, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.WINTRY, ExtraBeeDefinition.ROCK, BeeDefinition.COMMON, 15); + registerMutation(ExtraBeeDefinition.BASALT, ExtraBeeDefinition.ROCK, BeeDefinition.COMMON, 15); + + registerMutation(BeeDefinition.FOREST, ExtraBeeDefinition.BASALT, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.MEADOWS, ExtraBeeDefinition.BASALT, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.MODEST, ExtraBeeDefinition.BASALT, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.TROPICAL, ExtraBeeDefinition.BASALT, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.MARSHY, ExtraBeeDefinition.BASALT, BeeDefinition.COMMON, 15); + registerMutation(BeeDefinition.WINTRY, ExtraBeeDefinition.BASALT, BeeDefinition.COMMON, 15); + + registerMutation(BeeDefinition.COMMON, ExtraBeeDefinition.WATER, BeeDefinition.CULTIVATED, 12); + registerMutation(BeeDefinition.COMMON, ExtraBeeDefinition.ROCK, BeeDefinition.CULTIVATED, 12); + registerMutation(BeeDefinition.COMMON, ExtraBeeDefinition.BASALT, BeeDefinition.CULTIVATED, 12); + + registerMutation(BeeDefinition.CULTIVATED, BASALT, BeeDefinition.SINISTER, 60) + .restrictBiomeType(BiomeDictionary.Type.NETHER); + + registerMutation(BeeDefinition.SINISTER, BASALT, BeeDefinition.FIENDISH, 40) + .restrictBiomeType(BiomeDictionary.Type.NETHER); + } + + private void init() { + if (!overworldHiveBees.contains(this)) { + species.setIsSecret(); + } + setSpeciesProperties(species); + + template = branch.getTemplate(); + AlleleHelper.instance.set(template, EnumBeeChromosome.SPECIES, species); + setAlleles(template); + + genome = BeeManager.beeRoot.templateAsGenome(template); + BeeManager.beeRoot.registerTemplate(template); + } + + protected final ExtraBeeMutation registerMutation(ExtraBeeDefinition parent1, ExtraBeeDefinition parent2, int chance) { + return registerMutation(parent1.species, parent2.species, chance); + } + + protected final ExtraBeeMutation registerMutation(BeeDefinition parent1, ExtraBeeDefinition parent2, int chance) { + return registerMutation(parent1.getGenome().getPrimary(), parent2.species, chance); + } + + protected final ExtraBeeMutation registerMutation(BeeDefinition parent1, BeeDefinition parent2, int chance) { + return registerMutation(parent1.getGenome().getPrimary(), parent2.getGenome().getPrimary(), chance); + } + + protected final ExtraBeeMutation registerMutation(IAlleleBeeSpecies parent1, IAlleleBeeSpecies parent2, int chance) { + ExtraBeeMutation mutation = new ExtraBeeMutation(parent1, parent2, getTemplate(), chance); + BeeManager.beeRoot.registerMutation(mutation); + return mutation; + } + + private static ExtraBeeMutation registerMutation(ExtraBeeDefinition parent1, ExtraBeeDefinition parent2, BeeDefinition result, int chance) { + ExtraBeeMutation mutation = new ExtraBeeMutation(parent1.species, parent2.species, result.getTemplate(), chance); + BeeManager.beeRoot.registerMutation(mutation); + return mutation; + } + + private static ExtraBeeMutation registerMutation(BeeDefinition parent1, ExtraBeeDefinition parent2, BeeDefinition result, int chance) { + ExtraBeeMutation mutation = new ExtraBeeMutation(parent1.getGenome().getPrimary(), parent2.species, result.getTemplate(), chance); + BeeManager.beeRoot.registerMutation(mutation); + return mutation; + } + + @Override + public final IAllele[] getTemplate() { + return Arrays.copyOf(template, template.length); + } + + @Override + public final IBeeGenome getGenome() { + return genome; + } + + @Override + public final IBee getIndividual() { + return new Bee(genome); + } + + @Override + public final ItemStack getMemberStack(EnumBeeType beeType) { + IBee bee = getIndividual(); + return BeeManager.beeRoot.getMemberStack(bee, beeType.ordinal()); + } +} diff --git a/src/main/java/binnie/extrabees/genetics/ExtraBeeMutation.java b/src/main/java/binnie/extrabees/genetics/ExtraBeeMutation.java index 35db9ef7..53ec4a03 100644 --- a/src/main/java/binnie/extrabees/genetics/ExtraBeeMutation.java +++ b/src/main/java/binnie/extrabees/genetics/ExtraBeeMutation.java @@ -1,330 +1,50 @@ package binnie.extrabees.genetics; -import binnie.Binnie; -import binnie.core.genetics.ForestryAllele; +import binnie.extrabees.genetics.requirements.DummyMutationCondition; +import binnie.extrabees.genetics.requirements.IMutationRequirement; +import binnie.extrabees.genetics.requirements.RequirementPerson; import forestry.api.apiculture.BeeManager; import forestry.api.apiculture.IAlleleBeeSpecies; import forestry.api.apiculture.IBeeGenome; import forestry.api.apiculture.IBeeHousing; -import forestry.api.apiculture.IBeeMutation; +import forestry.api.apiculture.IBeeMutationCustom; import forestry.api.apiculture.IBeeRoot; import forestry.api.genetics.IAllele; -import forestry.api.genetics.IAlleleSpecies; -import forestry.api.genetics.IGenome; -import net.minecraft.world.World; -import net.minecraftforge.common.BiomeDictionary; +import forestry.api.genetics.IMutation; +import forestry.apiculture.genetics.BeeMutation; import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; import java.util.List; -public class ExtraBeeMutation implements IBeeMutation { - public static List mutations = new ArrayList<>(); +public class ExtraBeeMutation extends BeeMutation implements IBeeMutationCustom { + public static List mutations = new ArrayList<>(); - protected IAllele[] template; - protected int chance; - - private MutationRequirement req; - private IAlleleBeeSpecies species0; - private IAlleleBeeSpecies species1; - - public ExtraBeeMutation(IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, ExtraBeesSpecies mutation, int chance) { - this(allele0, allele1, mutation.getTemplate(), chance, null); - } - - public ExtraBeeMutation(IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, ExtraBeesSpecies mutation, int chance, MutationRequirement req) { - this(allele0, allele1, mutation.getTemplate(), chance, req); - } - - public ExtraBeeMutation(IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, IAllele[] mutation, int chance) { - this(allele0, allele1, mutation, chance, null); - } - - public ExtraBeeMutation(IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, IAllele[] mutation, int chance, MutationRequirement req) { - this.chance = chance; - this.req = req; - species0 = allele0; - species1 = allele1; - template = mutation; - - if (species0 != null && species1 != null && template != null) { - ExtraBeeMutation.mutations.add(this); - } - } - - public static void doInit() { - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Meadows.getAllele(), ForestryAllele.BeeSpecies.Frugal.getAllele(), ExtraBeesSpecies.ARID, 10); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Forest.getAllele(), ForestryAllele.BeeSpecies.Frugal.getAllele(), ExtraBeesSpecies.ARID, 10); - new ExtraBeeMutation(ExtraBeesSpecies.ARID, ForestryAllele.BeeSpecies.Common.getAllele(), ExtraBeesSpecies.BARREN, 8); - new ExtraBeeMutation(ExtraBeesSpecies.ARID, ExtraBeesSpecies.BARREN, ExtraBeesSpecies.DESOLATE, 8); - new ExtraBeeMutation(ExtraBeesSpecies.BARREN, ForestryAllele.BeeSpecies.Forest.getAllele(), ExtraBeesSpecies.GNAWING, 15); - new ExtraBeeMutation(ExtraBeesSpecies.DESOLATE, ForestryAllele.BeeSpecies.Meadows.getAllele(), ExtraBeesSpecies.ROTTEN, 15); - new ExtraBeeMutation(ExtraBeesSpecies.DESOLATE, ForestryAllele.BeeSpecies.Forest.getAllele(), ExtraBeesSpecies.BONE, 15); - new ExtraBeeMutation(ExtraBeesSpecies.DESOLATE, ForestryAllele.BeeSpecies.Modest.getAllele(), ExtraBeesSpecies.CREEPER, 15); - new ExtraBeeMutation(ExtraBeesSpecies.BARREN, ForestryAllele.BeeSpecies.Marshy.getAllele(), ExtraBeesSpecies.DECOMPOSING, 15); - new ExtraBeeMutation(ExtraBeesSpecies.ROCK, ForestryAllele.BeeSpecies.Diligent.getAllele(), ExtraBeesSpecies.STONE, 12); - new ExtraBeeMutation(ExtraBeesSpecies.STONE, ForestryAllele.BeeSpecies.Unweary.getAllele(), ExtraBeesSpecies.GRANITE, 10); - new ExtraBeeMutation(ExtraBeesSpecies.GRANITE, ForestryAllele.BeeSpecies.Industrious.getAllele(), ExtraBeesSpecies.MINERAL, 6); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Meadows.getAllele(), ExtraBeesSpecies.IRON, 5); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Forest.getAllele(), ExtraBeesSpecies.IRON, 5); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Wintry.getAllele(), ExtraBeesSpecies.COPPER, 5); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Modest.getAllele(), ExtraBeesSpecies.COPPER, 5); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Marshy.getAllele(), ExtraBeesSpecies.TIN, 5); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Tropical.getAllele(), ExtraBeesSpecies.TIN, 5); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Meadows.getAllele(), ExtraBeesSpecies.LEAD, 5); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Modest.getAllele(), ExtraBeesSpecies.LEAD, 5); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Wintry.getAllele(), ExtraBeesSpecies.ZINC, 5); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Tropical.getAllele(), ExtraBeesSpecies.ZINC, 5); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Forest.getAllele(), ExtraBeesSpecies.NICKEL, 5); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Marshy.getAllele(), ExtraBeesSpecies.NICKEL, 5); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Cultivated.getAllele(), ExtraBeesSpecies.TITANIUM, 3); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Common.getAllele(), ExtraBeesSpecies.TUNGSTATE, 3); - new ExtraBeeMutation(ExtraBeesSpecies.ZINC, ForestryAllele.BeeSpecies.Majestic.getAllele(), ExtraBeesSpecies.SILVER, 2); - new ExtraBeeMutation(ExtraBeesSpecies.TIN, ForestryAllele.BeeSpecies.Majestic.getAllele(), ExtraBeesSpecies.SILVER, 2); - new ExtraBeeMutation(ExtraBeesSpecies.LEAD, ForestryAllele.BeeSpecies.Majestic.getAllele(), ExtraBeesSpecies.SILVER, 2); - new ExtraBeeMutation(ExtraBeesSpecies.TITANIUM, ForestryAllele.BeeSpecies.Majestic.getAllele(), ExtraBeesSpecies.SILVER, 3); - new ExtraBeeMutation(ExtraBeesSpecies.IRON, ForestryAllele.BeeSpecies.Majestic.getAllele(), ExtraBeesSpecies.GOLD, 2); - new ExtraBeeMutation(ExtraBeesSpecies.COPPER, ForestryAllele.BeeSpecies.Majestic.getAllele(), ExtraBeesSpecies.GOLD, 2); - new ExtraBeeMutation(ExtraBeesSpecies.NICKEL, ForestryAllele.BeeSpecies.Majestic.getAllele(), ExtraBeesSpecies.GOLD, 2); - new ExtraBeeMutation(ExtraBeesSpecies.TUNGSTATE, ForestryAllele.BeeSpecies.Majestic.getAllele(), ExtraBeesSpecies.GOLD, 3); - new ExtraBeeMutation(ExtraBeesSpecies.GOLD, ExtraBeesSpecies.SILVER, ExtraBeesSpecies.PLATINUM, 2); - new ExtraBeeMutation(ExtraBeesSpecies.MINERAL, ForestryAllele.BeeSpecies.Imperial.getAllele(), ExtraBeesSpecies.LAPIS, 5); - new ExtraBeeMutation(ExtraBeesSpecies.LAPIS, ForestryAllele.BeeSpecies.Forest.getAllele(), ExtraBeesSpecies.EMERALD, 5); - new ExtraBeeMutation(ExtraBeesSpecies.LAPIS, ForestryAllele.BeeSpecies.Modest.getAllele(), ExtraBeesSpecies.RUBY, 5); - new ExtraBeeMutation(ExtraBeesSpecies.LAPIS, ExtraBeesSpecies.WATER, ExtraBeesSpecies.SAPPHIRE, 5); - new ExtraBeeMutation(ExtraBeesSpecies.LAPIS, ForestryAllele.BeeSpecies.Cultivated.getAllele(), ExtraBeesSpecies.DIAMOND, 5); - new ExtraBeeMutation(ExtraBeesSpecies.PREHISTORIC, ExtraBeesSpecies.MINERAL, ExtraBeesSpecies.UNSTABLE, 5); - new ExtraBeeMutation(ExtraBeesSpecies.UNSTABLE, ExtraBeesSpecies.IRON, ExtraBeesSpecies.NUCLEAR, 5); - new ExtraBeeMutation(ExtraBeesSpecies.UNSTABLE, ExtraBeesSpecies.COPPER, ExtraBeesSpecies.NUCLEAR, 5); - new ExtraBeeMutation(ExtraBeesSpecies.UNSTABLE, ExtraBeesSpecies.TIN, ExtraBeesSpecies.NUCLEAR, 5); - new ExtraBeeMutation(ExtraBeesSpecies.UNSTABLE, ExtraBeesSpecies.ZINC, ExtraBeesSpecies.NUCLEAR, 5); - new ExtraBeeMutation(ExtraBeesSpecies.UNSTABLE, ExtraBeesSpecies.NICKEL, ExtraBeesSpecies.NUCLEAR, 5); - new ExtraBeeMutation(ExtraBeesSpecies.UNSTABLE, ExtraBeesSpecies.LEAD, ExtraBeesSpecies.NUCLEAR, 5); - new ExtraBeeMutation(ExtraBeesSpecies.NUCLEAR, ExtraBeesSpecies.GOLD, ExtraBeesSpecies.RADIOACTIVE, 5); - new ExtraBeeMutation(ExtraBeesSpecies.NUCLEAR, ExtraBeesSpecies.SILVER, ExtraBeesSpecies.RADIOACTIVE, 5); - new ExtraBeeMutation(ExtraBeesSpecies.NUCLEAR, ForestryAllele.BeeSpecies.Frugal.getAllele(), ExtraBeesSpecies.YELLORIUM, 5); - new ExtraBeeMutation(ExtraBeesSpecies.NUCLEAR, ExtraBeesSpecies.YELLORIUM, ExtraBeesSpecies.CYANITE, 5); - new ExtraBeeMutation(ExtraBeesSpecies.YELLORIUM, ExtraBeesSpecies.CYANITE, ExtraBeesSpecies.BLUTONIUM, 5); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Noble.getAllele(), ForestryAllele.BeeSpecies.Diligent.getAllele(), ExtraBeesSpecies.ANCIENT, 10); - new ExtraBeeMutation(ExtraBeesSpecies.ANCIENT, ForestryAllele.BeeSpecies.Secluded.getAllele(), ExtraBeesSpecies.PRIMEVAL, 8); - new ExtraBeeMutation(ExtraBeesSpecies.PRIMEVAL, ExtraBeesSpecies.ANCIENT, ExtraBeesSpecies.PREHISTORIC, 8); - new ExtraBeeMutation(ExtraBeesSpecies.PREHISTORIC, ForestryAllele.BeeSpecies.Imperial.getAllele(), ExtraBeesSpecies.RELIC, 8); - new ExtraBeeMutation(ExtraBeesSpecies.PRIMEVAL, ExtraBeesSpecies.GROWING, ExtraBeesSpecies.COAL, 8); - new ExtraBeeMutation(ExtraBeesSpecies.PRIMEVAL, ForestryAllele.BeeSpecies.Rural.getAllele(), ExtraBeesSpecies.COAL, 8); - new ExtraBeeMutation(ExtraBeesSpecies.PRIMEVAL, ForestryAllele.BeeSpecies.Miry.getAllele(), ExtraBeesSpecies.RESIN, 8); - new ExtraBeeMutation(ExtraBeesSpecies.PRIMEVAL, ExtraBeesSpecies.OCEAN, ExtraBeesSpecies.OIL, 8); - new ExtraBeeMutation(ExtraBeesSpecies.PRIMEVAL, ForestryAllele.BeeSpecies.Frugal.getAllele(), ExtraBeesSpecies.OIL, 8); - new ExtraBeeMutation(ExtraBeesSpecies.OIL, ForestryAllele.BeeSpecies.Industrious.getAllele(), ExtraBeesSpecies.DISTILLED, 8); - new ExtraBeeMutation(ExtraBeesSpecies.DISTILLED, ExtraBeesSpecies.OIL, ExtraBeesSpecies.FUEL, 8); - new ExtraBeeMutation(ExtraBeesSpecies.DISTILLED, ExtraBeesSpecies.COAL, ExtraBeesSpecies.CREOSOTE, 8); - new ExtraBeeMutation(ExtraBeesSpecies.DISTILLED, ExtraBeesSpecies.RESIN, ExtraBeesSpecies.LATEX, 8); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ForestryAllele.BeeSpecies.Diligent.getAllele(), ExtraBeesSpecies.RIVER, 10, new RequirementBiomeType(BiomeDictionary.Type.RIVER)); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ForestryAllele.BeeSpecies.Diligent.getAllele(), ExtraBeesSpecies.OCEAN, 10, new RequirementBiomeType(BiomeDictionary.Type.OCEAN)); - new ExtraBeeMutation(ExtraBeesSpecies.BLACK, ExtraBeesSpecies.OCEAN, ExtraBeesSpecies.INK, 8); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Forest.getAllele(), ForestryAllele.BeeSpecies.Diligent.getAllele(), ExtraBeesSpecies.GROWING, 10); - new ExtraBeeMutation(ExtraBeesSpecies.GROWING, ForestryAllele.BeeSpecies.Unweary.getAllele(), ExtraBeesSpecies.THRIVING, 10); - new ExtraBeeMutation(ExtraBeesSpecies.THRIVING, ForestryAllele.BeeSpecies.Industrious.getAllele(), ExtraBeesSpecies.BLOOMING, 8); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Valiant.getAllele(), ForestryAllele.BeeSpecies.Diligent.getAllele(), ExtraBeesSpecies.SWEET, 15); - new ExtraBeeMutation(ExtraBeesSpecies.SWEET, ForestryAllele.BeeSpecies.Rural.getAllele(), ExtraBeesSpecies.SUGAR, 15); - new ExtraBeeMutation(ExtraBeesSpecies.SWEET, ExtraBeesSpecies.GROWING, ExtraBeesSpecies.RIPENING, 5); - new ExtraBeeMutation(ExtraBeesSpecies.SWEET, ExtraBeesSpecies.THRIVING, ExtraBeesSpecies.FRUIT, 5); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Farmerly.getAllele(), ForestryAllele.BeeSpecies.Meadows.getAllele(), ExtraBeesSpecies.ALCOHOL, 10); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Farmerly.getAllele(), ForestryAllele.BeeSpecies.Meadows.getAllele(), ExtraBeesSpecies.FARM, 10); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Farmerly.getAllele(), ExtraBeesSpecies.WATER, ExtraBeesSpecies.MILK, 10); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Farmerly.getAllele(), ForestryAllele.BeeSpecies.Tropical.getAllele(), ExtraBeesSpecies.COFFEE, 10); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ForestryAllele.BeeSpecies.Miry.getAllele(), ExtraBeesSpecies.SWAMP, 10); - new ExtraBeeMutation(ExtraBeesSpecies.SWAMP, ForestryAllele.BeeSpecies.Boggy.getAllele(), ExtraBeesSpecies.BOGGY, 8); - new ExtraBeeMutation(ExtraBeesSpecies.BOGGY, ExtraBeesSpecies.SWAMP, ExtraBeesSpecies.FUNGAL, 8); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Boggy.getAllele(), ForestryAllele.BeeSpecies.Miry.getAllele(), ExtraBeesSpecies.FUNGAL, 8); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ForestryAllele.BeeSpecies.Forest.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ForestryAllele.BeeSpecies.Meadows.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ForestryAllele.BeeSpecies.Modest.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ForestryAllele.BeeSpecies.Tropical.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ForestryAllele.BeeSpecies.Marshy.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ForestryAllele.BeeSpecies.Wintry.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ExtraBeesSpecies.ROCK, ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ExtraBeesSpecies.BASALT, ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.ROCK, ForestryAllele.BeeSpecies.Forest.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.ROCK, ForestryAllele.BeeSpecies.Meadows.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.ROCK, ForestryAllele.BeeSpecies.Modest.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.ROCK, ForestryAllele.BeeSpecies.Tropical.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.ROCK, ForestryAllele.BeeSpecies.Marshy.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.ROCK, ForestryAllele.BeeSpecies.Wintry.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.ROCK, ExtraBeesSpecies.BASALT, ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.BASALT, ForestryAllele.BeeSpecies.Forest.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.BASALT, ForestryAllele.BeeSpecies.Meadows.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.BASALT, ForestryAllele.BeeSpecies.Modest.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.BASALT, ForestryAllele.BeeSpecies.Tropical.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.BASALT, ForestryAllele.BeeSpecies.Marshy.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.BASALT, ForestryAllele.BeeSpecies.Wintry.getAllele(), ForestryAllele.BeeSpecies.Common.getTemplate(), 15); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ForestryAllele.BeeSpecies.Common.getAllele(), ForestryAllele.BeeSpecies.Cultivated.getTemplate(), 12); - new ExtraBeeMutation(ExtraBeesSpecies.ROCK, ForestryAllele.BeeSpecies.Common.getAllele(), ForestryAllele.BeeSpecies.Cultivated.getTemplate(), 12); - new ExtraBeeMutation(ExtraBeesSpecies.BASALT, ForestryAllele.BeeSpecies.Common.getAllele(), ForestryAllele.BeeSpecies.Cultivated.getTemplate(), 12); - new ExtraBeeMutation(ExtraBeesSpecies.BASALT, ForestryAllele.BeeSpecies.Fiendish.getAllele(), ExtraBeesSpecies.TEMPERED, 30, new RequirementBiomeType(BiomeDictionary.Type.NETHER)); - new ExtraBeeMutation(ExtraBeesSpecies.TEMPERED, ForestryAllele.BeeSpecies.Demonic.getAllele(), ExtraBeesSpecies.VOLCANIC, 20, new RequirementBiomeType(BiomeDictionary.Type.NETHER)); - new ExtraBeeMutation(ExtraBeesSpecies.BASALT, ForestryAllele.BeeSpecies.Cultivated.getAllele(), ForestryAllele.BeeSpecies.Sinister.getTemplate(), 60, new RequirementBiomeType(BiomeDictionary.Type.NETHER)); - new ExtraBeeMutation(ExtraBeesSpecies.BASALT, ForestryAllele.BeeSpecies.Sinister.getAllele(), ForestryAllele.BeeSpecies.Fiendish.getTemplate(), 40, new RequirementBiomeType(BiomeDictionary.Type.NETHER)); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Sinister.getAllele(), ForestryAllele.BeeSpecies.Tropical.getAllele(), ExtraBeesSpecies.MALICIOUS, 10); - new ExtraBeeMutation(ExtraBeesSpecies.MALICIOUS, ForestryAllele.BeeSpecies.Tropical.getAllele(), ExtraBeesSpecies.INFECTIOUS, 8); - new ExtraBeeMutation(ExtraBeesSpecies.MALICIOUS, ExtraBeesSpecies.INFECTIOUS, ExtraBeesSpecies.VIRULENT, 8); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ForestryAllele.BeeSpecies.Exotic.getAllele(), ExtraBeesSpecies.VISCOUS, 10); - new ExtraBeeMutation(ExtraBeesSpecies.VISCOUS, ForestryAllele.BeeSpecies.Exotic.getAllele(), ExtraBeesSpecies.GLUTINOUS, 8); - new ExtraBeeMutation(ExtraBeesSpecies.VISCOUS, ExtraBeesSpecies.GLUTINOUS, ExtraBeesSpecies.STICKY, 8); - new ExtraBeeMutation(ExtraBeesSpecies.MALICIOUS, ExtraBeesSpecies.VISCOUS, ExtraBeesSpecies.CORROSIVE, 10); - new ExtraBeeMutation(ExtraBeesSpecies.CORROSIVE, ForestryAllele.BeeSpecies.Fiendish.getAllele(), ExtraBeesSpecies.CAUSTIC, 8); - new ExtraBeeMutation(ExtraBeesSpecies.CORROSIVE, ExtraBeesSpecies.CAUSTIC, ExtraBeesSpecies.ACIDIC, 4); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Cultivated.getAllele(), ForestryAllele.BeeSpecies.Valiant.getAllele(), ExtraBeesSpecies.EXCITED, 10); - new ExtraBeeMutation(ExtraBeesSpecies.EXCITED, ForestryAllele.BeeSpecies.Diligent.getAllele(), ExtraBeesSpecies.ENERGETIC, 8); - new ExtraBeeMutation(ExtraBeesSpecies.EXCITED, ExtraBeesSpecies.ENERGETIC, ExtraBeesSpecies.ECSTATIC, 8); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Wintry.getAllele(), ForestryAllele.BeeSpecies.Diligent.getAllele(), ExtraBeesSpecies.ARTIC, 10); - new ExtraBeeMutation(ExtraBeesSpecies.OCEAN, ExtraBeesSpecies.ARTIC, ExtraBeesSpecies.FREEZING, 10); - new ExtraBeeMutation(ExtraBeesSpecies.ROCK, ForestryAllele.BeeSpecies.Sinister.getAllele(), ExtraBeesSpecies.SHADOW, 10); - new ExtraBeeMutation(ExtraBeesSpecies.SHADOW, ExtraBeesSpecies.ROCK, ExtraBeesSpecies.DARKENED, 8); - new ExtraBeeMutation(ExtraBeesSpecies.SHADOW, ExtraBeesSpecies.DARKENED, ExtraBeesSpecies.ABYSS, 8); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Forest.getAllele(), ForestryAllele.BeeSpecies.Valiant.getAllele(), ExtraBeesSpecies.RED, 5); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Meadows.getAllele(), ForestryAllele.BeeSpecies.Valiant.getAllele(), ExtraBeesSpecies.YELLOW, 5); - new ExtraBeeMutation(ExtraBeesSpecies.WATER, ForestryAllele.BeeSpecies.Valiant.getAllele(), ExtraBeesSpecies.BLUE, 5); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Tropical.getAllele(), ForestryAllele.BeeSpecies.Valiant.getAllele(), ExtraBeesSpecies.GREEN, 5); - new ExtraBeeMutation(ExtraBeesSpecies.ROCK, ForestryAllele.BeeSpecies.Valiant.getAllele(), ExtraBeesSpecies.BLACK, 5); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Wintry.getAllele(), ForestryAllele.BeeSpecies.Valiant.getAllele(), ExtraBeesSpecies.WHITE, 5); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Marshy.getAllele(), ForestryAllele.BeeSpecies.Valiant.getAllele(), ExtraBeesSpecies.BROWN, 5); - new ExtraBeeMutation(ExtraBeesSpecies.RED, ExtraBeesSpecies.YELLOW, ExtraBeesSpecies.ORANGE, 5); - new ExtraBeeMutation(ExtraBeesSpecies.GREEN, ExtraBeesSpecies.BLUE, ExtraBeesSpecies.CYAN, 5); - new ExtraBeeMutation(ExtraBeesSpecies.RED, ExtraBeesSpecies.BLUE, ExtraBeesSpecies.PURPLE, 5); - new ExtraBeeMutation(ExtraBeesSpecies.BLACK, ExtraBeesSpecies.WHITE, ExtraBeesSpecies.GRAY, 5); - new ExtraBeeMutation(ExtraBeesSpecies.BLUE, ExtraBeesSpecies.WHITE, ExtraBeesSpecies.LIGHTBLUE, 5); - new ExtraBeeMutation(ExtraBeesSpecies.RED, ExtraBeesSpecies.WHITE, ExtraBeesSpecies.PINK, 5); - new ExtraBeeMutation(ExtraBeesSpecies.GREEN, ExtraBeesSpecies.WHITE, ExtraBeesSpecies.LIMEGREEN, 5); - new ExtraBeeMutation(ExtraBeesSpecies.PURPLE, ExtraBeesSpecies.PINK, ExtraBeesSpecies.MAGENTA, 5); - new ExtraBeeMutation(ExtraBeesSpecies.GRAY, ExtraBeesSpecies.WHITE, ExtraBeesSpecies.LIGHTGRAY, 5); - new ExtraBeeMutation(ExtraBeesSpecies.TEMPERED, ExtraBeesSpecies.EXCITED, ExtraBeesSpecies.GLOWSTONE, 5); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Austere.getAllele(), ExtraBeesSpecies.DESOLATE, ExtraBeesSpecies.HAZARDOUS, 5); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Ended.getAllele(), ExtraBeesSpecies.RELIC, ExtraBeesSpecies.JADED, 2, new RequirementPerson("jadedcat")); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Austere.getAllele(), ExtraBeesSpecies.EXCITED, ExtraBeesSpecies.CELEBRATORY, 5); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Secluded.getAllele(), ForestryAllele.BeeSpecies.Ended.getAllele(), ExtraBeesSpecies.UNUSUAL, 5); - new ExtraBeeMutation(ExtraBeesSpecies.UNUSUAL, ForestryAllele.BeeSpecies.Hermitic.getAllele(), ExtraBeesSpecies.SPATIAL, 5); - new ExtraBeeMutation(ExtraBeesSpecies.SPATIAL, ForestryAllele.BeeSpecies.Spectral.getAllele(), ExtraBeesSpecies.QUANTUM, 5); - new ExtraBeeMutation(ForestryAllele.BeeSpecies.Noble.getAllele(), ForestryAllele.BeeSpecies.Monastic.getAllele(), ExtraBeesSpecies.MYSTICAL, 5); - - for (IBeeMutation mutation : ExtraBeeMutation.mutations) { - Binnie.Genetics.getBeeRoot().registerMutation(mutation); - } - } - - @Override - public IAlleleSpecies getAllele0() { - return species0; - } - - @Override - public IAlleleSpecies getAllele1() { - return species1; - } - - @Override - public IAllele[] getTemplate() { - return template; - } - - @Override - public float getBaseChance() { - return chance; - } - - @Override - public boolean isPartner(IAllele allele) { - String uid = allele.getUID(); - return uid.equals(species0.getUID()) - || uid.equals(species1.getUID()); - } - - @Override - public IAllele getPartner(IAllele allele) { - return allele.getUID().equals(species0.getUID()) ? species1 : species0; - } - - @Override - public boolean isSecret() { - return false; - } - - @Override - public float getChance(IBeeHousing housing, IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, IBeeGenome genome0, IBeeGenome genome1) { - if (species0 == null || species1 == null || allele0 == null || allele1 == null) { - return 0.0f; - } - - World world = housing.getWorld(); - if (req != null && !req.fufilled(housing, allele0, allele1, genome0, genome1)) { - return 0.0f; - } - - int processedChance = Math.round(chance * BeeManager.beeRoot.createBeeHousingModifier(housing).getMutationModifier(genome0, genome1, 1.0f) - * Binnie.Genetics.getBeeRoot().getBeekeepingMode(world).getBeeModifier().getMutationModifier(genome0, genome1, 1.0f)); - if (species0.getUID().equals(allele0.getUID()) && species1.getUID().equals(allele1.getUID())) { - return processedChance; - } - if (species1.getUID().equals(allele0.getUID()) && species0.getUID().equals(allele1.getUID())) { - return processedChance; - } - return 0.0f; - } - - @Override - public Collection getSpecialConditions() { - List conditions = new ArrayList<>(); - if (req != null) { - Collections.addAll(conditions, req.tooltip()); - } - return conditions; + private List requirements; + + public ExtraBeeMutation(IAlleleBeeSpecies bee0, IAlleleBeeSpecies bee1, IAllele[] result, int chance) { + super(bee0, bee1, result, chance); + requirements = new ArrayList<>(); + mutations.add(this); } @Override public IBeeRoot getRoot() { - return Binnie.Genetics.getBeeRoot(); + return BeeManager.beeRoot; } - abstract static class MutationRequirement { - public abstract String[] tooltip(); - - public abstract boolean fufilled(IBeeHousing housing, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1); + @Override + public float getChance(IBeeHousing housing, IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, IBeeGenome genome0, IBeeGenome genome1) { + for (IMutationRequirement requirement : requirements) { + if (!requirement.fufilled(housing, allele0, allele1, genome0, genome1)) { + return 0.0f; + } + } + return super.getChance(housing, allele0, allele1, genome0, genome1); } - static class RequirementBiomeType extends MutationRequirement { - protected BiomeDictionary.Type type; - - public RequirementBiomeType(BiomeDictionary.Type type) { - this.type = type; - } - - @Override - public String[] tooltip() { - return new String[]{"Is restricted to " + type + "-like biomes."}; - } - - @Override - public boolean fufilled(IBeeHousing housing, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1) { - return BiomeDictionary.isBiomeOfType(housing.getBiome(), type); - } - } - - static class RequirementPerson extends MutationRequirement { - protected String name; - - public RequirementPerson(String name) { - this.name = name; - } - - @Override - public String[] tooltip() { - return new String[]{"Can only be bred by " + name}; - } - - @Override - public boolean fufilled(IBeeHousing housing, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1) { - return housing.getOwner().getName() != null - && housing.getOwner().getName().equals(name); - } + public void restrictPerson(String nickname) { + RequirementPerson requirement = new RequirementPerson(nickname); + requirements.add(requirement); + addMutationCondition(new DummyMutationCondition(requirement)); } } diff --git a/src/main/java/binnie/extrabees/genetics/ExtraBeesBranch.java b/src/main/java/binnie/extrabees/genetics/ExtraBeesBranch.java deleted file mode 100644 index d32b9e37..00000000 --- a/src/main/java/binnie/extrabees/genetics/ExtraBeesBranch.java +++ /dev/null @@ -1,338 +0,0 @@ -package binnie.extrabees.genetics; - -import binnie.extrabees.ExtraBees; -import forestry.api.apiculture.IAlleleBeeSpecies; -import forestry.api.genetics.AlleleManager; -import forestry.api.genetics.IAlleleSpecies; -import forestry.api.genetics.IClassification; - -import java.util.LinkedHashSet; -import java.util.Set; - -public enum ExtraBeesBranch implements IClassification { - BARREN("Vacapis"), - HOSTILE("Infenapis"), - ROCKY("Monapis"), - METALLIC("Lamminapis"), - METALLIC2("Metalapis"), - ALLOY("Allapis"), - PRECIOUS("Pluriapis"), - MINERAL("Niphapis"), - GEMSTONE("Gemmapis"), - NUCLEAR("Levapis"), - HISTORIC("Priscapis"), - FOSSILIZED("Fosiapis"), - REFINED("Petrapis"), - AQUATIC("Aquapis"), - SACCHARINE("Sacchapis"), - CLASSICAL("Grecapis"), - VOLCANIC("Irrapis"), - VIRULENT("Virapis"), - VISCOUS("Viscapis"), - CAUSTIC("Morbapis"), - ENERGETIC("Incitapis"), - FARMING("Agriapis"), - SHADOW("Pullapis"), - PRIMARY("Primapis"), - SECONDARY("Secapis"), - TERTIARY("Tertiapis"), - FTB("Eftebeapis"), - QUANTUM("Quantapis"), - BOTANIA("Botaniapis"); - - protected IClassification parent; - - private String uid; - private String scientific; - private Set speciesSet; - - ExtraBeesBranch(String scientific) { - this.scientific = scientific; - speciesSet = new LinkedHashSet<>(); - uid = toString().toLowerCase(); - } - - public static void doInit() { - IClassification frozenBranch = AlleleManager.alleleRegistry.getClassification("genus.bees.frozen"); - if (frozenBranch != null) { - frozenBranch.addMemberSpecies(ExtraBeesSpecies.ARTIC); - ExtraBeesSpecies.ARTIC.setBranch(frozenBranch); - frozenBranch.addMemberSpecies(ExtraBeesSpecies.FREEZING); - ExtraBeesSpecies.FREEZING.setBranch(frozenBranch); - } - - IClassification agrarianBranch = AlleleManager.alleleRegistry.getClassification("genus.bees.agrarian"); - if (agrarianBranch != null) { - agrarianBranch.addMemberSpecies(ExtraBeesSpecies.FARM); - ExtraBeesSpecies.FARM.setBranch(agrarianBranch); - ExtraBeesSpecies.GROWING.setBranch(agrarianBranch); - ExtraBeesSpecies.THRIVING.setBranch(agrarianBranch); - ExtraBeesSpecies.BLOOMING.setBranch(agrarianBranch); - } - - IClassification boggyBranch = AlleleManager.alleleRegistry.getClassification("genus.bees.boggy"); - if (boggyBranch != null) { - boggyBranch.addMemberSpecies(ExtraBeesSpecies.SWAMP); - boggyBranch.addMemberSpecies(ExtraBeesSpecies.BOGGY); - boggyBranch.addMemberSpecies(ExtraBeesSpecies.FUNGAL); - ExtraBeesSpecies.SWAMP.setBranch(boggyBranch); - ExtraBeesSpecies.BOGGY.setBranch(boggyBranch); - ExtraBeesSpecies.FUNGAL.setBranch(boggyBranch); - } - - IClassification festiveBranch = AlleleManager.alleleRegistry.getClassification("genus.bees.festive"); - if (festiveBranch != null) { - festiveBranch.addMemberSpecies(ExtraBeesSpecies.CELEBRATORY); - ExtraBeesSpecies.CELEBRATORY.setBranch(festiveBranch); - } - - IClassification austereBranch = AlleleManager.alleleRegistry.getClassification("genus.bees.austere"); - if (austereBranch != null) { - austereBranch.addMemberSpecies(ExtraBeesSpecies.HAZARDOUS); - ExtraBeesSpecies.HAZARDOUS.setBranch(austereBranch); - } - - ExtraBeesBranch.FARMING.addMemberSpecies(ExtraBeesSpecies.ALCOHOL); - ExtraBeesBranch.FARMING.addMemberSpecies(ExtraBeesSpecies.MILK); - ExtraBeesBranch.FARMING.addMemberSpecies(ExtraBeesSpecies.COFFEE); - ExtraBeesBranch.FARMING.addMemberSpecies(ExtraBeesSpecies.CITRUS); - ExtraBeesBranch.FARMING.addMemberSpecies(ExtraBeesSpecies.MINT); - ExtraBeesBranch.FARMING.register(); - - ExtraBeesBranch.BARREN.addMemberSpecies(ExtraBeesSpecies.ARID); - ExtraBeesBranch.BARREN.addMemberSpecies(ExtraBeesSpecies.BARREN); - ExtraBeesBranch.BARREN.addMemberSpecies(ExtraBeesSpecies.DESOLATE); - ExtraBeesBranch.BARREN.addMemberSpecies(ExtraBeesSpecies.DECOMPOSING); - ExtraBeesBranch.BARREN.addMemberSpecies(ExtraBeesSpecies.GNAWING); - ExtraBeesBranch.BARREN.register(); - - ExtraBeesBranch.HOSTILE.addMemberSpecies(ExtraBeesSpecies.ROTTEN); - ExtraBeesBranch.HOSTILE.addMemberSpecies(ExtraBeesSpecies.BONE); - ExtraBeesBranch.HOSTILE.addMemberSpecies(ExtraBeesSpecies.CREEPER); - ExtraBeesBranch.HOSTILE.register(); - - ExtraBeesBranch.ROCKY.addMemberSpecies(ExtraBeesSpecies.ROCK); - ExtraBeesBranch.ROCKY.addMemberSpecies(ExtraBeesSpecies.STONE); - ExtraBeesBranch.ROCKY.addMemberSpecies(ExtraBeesSpecies.GRANITE); - ExtraBeesBranch.ROCKY.addMemberSpecies(ExtraBeesSpecies.MINERAL); - ExtraBeesBranch.ROCKY.register(); - - ExtraBeesBranch.METALLIC.addMemberSpecies(ExtraBeesSpecies.IRON); - ExtraBeesBranch.METALLIC.addMemberSpecies(ExtraBeesSpecies.COPPER); - ExtraBeesBranch.METALLIC.addMemberSpecies(ExtraBeesSpecies.TIN); - ExtraBeesBranch.METALLIC.addMemberSpecies(ExtraBeesSpecies.LEAD); - ExtraBeesBranch.METALLIC.register(); - - ExtraBeesBranch.METALLIC2.addMemberSpecies(ExtraBeesSpecies.NICKEL); - ExtraBeesBranch.METALLIC2.addMemberSpecies(ExtraBeesSpecies.ZINC); - ExtraBeesBranch.METALLIC2.addMemberSpecies(ExtraBeesSpecies.TUNGSTATE); - ExtraBeesBranch.METALLIC2.addMemberSpecies(ExtraBeesSpecies.TITANIUM); - ExtraBeesBranch.METALLIC2.register(); - - ExtraBeesBranch.ALLOY.addMemberSpecies(ExtraBeesSpecies.BRONZE); - ExtraBeesBranch.ALLOY.addMemberSpecies(ExtraBeesSpecies.BRASS); - ExtraBeesBranch.ALLOY.addMemberSpecies(ExtraBeesSpecies.STEEL); - ExtraBeesBranch.ALLOY.addMemberSpecies(ExtraBeesSpecies.INVAR); - ExtraBeesBranch.ALLOY.register(); - - ExtraBeesBranch.PRECIOUS.addMemberSpecies(ExtraBeesSpecies.SILVER); - ExtraBeesBranch.PRECIOUS.addMemberSpecies(ExtraBeesSpecies.GOLD); - ExtraBeesBranch.PRECIOUS.addMemberSpecies(ExtraBeesSpecies.ELECTRUM); - ExtraBeesBranch.PRECIOUS.addMemberSpecies(ExtraBeesSpecies.PLATINUM); - ExtraBeesBranch.PRECIOUS.register(); - - ExtraBeesBranch.MINERAL.addMemberSpecies(ExtraBeesSpecies.LAPIS); - ExtraBeesBranch.MINERAL.addMemberSpecies(ExtraBeesSpecies.SODALITE); - ExtraBeesBranch.MINERAL.addMemberSpecies(ExtraBeesSpecies.PYRITE); - ExtraBeesBranch.MINERAL.addMemberSpecies(ExtraBeesSpecies.BAUXITE); - ExtraBeesBranch.MINERAL.addMemberSpecies(ExtraBeesSpecies.CINNABAR); - ExtraBeesBranch.MINERAL.addMemberSpecies(ExtraBeesSpecies.SPHALERITE); - ExtraBeesBranch.MINERAL.register(); - - ExtraBeesBranch.GEMSTONE.addMemberSpecies(ExtraBeesSpecies.EMERALD); - ExtraBeesBranch.GEMSTONE.addMemberSpecies(ExtraBeesSpecies.RUBY); - ExtraBeesBranch.GEMSTONE.addMemberSpecies(ExtraBeesSpecies.SAPPHIRE); - ExtraBeesBranch.GEMSTONE.addMemberSpecies(ExtraBeesSpecies.OLIVINE); - ExtraBeesBranch.GEMSTONE.addMemberSpecies(ExtraBeesSpecies.DIAMOND); - ExtraBeesBranch.GEMSTONE.register(); - - ExtraBeesBranch.NUCLEAR.addMemberSpecies(ExtraBeesSpecies.UNSTABLE); - ExtraBeesBranch.NUCLEAR.addMemberSpecies(ExtraBeesSpecies.NUCLEAR); - ExtraBeesBranch.NUCLEAR.addMemberSpecies(ExtraBeesSpecies.RADIOACTIVE); - ExtraBeesBranch.NUCLEAR.addMemberSpecies(ExtraBeesSpecies.YELLORIUM); - ExtraBeesBranch.NUCLEAR.addMemberSpecies(ExtraBeesSpecies.CYANITE); - ExtraBeesBranch.NUCLEAR.addMemberSpecies(ExtraBeesSpecies.BLUTONIUM); - ExtraBeesBranch.NUCLEAR.register(); - - ExtraBeesBranch.HISTORIC.addMemberSpecies(ExtraBeesSpecies.ANCIENT); - ExtraBeesBranch.HISTORIC.addMemberSpecies(ExtraBeesSpecies.PRIMEVAL); - ExtraBeesBranch.HISTORIC.addMemberSpecies(ExtraBeesSpecies.PREHISTORIC); - ExtraBeesBranch.HISTORIC.addMemberSpecies(ExtraBeesSpecies.RELIC); - ExtraBeesBranch.HISTORIC.register(); - - ExtraBeesBranch.FOSSILIZED.addMemberSpecies(ExtraBeesSpecies.COAL); - ExtraBeesBranch.FOSSILIZED.addMemberSpecies(ExtraBeesSpecies.RESIN); - ExtraBeesBranch.FOSSILIZED.addMemberSpecies(ExtraBeesSpecies.OIL); - ExtraBeesBranch.FOSSILIZED.addMemberSpecies(ExtraBeesSpecies.PEAT); - ExtraBeesBranch.FOSSILIZED.register(); - - ExtraBeesBranch.REFINED.addMemberSpecies(ExtraBeesSpecies.DISTILLED); - ExtraBeesBranch.REFINED.addMemberSpecies(ExtraBeesSpecies.FUEL); - ExtraBeesBranch.REFINED.addMemberSpecies(ExtraBeesSpecies.CREOSOTE); - ExtraBeesBranch.REFINED.addMemberSpecies(ExtraBeesSpecies.LATEX); - ExtraBeesBranch.REFINED.register(); - - ExtraBeesBranch.AQUATIC.addMemberSpecies(ExtraBeesSpecies.WATER); - ExtraBeesBranch.AQUATIC.addMemberSpecies(ExtraBeesSpecies.RIVER); - ExtraBeesBranch.AQUATIC.addMemberSpecies(ExtraBeesSpecies.OCEAN); - ExtraBeesBranch.AQUATIC.addMemberSpecies(ExtraBeesSpecies.INK); - ExtraBeesBranch.AQUATIC.register(); - - ExtraBeesBranch.SACCHARINE.addMemberSpecies(ExtraBeesSpecies.SWEET); - ExtraBeesBranch.SACCHARINE.addMemberSpecies(ExtraBeesSpecies.SUGAR); - ExtraBeesBranch.SACCHARINE.addMemberSpecies(ExtraBeesSpecies.FRUIT); - ExtraBeesBranch.SACCHARINE.addMemberSpecies(ExtraBeesSpecies.RIPENING); - ExtraBeesBranch.SACCHARINE.register(); - - ExtraBeesBranch.CLASSICAL.addMemberSpecies(ExtraBeesSpecies.MARBLE); - ExtraBeesBranch.CLASSICAL.addMemberSpecies(ExtraBeesSpecies.ROMAN); - ExtraBeesBranch.CLASSICAL.addMemberSpecies(ExtraBeesSpecies.GREEK); - ExtraBeesBranch.CLASSICAL.addMemberSpecies(ExtraBeesSpecies.CLASSICAL); - ExtraBeesBranch.CLASSICAL.register(); - - ExtraBeesBranch.VOLCANIC.addMemberSpecies(ExtraBeesSpecies.BASALT); - ExtraBeesBranch.VOLCANIC.addMemberSpecies(ExtraBeesSpecies.TEMPERED); - ExtraBeesBranch.VOLCANIC.addMemberSpecies(ExtraBeesSpecies.ANGRY); - ExtraBeesBranch.VOLCANIC.addMemberSpecies(ExtraBeesSpecies.VOLCANIC); - ExtraBeesBranch.VOLCANIC.addMemberSpecies(ExtraBeesSpecies.GLOWSTONE); - ExtraBeesBranch.VOLCANIC.register(); - - ExtraBeesBranch.VISCOUS.addMemberSpecies(ExtraBeesSpecies.VISCOUS); - ExtraBeesBranch.VISCOUS.addMemberSpecies(ExtraBeesSpecies.GLUTINOUS); - ExtraBeesBranch.VISCOUS.addMemberSpecies(ExtraBeesSpecies.STICKY); - ExtraBeesBranch.VISCOUS.register(); - - ExtraBeesBranch.VIRULENT.addMemberSpecies(ExtraBeesSpecies.MALICIOUS); - ExtraBeesBranch.VIRULENT.addMemberSpecies(ExtraBeesSpecies.INFECTIOUS); - ExtraBeesBranch.VIRULENT.addMemberSpecies(ExtraBeesSpecies.VIRULENT); - ExtraBeesBranch.VIRULENT.register(); - - ExtraBeesBranch.CAUSTIC.addMemberSpecies(ExtraBeesSpecies.CORROSIVE); - ExtraBeesBranch.CAUSTIC.addMemberSpecies(ExtraBeesSpecies.CAUSTIC); - ExtraBeesBranch.CAUSTIC.addMemberSpecies(ExtraBeesSpecies.ACIDIC); - ExtraBeesBranch.CAUSTIC.register(); - - ExtraBeesBranch.ENERGETIC.addMemberSpecies(ExtraBeesSpecies.EXCITED); - ExtraBeesBranch.ENERGETIC.addMemberSpecies(ExtraBeesSpecies.ENERGETIC); - ExtraBeesBranch.ENERGETIC.addMemberSpecies(ExtraBeesSpecies.ECSTATIC); - ExtraBeesBranch.ENERGETIC.register(); - - ExtraBeesBranch.SHADOW.addMemberSpecies(ExtraBeesSpecies.SHADOW); - ExtraBeesBranch.SHADOW.addMemberSpecies(ExtraBeesSpecies.DARKENED); - ExtraBeesBranch.SHADOW.addMemberSpecies(ExtraBeesSpecies.ABYSS); - ExtraBeesBranch.SHADOW.register(); - - ExtraBeesBranch.PRIMARY.addMemberSpecies(ExtraBeesSpecies.RED); - ExtraBeesBranch.PRIMARY.addMemberSpecies(ExtraBeesSpecies.YELLOW); - ExtraBeesBranch.PRIMARY.addMemberSpecies(ExtraBeesSpecies.BLUE); - ExtraBeesBranch.PRIMARY.addMemberSpecies(ExtraBeesSpecies.GREEN); - ExtraBeesBranch.PRIMARY.addMemberSpecies(ExtraBeesSpecies.BLACK); - ExtraBeesBranch.PRIMARY.addMemberSpecies(ExtraBeesSpecies.WHITE); - ExtraBeesBranch.PRIMARY.addMemberSpecies(ExtraBeesSpecies.BROWN); - ExtraBeesBranch.PRIMARY.register(); - - ExtraBeesBranch.SECONDARY.addMemberSpecies(ExtraBeesSpecies.ORANGE); - ExtraBeesBranch.SECONDARY.addMemberSpecies(ExtraBeesSpecies.CYAN); - ExtraBeesBranch.SECONDARY.addMemberSpecies(ExtraBeesSpecies.PURPLE); - ExtraBeesBranch.SECONDARY.addMemberSpecies(ExtraBeesSpecies.GRAY); - ExtraBeesBranch.SECONDARY.addMemberSpecies(ExtraBeesSpecies.LIGHTBLUE); - ExtraBeesBranch.SECONDARY.addMemberSpecies(ExtraBeesSpecies.PINK); - ExtraBeesBranch.SECONDARY.addMemberSpecies(ExtraBeesSpecies.LIMEGREEN); - ExtraBeesBranch.SECONDARY.register(); - - ExtraBeesBranch.TERTIARY.addMemberSpecies(ExtraBeesSpecies.MAGENTA); - ExtraBeesBranch.TERTIARY.addMemberSpecies(ExtraBeesSpecies.LIGHTGRAY); - ExtraBeesBranch.TERTIARY.register(); - - ExtraBeesBranch.FTB.addMemberSpecies(ExtraBeesSpecies.JADED); - ExtraBeesBranch.FTB.register(); - - ExtraBeesBranch.QUANTUM.addMemberSpecies(ExtraBeesSpecies.UNUSUAL); - ExtraBeesBranch.QUANTUM.addMemberSpecies(ExtraBeesSpecies.SPATIAL); - ExtraBeesBranch.QUANTUM.addMemberSpecies(ExtraBeesSpecies.QUANTUM); - ExtraBeesBranch.QUANTUM.register(); - - ExtraBeesBranch.BOTANIA.addMemberSpecies(ExtraBeesSpecies.MYSTICAL); - ExtraBeesBranch.BOTANIA.register(); - } - - @Override - public String getUID() { - return "extrabees.genus." + uid; - } - - @Override - public String getName() { - return ExtraBees.proxy.localise("branch." + toString().toLowerCase() + ".name"); - } - - @Override - public String getScientific() { - return scientific; - } - - @Override - public String getDescription() { - return ExtraBees.proxy.localiseOrBlank("branch." + toString().toLowerCase() + ".desc"); - } - - public void register() { - if (speciesSet.isEmpty()) { - return; - } - - AlleleManager.alleleRegistry.registerClassification(this); - IClassification parent = AlleleManager.alleleRegistry.getClassification("family.apidae"); - if (parent != null) { - parent.addMemberGroup(this); - setParent(parent); - } - } - - @Override - public IClassification.EnumClassLevel getLevel() { - return IClassification.EnumClassLevel.GENUS; - } - - @Override - public IClassification[] getMemberGroups() { - return null; - } - - @Override - public void addMemberGroup(IClassification group) { - } - - @Override - public IAlleleSpecies[] getMemberSpecies() { - return speciesSet.toArray(new IAlleleSpecies[0]); - } - - @Override - public void addMemberSpecies(IAlleleSpecies species) { - speciesSet.add((IAlleleBeeSpecies) species); - if (species instanceof ExtraBeesSpecies) { - ((ExtraBeesSpecies) species).setBranch(this); - } - } - - @Override - public IClassification getParent() { - return parent; - } - - @Override - public void setParent(IClassification parent) { - this.parent = parent; - } -} diff --git a/src/main/java/binnie/extrabees/genetics/ExtraBeesSpecies.java b/src/main/java/binnie/extrabees/genetics/ExtraBeesSpecies.java deleted file mode 100644 index 8330e5e4..00000000 --- a/src/main/java/binnie/extrabees/genetics/ExtraBeesSpecies.java +++ /dev/null @@ -1,1214 +0,0 @@ -package binnie.extrabees.genetics; - -import binnie.Binnie; -import binnie.core.BinnieCore; -import binnie.core.Mods; -import binnie.core.genetics.ForestryAllele; -import binnie.core.item.IItemEnum; -import binnie.extrabees.ExtraBees; -import binnie.extrabees.genetics.effect.ExtraBeesEffect; -import binnie.extrabees.products.EnumHoneyComb; -import binnie.extrabees.products.ItemHoneyComb; -import binnie.genetics.genetics.AlleleHelper; -import com.mojang.authlib.GameProfile; -import cpw.mods.fml.relauncher.Side; -import cpw.mods.fml.relauncher.SideOnly; -import forestry.api.apiculture.EnumBeeChromosome; -import forestry.api.apiculture.EnumBeeType; -import forestry.api.apiculture.IAlleleBeeEffect; -import forestry.api.apiculture.IAlleleBeeSpecies; -import forestry.api.apiculture.IBeeGenome; -import forestry.api.apiculture.IBeeHousing; -import forestry.api.apiculture.IBeeRoot; -import forestry.api.core.EnumHumidity; -import forestry.api.core.EnumTemperature; -import forestry.api.core.IIconProvider; -import forestry.api.genetics.AlleleManager; -import forestry.api.genetics.EnumTolerance; -import forestry.api.genetics.IAllele; -import forestry.api.genetics.IAlleleFlowers; -import forestry.api.genetics.IAlleleSpecies; -import forestry.api.genetics.IClassification; -import forestry.api.genetics.IIndividual; -import forestry.api.genetics.IMutation; -import forestry.core.genetics.alleles.EnumAllele; -import net.minecraft.client.renderer.texture.IIconRegister; -import net.minecraft.init.Items; -import net.minecraft.item.ItemStack; -import net.minecraft.stats.Achievement; -import net.minecraft.util.IIcon; -import net.minecraft.world.World; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashMap; -import java.util.LinkedHashMap; -import java.util.Locale; -import java.util.Map; - -// TODO drop this and replace for ExtraBeeDefinition -public enum ExtraBeesSpecies implements IAlleleBeeSpecies, IIconProvider { - ARID("aridus", 0xbee854), - BARREN("infelix", 0xe0d263), - DESOLATE("desolo", 0xd1b890), - GNAWING("apica", 0xe874b0), - ROTTEN("caries", 0xbfe0b6), - BONE("os", 0xe9ede8), - CREEPER("erepo", 0x2ce615), - DECOMPOSING("aegrus", 0x523711), - ROCK("saxum", 0xa8a8a8), - STONE("lapis", 0x757575), - GRANITE("granum", 0x695555), - MINERAL("minerale", 0x6e757d), - COPPER("cuprous", 0xd16308), - TIN("stannus", 0xbdb1bd), - IRON("ferrous", 0xa87058), - LEAD("plumbous", 0xad8bab), - ZINC("spelta", 0xedebff), - TITANIUM("titania", 0xb0aae3), - BRONZE, - BRASS, - STEEL, - TUNGSTATE("wolfram", 1249812), - GOLD("aureus", 15125515), - SILVER("argentus", 14408667), - ELECTRUM, - PLATINUM("platina", 14408667), - LAPIS("lazuli", 4009179), - SODALITE, - PYRITE, - BAUXITE, - CINNABAR, - SPHALERITE, - EMERALD("emerala", 1900291), - RUBY("ruba", 14024704), - SAPPHIRE("saphhira", 673791), - OLIVINE, - DIAMOND("diama", 8371706), - UNSTABLE("levis", 4099124), - NUCLEAR("nucleus", 4312111), - RADIOACTIVE("fervens", 2031360), - ANCIENT("antiquus", 15915919), - PRIMEVAL("priscus", 11773563), - PREHISTORIC("pristinus", 7232064), - RELIC("sapiens", 5062166), - COAL("carbo", 8025672), - RESIN("lacrima", 10908443), - OIL("lubricus", 5719920), - PEAT, - DISTILLED("distilli", 3498838), - FUEL("refina", 16760835), - CREOSOTE("creosota", 9936403), - LATEX("latex", 4803134), - WATER("aqua", 9741055), - RIVER("flumen", 8631252), - OCEAN("mare", 1912493), - INK("atramentum", 922695), - GROWING("tyrelli", 6024152), - THRIVING("thriva", 3466109), - BLOOMING("blooma", 704308), - SWEET("mellitus", 16536049), - SUGAR("dulcis", 15127520), - RIPENING("ripa", 11716445), - FRUIT("pomum", 14375030), - ALCOHOL("vinum", 15239777), - FARM("ager", 7723872), - MILK("lacteus", 14936296), - COFFEE("arabica", 9199152), - CITRUS, - MINT, - SWAMP("paludis", 3500339), - BOGGY("lama", 7887913), - FUNGAL("boletus", 13722112), - MARBLE, - ROMAN, - GREEK, - CLASSICAL, - BASALT("aceri", 9202025), - TEMPERED("iratus", 9062472), - ANGRY, - VOLCANIC("volcano", 5049356), - MALICIOUS("acerbus", 7875191), - INFECTIOUS("contagio", 12070581), - VIRULENT("morbus", 15733740), - VISCOUS("liquidus", 608014), - GLUTINOUS("glutina", 1936423), - STICKY("lentesco", 1565480), - CORROSIVE("corrumpo", 4873227), - CAUSTIC("torrens", 8691997), - ACIDIC("acidus", 12644374), - EXCITED("excita", 16729413), - ENERGETIC("energia", 15218119), - ECSTATIC("ecstatica", 11482600), - ARTIC("artica", 11395296), - FREEZING("glacia", 8119267), - SHADOW("shadowa", 5855577), - DARKENED("darka", 3354163), - ABYSS("abyssba", 2164769), - RED("rubra", 16711680), - YELLOW("fulvus", 16768256), - BLUE("caeruleus", 8959), - GREEN("prasinus", 39168), - BLACK("niger", 5723991), - WHITE("albus", 16777215), - BROWN("fuscus", 6042895), - ORANGE("flammeus", 16751872), - CYAN("cyana", 65509), - PURPLE("purpureus", 11403519), - GRAY("ravus", 12237498), - LIGHTBLUE("aqua", 40447), - PINK("rosaceus", 16744671), - LIMEGREEN("lima", 65288), - MAGENTA("fuchsia", 16711884), - LIGHTGRAY("canus", 13224393), - CELEBRATORY("celeba", 16386666), - JADED("jadeca", 16386666), - GLOWSTONE("glowia", 14730779), - HAZARDOUS("infensus", 11562024), - NICKEL("claro", 16768764), - INVAR, - QUANTUM("quanta", 3655131), - SPATIAL("spatia", 4987872), - UNUSUAL("daniella", 5874874), - YELLORIUM("yellori", 14019840), - CYANITE("cyanita", 34541), - BLUTONIUM("caruthus", 1769702), - MYSTICAL("mystica", 4630306); - - public HashMap allProducts = new LinkedHashMap<>(); - public HashMap allSpecialties = new LinkedHashMap<>(); - public EnumBeeSpeciesState state; - - protected boolean nocturnal = false; - - private int primaryColor; - private int secondaryColor = 0xffdc16; - private EnumTemperature temperature = EnumTemperature.NORMAL; - private EnumHumidity humidity = EnumHumidity.NORMAL; - private boolean hasEffect = false; - private boolean isSecret = true; - private boolean isCounted = true; - private String binomial; - private IClassification branch = null; - private String uid; - private Achievement achievement = null; - private boolean dominant = true; - private HashMap products = new LinkedHashMap<>(); - private HashMap specialties = new LinkedHashMap<>(); - private IAllele[] template; - - @SideOnly(Side.CLIENT) - private IIcon[][] icons; - - ExtraBeesSpecies(String binomial, int color) { - this.binomial = binomial; - primaryColor = color; - state = EnumBeeSpeciesState.ACTIVE; - uid = toString().toLowerCase(); - } - - ExtraBeesSpecies() { - binomial = ""; - primaryColor = 0xffffff; - state = EnumBeeSpeciesState.DEPRECATED; - uid = ""; - } - - public static IAllele[] getDefaultTemplate() { - return Binnie.Genetics.getBeeRoot().getDefaultTemplate(); - } - - public static void doInit() { - for (ExtraBeesSpecies species : values()) { - species.template = getDefaultTemplate(); - } - - int aridBody = 0xcbe374; - int rockBody = 0x999999; - - ExtraBeesSpecies.ARID - .importTemplate(ForestryAllele.BeeSpecies.Modest) - .addProduct(EnumHoneyComb.BARREN, 0.30f) - .setHumidity(EnumHumidity.ARID) - .setFlowerProvider(ExtraBeesFlowers.DEAD.getUID()) - .setTemperatureTolerance(EnumTolerance.UP_1) - .setSecondaryColor(aridBody); - - ExtraBeesSpecies.BARREN - .importTemplate(ExtraBeesSpecies.ARID) - .setFertility(EnumAllele.Fertility.LOW) - .addProduct(EnumHoneyComb.BARREN, 0.30f); - - ExtraBeesSpecies.DESOLATE - .addProduct(EnumHoneyComb.BARREN, 0.30f) - .importTemplate(ExtraBeesSpecies.BARREN) - .setEffect(ExtraBeesEffect.HUNGER.getUID()) - .recessive() - .setNocturnal() - .setHasEffect(true); - - ExtraBeesSpecies.GNAWING - .importTemplate(ExtraBeesSpecies.BARREN) - .setFlowerProvider(ExtraBeesFlowers.WOOD.getUID()) - .addProduct(EnumHoneyComb.BARREN, 0.25f) - .addSpecialty(EnumHoneyComb.SAWDUST, 0.25f); - - ExtraBeesSpecies.ROTTEN - .importTemplate(ExtraBeesSpecies.DESOLATE) - .setNocturnal() - .setCaveDwelling() - .setTolerantFlyer() - .setEffect(ExtraBeesEffect.SPAWN_ZOMBIE.getUID()) - .addProduct(EnumHoneyComb.BARREN, 0.30f) - .addSpecialty(EnumHoneyComb.ROTTEN, 0.10f); - - ExtraBeesSpecies.BONE - .importTemplate(ExtraBeesSpecies.ROTTEN) - .addProduct(EnumHoneyComb.BARREN, 0.30f) - .addSpecialty(EnumHoneyComb.BONE, 0.10f) - .setEffect(ExtraBeesEffect.SPAWN_SKELETON.getUID()); - - ExtraBeesSpecies.CREEPER - .importTemplate(ExtraBeesSpecies.ROTTEN) - .setAllDay() - .addProduct(EnumHoneyComb.BARREN, 0.30f) - .addSpecialty(ItemHoneyComb.VanillaComb.POWDERY.get(), 0.08f) - .setEffect(ExtraBeesEffect.SPAWN_CREEPER.getUID()); - - ExtraBeesSpecies.DECOMPOSING - .importTemplate(ExtraBeesSpecies.BARREN) - .addProduct(EnumHoneyComb.BARREN, 0.30f) - .addSpecialty(EnumHoneyComb.COMPOST, 0.08f); - - ExtraBeesSpecies.ROCK - .addProduct(EnumHoneyComb.STONE, 0.30f) - .setIsSecret(false) - .setAllDay() - .setCaveDwelling() - .setTolerantFlyer() - .setTemperatureTolerance(EnumTolerance.BOTH_1) - .setHumidityTolerance(EnumTolerance.BOTH_1) - .setFlowerProvider(ExtraBeesFlowers.ROCK.getUID()) - .setFertility(EnumAllele.Fertility.LOW) - .setLifespan(EnumAllele.Lifespan.SHORT) - .setSecondaryColor(rockBody); - - ExtraBeesSpecies.STONE - .addProduct(EnumHoneyComb.STONE, 0.30f) - .importTemplate(ExtraBeesSpecies.ROCK) - .recessive() - .setSecondaryColor(rockBody); - - ExtraBeesSpecies.GRANITE - .addProduct(EnumHoneyComb.STONE, 0.30f) - .importTemplate(ExtraBeesSpecies.STONE) - .setTemperatureTolerance(EnumTolerance.BOTH_2) - .setHumidityTolerance(EnumTolerance.BOTH_2) - .setSecondaryColor(rockBody); - - ExtraBeesSpecies.MINERAL - .addProduct(EnumHoneyComb.STONE, 0.30f) - .importTemplate(ExtraBeesSpecies.GRANITE) - .setSecondaryColor(rockBody); - - ExtraBeesSpecies.COPPER - .addProduct(EnumHoneyComb.STONE, 0.20f) - .addSpecialty(EnumHoneyComb.COPPER, 0.06f) - .importTemplate(ExtraBeesSpecies.MINERAL) - .setSecondaryColor(rockBody); - - ExtraBeesSpecies.TIN.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.TIN.addSpecialty(EnumHoneyComb.TIN, 0.06f); - ExtraBeesSpecies.TIN.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.TIN.setSecondaryColor(rockBody); - - ExtraBeesSpecies.IRON.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.IRON.addSpecialty(EnumHoneyComb.IRON, 0.05f); - ExtraBeesSpecies.IRON.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.IRON.recessive(); - ExtraBeesSpecies.IRON.setSecondaryColor(rockBody); - - ExtraBeesSpecies.LEAD.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.LEAD.addSpecialty(EnumHoneyComb.LEAD, 0.50f); - ExtraBeesSpecies.LEAD.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.LEAD.setSecondaryColor(rockBody); - - ExtraBeesSpecies.NICKEL.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.NICKEL.addSpecialty(EnumHoneyComb.NICKEL, 0.05f); - ExtraBeesSpecies.NICKEL.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.NICKEL.setSecondaryColor(rockBody); - - ExtraBeesSpecies.ZINC.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.ZINC.addSpecialty(EnumHoneyComb.ZINC, 0.05f); - ExtraBeesSpecies.ZINC.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.ZINC.setSecondaryColor(rockBody); - - ExtraBeesSpecies.TITANIUM.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.TITANIUM.addSpecialty(EnumHoneyComb.TITANIUM, 0.02f); - ExtraBeesSpecies.TITANIUM.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.TITANIUM.setSecondaryColor(rockBody); - - ExtraBeesSpecies.TUNGSTATE.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.TUNGSTATE.addSpecialty(EnumHoneyComb.TUNGSTEN, 0.01f); - ExtraBeesSpecies.TUNGSTATE.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.TUNGSTATE.setSecondaryColor(rockBody); - - ExtraBeesSpecies.GOLD.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.GOLD.addSpecialty(EnumHoneyComb.GOLD, 0.02f); - ExtraBeesSpecies.GOLD.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.GOLD.setSecondaryColor(rockBody); - - ExtraBeesSpecies.SILVER.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.SILVER.addSpecialty(EnumHoneyComb.SILVER, 0.02f); - ExtraBeesSpecies.SILVER.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.SILVER.recessive(); - ExtraBeesSpecies.SILVER.recessive(); - ExtraBeesSpecies.SILVER.setSecondaryColor(rockBody); - - ExtraBeesSpecies.PLATINUM.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.PLATINUM.addSpecialty(EnumHoneyComb.PLATINUM, 0.01f); - ExtraBeesSpecies.PLATINUM.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.PLATINUM.recessive(); - ExtraBeesSpecies.PLATINUM.setSecondaryColor(rockBody); - - ExtraBeesSpecies.LAPIS.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.LAPIS.addSpecialty(EnumHoneyComb.LAPIS, 0.05f); - ExtraBeesSpecies.LAPIS.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.LAPIS.setSecondaryColor(rockBody); - - ExtraBeesSpecies.EMERALD.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.EMERALD.addSpecialty(EnumHoneyComb.EMERALD, 0.04f); - ExtraBeesSpecies.EMERALD.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.EMERALD.setSecondaryColor(rockBody); - - ExtraBeesSpecies.RUBY.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.RUBY.addSpecialty(EnumHoneyComb.RUBY, 0.03f); - ExtraBeesSpecies.RUBY.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.RUBY.setSecondaryColor(rockBody); - - ExtraBeesSpecies.SAPPHIRE.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.SAPPHIRE.addSpecialty(EnumHoneyComb.SAPPHIRE, 0.03f); - ExtraBeesSpecies.SAPPHIRE.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.SAPPHIRE.setSecondaryColor(rockBody); - - ExtraBeesSpecies.DIAMOND.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.DIAMOND.addSpecialty(EnumHoneyComb.DIAMOND, 0.01f); - ExtraBeesSpecies.DIAMOND.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.DIAMOND.setSecondaryColor(rockBody); - - ExtraBeesSpecies.UNSTABLE.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.UNSTABLE.addProduct(EnumHoneyComb.BARREN, 0.20f); - ExtraBeesSpecies.UNSTABLE.setEffect(ExtraBeesEffect.RADIOACTIVE.getUID()); - ExtraBeesSpecies.UNSTABLE.setFertility(EnumAllele.Fertility.LOW); - ExtraBeesSpecies.UNSTABLE.setLifespan(EnumAllele.Lifespan.SHORTEST); - ExtraBeesSpecies.UNSTABLE.recessive(); - - ExtraBeesSpecies.NUCLEAR.importTemplate(ExtraBeesSpecies.UNSTABLE); - ExtraBeesSpecies.NUCLEAR.addProduct(EnumHoneyComb.BARREN, 0.20f); - ExtraBeesSpecies.NUCLEAR.recessive(); - - ExtraBeesSpecies.RADIOACTIVE.importTemplate(ExtraBeesSpecies.NUCLEAR); - ExtraBeesSpecies.RADIOACTIVE.addProduct(EnumHoneyComb.BARREN, 0.20f); - ExtraBeesSpecies.RADIOACTIVE.addSpecialty(EnumHoneyComb.URANIUM, 0.02f); - ExtraBeesSpecies.RADIOACTIVE.setHasEffect(true); - ExtraBeesSpecies.RADIOACTIVE.recessive(); - - ExtraBeesSpecies.ANCIENT.importTemplate(ForestryAllele.BeeSpecies.Noble); - ExtraBeesSpecies.ANCIENT.addProduct(EnumHoneyComb.OLD, 0.30f); - ExtraBeesSpecies.ANCIENT.setLifespan(EnumAllele.Lifespan.ELONGATED); - - ExtraBeesSpecies.PRIMEVAL.importTemplate(ExtraBeesSpecies.ANCIENT); - ExtraBeesSpecies.PRIMEVAL.addProduct(EnumHoneyComb.OLD, 0.30f); - ExtraBeesSpecies.PRIMEVAL.setLifespan(EnumAllele.Lifespan.LONG); - - ExtraBeesSpecies.PREHISTORIC.importTemplate(ExtraBeesSpecies.ANCIENT); - ExtraBeesSpecies.PREHISTORIC.addProduct(EnumHoneyComb.OLD, 0.30f); - ExtraBeesSpecies.PREHISTORIC.setLifespan(EnumAllele.Lifespan.LONGER); - ExtraBeesSpecies.PREHISTORIC.setFertility(EnumAllele.Fertility.LOW); - ExtraBeesSpecies.PREHISTORIC.recessive(); - - ExtraBeesSpecies.RELIC.importTemplate(ExtraBeesSpecies.ANCIENT); - ExtraBeesSpecies.RELIC.addProduct(EnumHoneyComb.OLD, 0.30f); - ExtraBeesSpecies.RELIC.setHasEffect(true); - ExtraBeesSpecies.RELIC.setLifespan(EnumAllele.Lifespan.LONGEST); - - ExtraBeesSpecies.COAL.importTemplate(ExtraBeesSpecies.ANCIENT); - ExtraBeesSpecies.COAL.setLifespan(EnumAllele.Lifespan.NORMAL); - ExtraBeesSpecies.COAL.addProduct(EnumHoneyComb.OLD, 0.20f); - ExtraBeesSpecies.COAL.addSpecialty(EnumHoneyComb.COAL, 0.08f); - - ExtraBeesSpecies.RESIN.importTemplate(ExtraBeesSpecies.COAL); - ExtraBeesSpecies.RESIN.addProduct(EnumHoneyComb.OLD, 0.20f); - ExtraBeesSpecies.RESIN.addSpecialty(EnumHoneyComb.RESIN, 0.05f); - ExtraBeesSpecies.RESIN.recessive(); - - ExtraBeesSpecies.OIL.importTemplate(ExtraBeesSpecies.COAL); - ExtraBeesSpecies.OIL.addProduct(EnumHoneyComb.OLD, 0.20f); - ExtraBeesSpecies.OIL.addSpecialty(EnumHoneyComb.OIL, 0.05f); - - ExtraBeesSpecies.DISTILLED.importTemplate(ExtraBeesSpecies.OIL); - ExtraBeesSpecies.DISTILLED.addProduct(EnumHoneyComb.OIL, 0.10f); - ExtraBeesSpecies.DISTILLED.recessive(); - - ExtraBeesSpecies.FUEL.importTemplate(ExtraBeesSpecies.OIL); - ExtraBeesSpecies.FUEL.addProduct(EnumHoneyComb.OIL, 0.10f); - ExtraBeesSpecies.FUEL.addSpecialty(EnumHoneyComb.FUEL, 0.04f); - ExtraBeesSpecies.FUEL.setHasEffect(true); - - ExtraBeesSpecies.CREOSOTE.importTemplate(ExtraBeesSpecies.COAL); - ExtraBeesSpecies.CREOSOTE.addProduct(EnumHoneyComb.COAL, 0.10f); - ExtraBeesSpecies.CREOSOTE.addSpecialty(EnumHoneyComb.CREOSOTE, 0.07f); - ExtraBeesSpecies.CREOSOTE.setHasEffect(true); - - ExtraBeesSpecies.LATEX.importTemplate(ExtraBeesSpecies.RESIN); - ExtraBeesSpecies.LATEX.addProduct(EnumHoneyComb.RESIN, 0.10f); - ExtraBeesSpecies.LATEX.addSpecialty(EnumHoneyComb.LATEX, 0.05f); - ExtraBeesSpecies.LATEX.setHasEffect(true); - - ExtraBeesSpecies.WATER.addProduct(EnumHoneyComb.WATER, 0.30f); - ExtraBeesSpecies.WATER.setIsSecret(false); - ExtraBeesSpecies.WATER.setTolerantFlyer(); - ExtraBeesSpecies.WATER.setHumidityTolerance(EnumTolerance.BOTH_1); - ExtraBeesSpecies.WATER.setFlowerProvider(ExtraBeesFlowers.WATER.getUID()); - ExtraBeesSpecies.WATER.setFlowering(EnumAllele.Flowering.SLOW); - ExtraBeesSpecies.WATER.setEffect(ExtraBeesEffect.WATER.getUID()); - ExtraBeesSpecies.WATER.setHumidity(EnumHumidity.DAMP); - - ExtraBeesSpecies.RIVER.importTemplate(ExtraBeesSpecies.WATER); - ExtraBeesSpecies.RIVER.addProduct(EnumHoneyComb.WATER, 0.30f); - ExtraBeesSpecies.RIVER.addSpecialty(EnumHoneyComb.CLAY, 0.20f); - ExtraBeesSpecies.RIVER.importTemplate(ExtraBeesSpecies.WATER); - - ExtraBeesSpecies.OCEAN.importTemplate(ExtraBeesSpecies.WATER); - ExtraBeesSpecies.OCEAN.addProduct(EnumHoneyComb.WATER, 0.30f); - ExtraBeesSpecies.OCEAN.importTemplate(ExtraBeesSpecies.WATER); - ExtraBeesSpecies.OCEAN.recessive(); - - ExtraBeesSpecies.INK.importTemplate(ExtraBeesSpecies.OCEAN); - ExtraBeesSpecies.INK.addProduct(EnumHoneyComb.WATER, 0.30f); - ExtraBeesSpecies.INK.addSpecialty(new ItemStack(Items.dye, 1, 0), 0.10f); - - ExtraBeesSpecies.GROWING.importTemplate(ForestryAllele.BeeSpecies.Forest); - ExtraBeesSpecies.GROWING.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.35f); - ExtraBeesSpecies.GROWING.setFlowering(EnumAllele.Flowering.AVERAGE); - ExtraBeesSpecies.GROWING.setFlowerProvider(ExtraBeesFlowers.LEAVES.getUID()); - - ExtraBeesSpecies.THRIVING.importTemplate(ExtraBeesSpecies.GROWING); - ExtraBeesSpecies.THRIVING.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.35f); - ExtraBeesSpecies.THRIVING.setFlowering(EnumAllele.Flowering.FAST); - - ExtraBeesSpecies.BLOOMING.importTemplate(ExtraBeesSpecies.THRIVING); - ExtraBeesSpecies.BLOOMING.setFlowering(EnumAllele.Flowering.FASTEST); - ExtraBeesSpecies.BLOOMING.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.35f); - ExtraBeesSpecies.BLOOMING.setFlowerProvider(ExtraBeesFlowers.SAPLING.getUID()); - ExtraBeesSpecies.BLOOMING.setEffect(ExtraBeesEffect.BONEMEAL_SAPLING.getUID()); - - ExtraBeesSpecies.SWEET.importTemplate(ForestryAllele.BeeSpecies.Rural); - ExtraBeesSpecies.SWEET.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.40f); - ExtraBeesSpecies.SWEET.addProduct(new ItemStack(Items.sugar, 1, 0), 0.10f); - ExtraBeesSpecies.SWEET.setFlowerProvider(ExtraBeesFlowers.SUGAR.getUID()); - - ExtraBeesSpecies.SUGAR.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.40f); - ExtraBeesSpecies.SUGAR.addProduct(new ItemStack(Items.sugar, 1, 0), 0.20f); - ExtraBeesSpecies.SUGAR.importTemplate(ExtraBeesSpecies.SWEET); - - ExtraBeesSpecies.RIPENING.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f); - ExtraBeesSpecies.RIPENING.addProduct(new ItemStack(Items.sugar, 1, 0), 0.10f); - ExtraBeesSpecies.RIPENING.addSpecialty(EnumHoneyComb.FRUIT, 0.10f); - ExtraBeesSpecies.RIPENING.setFlowerProvider(ExtraBeesFlowers.FRUIT.getUID()); - ExtraBeesSpecies.RIPENING.importTemplate(ExtraBeesSpecies.SUGAR); - - ExtraBeesSpecies.FRUIT.importTemplate(ExtraBeesSpecies.RIPENING); - ExtraBeesSpecies.FRUIT.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f); - ExtraBeesSpecies.FRUIT.addProduct(new ItemStack(Items.sugar, 1, 0), 0.15f); - ExtraBeesSpecies.FRUIT.addSpecialty(EnumHoneyComb.FRUIT, 0.20f); - ExtraBeesSpecies.FRUIT.setEffect(ExtraBeesEffect.BONEMEAL_FRUIT.getUID()); - ExtraBeesSpecies.FRUIT.setHasEffect(true); - - ExtraBeesSpecies.ALCOHOL.importTemplate(ExtraBeesSpecies.SWEET); - ExtraBeesSpecies.ALCOHOL.addProduct(ItemHoneyComb.VanillaComb.WHEATEN.get(), 0.30f); - ExtraBeesSpecies.ALCOHOL.addSpecialty(EnumHoneyComb.ALCOHOL, 0.10f); - ExtraBeesSpecies.ALCOHOL.setEffect("forestry.effectDrunkard"); - ExtraBeesSpecies.ALCOHOL.recessive(); - - ExtraBeesSpecies.FARM.addProduct(ItemHoneyComb.VanillaComb.WHEATEN.get(), 0.30f); - ExtraBeesSpecies.FARM.addSpecialty(EnumHoneyComb.SEED, 0.10f); - ExtraBeesSpecies.FARM.importTemplate(ForestryAllele.BeeSpecies.Rural); - - ExtraBeesSpecies.MILK.addProduct(ItemHoneyComb.VanillaComb.WHEATEN.get(), 0.30f); - ExtraBeesSpecies.MILK.addSpecialty(EnumHoneyComb.MILK, 0.10f); - ExtraBeesSpecies.MILK.importTemplate(ForestryAllele.BeeSpecies.Rural); - - ExtraBeesSpecies.COFFEE.addProduct(ItemHoneyComb.VanillaComb.WHEATEN.get(), 0.30f); - ExtraBeesSpecies.COFFEE.addSpecialty(EnumHoneyComb.COFFEE, 0.08f); - ExtraBeesSpecies.COFFEE.importTemplate(ForestryAllele.BeeSpecies.Rural); - - ExtraBeesSpecies.SWAMP.addProduct(ItemHoneyComb.VanillaComb.MOSSY.get(), 0.30f); - ExtraBeesSpecies.SWAMP.importTemplate(ForestryAllele.BeeSpecies.Marshy); - ExtraBeesSpecies.SWAMP.setHumidity(EnumHumidity.DAMP); - ExtraBeesSpecies.SWAMP.setEffect(ExtraBeesEffect.SLOW.getUID()); - - ExtraBeesSpecies.BOGGY.importTemplate(ExtraBeesSpecies.SWAMP); - ExtraBeesSpecies.BOGGY.addProduct(ItemHoneyComb.VanillaComb.MOSSY.get(), 0.30f); - ExtraBeesSpecies.BOGGY.importTemplate(ExtraBeesSpecies.SWAMP); - ExtraBeesSpecies.BOGGY.recessive(); - - ExtraBeesSpecies.FUNGAL.importTemplate(ExtraBeesSpecies.BOGGY); - ExtraBeesSpecies.FUNGAL.addProduct(ItemHoneyComb.VanillaComb.MOSSY.get(), 0.30f); - ExtraBeesSpecies.FUNGAL.addSpecialty(EnumHoneyComb.FUNGAL, 0.15f); - ExtraBeesSpecies.FUNGAL.importTemplate(ExtraBeesSpecies.BOGGY); - ExtraBeesSpecies.FUNGAL.setEffect(ExtraBeesEffect.BONEMEAL_MUSHROOM.getUID()); - ExtraBeesSpecies.FUNGAL.setHasEffect(true); - - ExtraBeesSpecies.BASALT.addProduct(ItemHoneyComb.VanillaComb.SIMMERING.get(), 0.25f); - ExtraBeesSpecies.BASALT.importTemplate(ForestryAllele.BeeSpecies.Sinister); - ExtraBeesSpecies.BASALT.setEffect("forestry.effectAggressive"); - ExtraBeesSpecies.BASALT.setSecondaryColor(0x9a2323); - ExtraBeesSpecies.BASALT.setHumidity(EnumHumidity.ARID); - ExtraBeesSpecies.BASALT.setTemperature(EnumTemperature.HELLISH); - - ExtraBeesSpecies.TEMPERED.addProduct(ItemHoneyComb.VanillaComb.SIMMERING.get(), 0.25f); - ExtraBeesSpecies.TEMPERED.importTemplate(ExtraBeesSpecies.BASALT); - ExtraBeesSpecies.TEMPERED.setEffect(ExtraBeesEffect.METEOR.getUID()); - ExtraBeesSpecies.TEMPERED.recessive(); - ExtraBeesSpecies.TEMPERED.setSecondaryColor(0x9a2323); - - ExtraBeesSpecies.VOLCANIC.importTemplate(ExtraBeesSpecies.TEMPERED); - ExtraBeesSpecies.VOLCANIC.addProduct(ItemHoneyComb.VanillaComb.SIMMERING.get(), 0.25f); - ExtraBeesSpecies.VOLCANIC.addSpecialty(EnumHoneyComb.BLAZE, 0.10f); - ExtraBeesSpecies.VOLCANIC.setHasEffect(true); - ExtraBeesSpecies.VOLCANIC.setSecondaryColor(0x9a2323); - - ExtraBeesSpecies.MALICIOUS.importTemplate(ForestryAllele.BeeSpecies.Tropical); - ExtraBeesSpecies.MALICIOUS.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f); - ExtraBeesSpecies.MALICIOUS.setSecondaryColor(0x069764); - ExtraBeesSpecies.MALICIOUS.setHumidity(EnumHumidity.DAMP); - ExtraBeesSpecies.MALICIOUS.setTemperature(EnumTemperature.WARM); - - ExtraBeesSpecies.INFECTIOUS.importTemplate(ExtraBeesSpecies.MALICIOUS); - ExtraBeesSpecies.INFECTIOUS.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f); - ExtraBeesSpecies.INFECTIOUS.setFlowering(EnumAllele.Flowering.SLOW); - ExtraBeesSpecies.INFECTIOUS.setSecondaryColor(0x069764); - - ExtraBeesSpecies.VIRULENT.importTemplate(ExtraBeesSpecies.INFECTIOUS); - ExtraBeesSpecies.VIRULENT.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f); - ExtraBeesSpecies.VIRULENT.addSpecialty(EnumHoneyComb.VENOMOUS, 0.12f); - ExtraBeesSpecies.VIRULENT.setFlowering(EnumAllele.Flowering.AVERAGE); - ExtraBeesSpecies.VIRULENT.recessive(); - ExtraBeesSpecies.VIRULENT.setHasEffect(true); - ExtraBeesSpecies.VIRULENT.setSecondaryColor(0x069764); - - ExtraBeesSpecies.VISCOUS.importTemplate(ForestryAllele.BeeSpecies.Tropical); - ExtraBeesSpecies.VISCOUS.setEffect(ExtraBeesEffect.ECTOPLASM.getUID()); - ExtraBeesSpecies.VISCOUS.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f); - ExtraBeesSpecies.VISCOUS.setSecondaryColor(0x069764); - ExtraBeesSpecies.VISCOUS.setHumidity(EnumHumidity.DAMP); - ExtraBeesSpecies.VISCOUS.setSpeed(EnumAllele.Speed.SLOW); - ExtraBeesSpecies.VISCOUS.setTemperature(EnumTemperature.WARM); - - ExtraBeesSpecies.GLUTINOUS.importTemplate(ExtraBeesSpecies.VISCOUS); - ExtraBeesSpecies.GLUTINOUS.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f); - ExtraBeesSpecies.GLUTINOUS.setSpeed(EnumAllele.Speed.NORMAL); - ExtraBeesSpecies.GLUTINOUS.setSecondaryColor(0x069764); - - ExtraBeesSpecies.STICKY.importTemplate(ExtraBeesSpecies.GLUTINOUS); - ExtraBeesSpecies.STICKY.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f); - ExtraBeesSpecies.STICKY.addSpecialty(EnumHoneyComb.SLIME, 0.12f); - ExtraBeesSpecies.STICKY.setSpeed(EnumAllele.Speed.FAST); - ExtraBeesSpecies.STICKY.setHasEffect(true); - ExtraBeesSpecies.STICKY.setSecondaryColor(0x069764); - - ExtraBeesSpecies.CORROSIVE.importTemplate(ExtraBeesSpecies.STICKY); - ExtraBeesSpecies.CORROSIVE.setHumidity(EnumHumidity.DAMP); - ExtraBeesSpecies.CORROSIVE.setTemperature(EnumTemperature.WARM); - ExtraBeesSpecies.CORROSIVE.setEffect(ExtraBeesEffect.ACID.getUID()); - ExtraBeesSpecies.CORROSIVE.setFlowering(EnumAllele.Flowering.AVERAGE); - ExtraBeesSpecies.CORROSIVE.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 20f); - ExtraBeesSpecies.CORROSIVE.recessive(); - ExtraBeesSpecies.CORROSIVE.setSecondaryColor(0x069764); - - ExtraBeesSpecies.CAUSTIC.importTemplate(ExtraBeesSpecies.CORROSIVE); - ExtraBeesSpecies.CAUSTIC.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f); - ExtraBeesSpecies.CAUSTIC.addSpecialty(EnumHoneyComb.ACIDIC, 0.03f); - ExtraBeesSpecies.CAUSTIC.setSecondaryColor(0x069764); - - ExtraBeesSpecies.ACIDIC.importTemplate(ExtraBeesSpecies.CAUSTIC); - ExtraBeesSpecies.ACIDIC.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.20f); - ExtraBeesSpecies.ACIDIC.addSpecialty(EnumHoneyComb.ACIDIC, 0.16f); - ExtraBeesSpecies.ACIDIC.setHasEffect(true); - ExtraBeesSpecies.ACIDIC.setSecondaryColor(0x069764); - - ExtraBeesSpecies.EXCITED.setEffect(ExtraBeesEffect.LIGHTNING.getUID()); - ExtraBeesSpecies.EXCITED.addProduct(EnumHoneyComb.REDSTONE, 0.10f); - ExtraBeesSpecies.EXCITED.setCaveDwelling(); - ExtraBeesSpecies.EXCITED.setFlowerProvider(ExtraBeesFlowers.REDSTONE.getUID()); - - ExtraBeesSpecies.ENERGETIC.importTemplate(ExtraBeesSpecies.EXCITED); - ExtraBeesSpecies.ENERGETIC.setEffect(ExtraBeesEffect.LIGHTNING.getUID()); - ExtraBeesSpecies.ENERGETIC.addProduct(EnumHoneyComb.REDSTONE, 0.12f); - ExtraBeesSpecies.ENERGETIC.recessive(); - - ExtraBeesSpecies.ECSTATIC.importTemplate(ExtraBeesSpecies.ENERGETIC); - ExtraBeesSpecies.ECSTATIC.setEffect(ExtraBeesEffect.Power.getUID()); - ExtraBeesSpecies.ECSTATIC.addProduct(EnumHoneyComb.REDSTONE, 0.20f); - ExtraBeesSpecies.ECSTATIC.addSpecialty(EnumHoneyComb.IC2ENERGY, 0.08f); - ExtraBeesSpecies.ECSTATIC.setHasEffect(true); - - ExtraBeesSpecies.ARTIC.importTemplate(ForestryAllele.BeeSpecies.Wintry); - ExtraBeesSpecies.ARTIC.addProduct(ItemHoneyComb.VanillaComb.FROZEN.get(), 0.25f); - ExtraBeesSpecies.ARTIC.setTemperature(EnumTemperature.ICY); - ExtraBeesSpecies.ARTIC.setSecondaryColor(0xdaf5f3); - - ExtraBeesSpecies.FREEZING.importTemplate(ExtraBeesSpecies.ARTIC); - ExtraBeesSpecies.FREEZING.addProduct(ItemHoneyComb.VanillaComb.FROZEN.get(), 0.20f); - ExtraBeesSpecies.FREEZING.addSpecialty(EnumHoneyComb.GLACIAL, 0.10f); - ExtraBeesSpecies.FREEZING.setSecondaryColor(0xdaf5f3); - - ExtraBeesSpecies.SHADOW.importTemplate(ExtraBeesSpecies.BASALT); - ExtraBeesSpecies.SHADOW.setNocturnal(); - ExtraBeesSpecies.SHADOW.addProduct(EnumHoneyComb.SHADOW, 0.05f); - ExtraBeesSpecies.SHADOW.setEffect(ExtraBeesEffect.BLINDNESS.getUID()); - ExtraBeesSpecies.SHADOW.setAllDay(false); - ExtraBeesSpecies.SHADOW.recessive(); - ExtraBeesSpecies.SHADOW.setSecondaryColor(0x333333); - - ExtraBeesSpecies.DARKENED.addProduct(EnumHoneyComb.SHADOW, 0.10f); - ExtraBeesSpecies.DARKENED.setNocturnal(); - ExtraBeesSpecies.DARKENED.importTemplate(ExtraBeesSpecies.SHADOW); - ExtraBeesSpecies.DARKENED.setSecondaryColor(0x333333); - - ExtraBeesSpecies.ABYSS.importTemplate(ExtraBeesSpecies.DARKENED); - ExtraBeesSpecies.ABYSS.setNocturnal(); - ExtraBeesSpecies.ABYSS.addProduct(EnumHoneyComb.SHADOW, 0.25f); - ExtraBeesSpecies.ABYSS.setEffect(ExtraBeesEffect.WITHER.getUID()); - ExtraBeesSpecies.ABYSS.setHasEffect(true); - ExtraBeesSpecies.ABYSS.setSecondaryColor(0x333333); - - ExtraBeesSpecies.CELEBRATORY.importTemplate(ForestryAllele.BeeSpecies.Merry); - ExtraBeesSpecies.CELEBRATORY.setEffect(ExtraBeesEffect.FIREWORKS.getUID()); - - ExtraBeesSpecies.GLOWSTONE.importTemplate(ExtraBeesSpecies.BASALT); - ExtraBeesSpecies.GLOWSTONE.addProduct(EnumHoneyComb.GLOWSTONE, 0.15f); - ExtraBeesSpecies.GLOWSTONE.setSecondaryColor(0x9a2323); - - ExtraBeesSpecies.HAZARDOUS.importTemplate(ForestryAllele.BeeSpecies.Austere); - ExtraBeesSpecies.HAZARDOUS.addProduct(EnumHoneyComb.SALTPETER, 0.12f); - - ExtraBeesSpecies.JADED.importTemplate(ForestryAllele.BeeSpecies.Imperial); - ExtraBeesSpecies.JADED.setFertility(EnumAllele.Fertility.MAXIMUM); - ExtraBeesSpecies.JADED.setFlowering(EnumAllele.Flowering.MAXIMUM); - ExtraBeesSpecies.JADED.setTerritory(EnumAllele.Territory.LARGEST); - ExtraBeesSpecies.JADED.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f); - ExtraBeesSpecies.JADED.addSpecialty(Mods.Forestry.stack("pollen"), 0.20f); - ExtraBeesSpecies.JADED.setHasEffect(true); - ExtraBeesSpecies.JADED.setSecondaryColor(0xdc8aeb); - ExtraBeesSpecies.JADED.addSpecialty(EnumHoneyComb.PURPLE, 0.15f); - ExtraBeesSpecies.JADED.isCounted = false; - - ExtraBeesSpecies.UNUSUAL.importTemplate(ForestryAllele.BeeSpecies.Ended); - ExtraBeesSpecies.UNUSUAL.setEffect(ExtraBeesEffect.GRAVITY.getUID()); - ExtraBeesSpecies.UNUSUAL.setSecondaryColor(0xbaa2eb); - ExtraBeesSpecies.UNUSUAL.addProduct(ItemHoneyComb.VanillaComb.QUARTZ.get(), 0.25f); - - ExtraBeesSpecies.SPATIAL.importTemplate(ExtraBeesSpecies.UNUSUAL); - ExtraBeesSpecies.SPATIAL.setEffect(ExtraBeesEffect.GRAVITY.getUID()); - ExtraBeesSpecies.SPATIAL.setSecondaryColor(0xa44ecc); - ExtraBeesSpecies.SPATIAL.addProduct(ItemHoneyComb.VanillaComb.QUARTZ.get(), 0.25f); - ExtraBeesSpecies.SPATIAL.addSpecialty(EnumHoneyComb.CERTUS, 0.05f); - - ExtraBeesSpecies.QUANTUM.importTemplate(ExtraBeesSpecies.QUANTUM); - ExtraBeesSpecies.QUANTUM.setEffect(ExtraBeesEffect.TELEPORT.getUID()); - ExtraBeesSpecies.QUANTUM.setSecondaryColor(0xd50fdb); - ExtraBeesSpecies.QUANTUM.addProduct(ItemHoneyComb.VanillaComb.QUARTZ.get(), 0.25f); - ExtraBeesSpecies.QUANTUM.addSpecialty(EnumHoneyComb.CERTUS, 0.15f); - ExtraBeesSpecies.QUANTUM.addSpecialty(EnumHoneyComb.ENDERPEARL, 0.15f); - - ExtraBeesSpecies.YELLORIUM - .importTemplate(ExtraBeesSpecies.NUCLEAR) - .addProduct(EnumHoneyComb.BARREN, 0.20f) - .addSpecialty(EnumHoneyComb.YELLORIUM, 0.02f) - .setEffect(ExtraBeesEffect.RADIOACTIVE.getUID()) - .setFertility(EnumAllele.Fertility.LOW) - .setLifespan(EnumAllele.Lifespan.SHORTEST); - - ExtraBeesSpecies.CYANITE - .importTemplate(ExtraBeesSpecies.YELLORIUM) - .addProduct(EnumHoneyComb.BARREN, 0.20f) - .addSpecialty(EnumHoneyComb.CYANITE, 0.01f); - - ExtraBeesSpecies.BLUTONIUM - .importTemplate(ExtraBeesSpecies.CYANITE) - .addProduct(EnumHoneyComb.BARREN, 0.20f) - .addSpecialty(EnumHoneyComb.BLUTONIUM, 0.01f); - - ExtraBeesSpecies.MYSTICAL.importTemplate(ForestryAllele.BeeSpecies.Noble); - for (Map.Entry entry : ForestryAllele.BeeSpecies.Noble.getAllele().getProductChances().entrySet()) { - ExtraBeesSpecies.MYSTICAL.addProduct(entry.getKey(), entry.getValue()); - } - - ExtraBeesSpecies.MYSTICAL.setFlowerProvider(ExtraBeesFlowers.MYSTICAL.getUID()); - for (ExtraBeesSpecies species2 : values()) { - if (species2.state != EnumBeeSpeciesState.ACTIVE) { - AlleleManager.alleleRegistry.blacklistAllele(species2.getUID()); - } - - for (EnumBeeChromosome chromo : EnumBeeChromosome.values()) { - if (chromo != EnumBeeChromosome.HUMIDITY) { - IAllele allele = species2.template[chromo.ordinal()]; - if (allele == null || !chromo.getAlleleClass().isInstance(allele)) { - throw new RuntimeException(species2.getName() + " has an invalid " + chromo.toString() + " chromosome!"); - } - } - } - } - - for (int i = 0; i < 16; ++i) { - ExtraBeesSpecies species3 = values()[ExtraBeesSpecies.RED.ordinal() + i]; - EnumHoneyComb comb = EnumHoneyComb.values()[EnumHoneyComb.RED.ordinal() + i]; - species3.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f); - species3.addSpecialty(comb, 0.25f); - species3.setSecondaryColor(0x8cff00); - } - - for (ExtraBeesSpecies species2 : values()) { - species2.registerTemplate(); - } - } - - @Override - public String getName() { - return ExtraBees.proxy.localise("species." + name().toLowerCase() + ".name"); - } - - @Override - public String getDescription() { - return ExtraBees.proxy.localiseOrBlank("species." + name().toLowerCase() + ".desc"); - } - - @Override - public EnumTemperature getTemperature() { - return temperature; - } - - private void setTemperature(EnumTemperature temperature) { - this.temperature = temperature; - } - - @Override - public EnumHumidity getHumidity() { - return humidity; - } - - private ExtraBeesSpecies setHumidity(EnumHumidity humidity) { - this.humidity = humidity; - return this; - } - - @Override - public boolean hasEffect() { - return hasEffect; - } - - @Override - public boolean isSecret() { - return isSecret; - } - - @Override - public boolean isCounted() { - return isCounted; - } - - @Override - public String getBinomial() { - return binomial; - } - - @Override - public String getAuthority() { - return "Binnie"; - } - - @Override - public IClassification getBranch() { - return branch; - } - - void setBranch(IClassification branch) { - this.branch = branch; - } - - @Override - public String getUID() { - return "extrabees.species." + uid; - } - - @Override - public boolean isDominant() { - return dominant; - } - - public HashMap getProducts() { - return products; - } - - public HashMap getSpecialty() { - return specialties; - } - - private void setState(EnumBeeSpeciesState state) { - this.state = state; - } - - public void registerTemplate() { - Binnie.Genetics.getBeeRoot().registerTemplate(getTemplate()); - if (state != EnumBeeSpeciesState.ACTIVE) { - AlleleManager.alleleRegistry.blacklistAllele(getUID()); - } - } - - public void addProduct(ItemStack product, Float chance) { - if (product == null) { - setState(EnumBeeSpeciesState.INACTIVE); - } else { - products.put(product, chance); - allProducts.put(product, chance); - } - } - - public ExtraBeesSpecies addProduct(IItemEnum product, Float chance) { - if (product.isActive()) { - addProduct(product.get(1), chance); - } else { - allProducts.put(product.get(1), chance); - setState(EnumBeeSpeciesState.INACTIVE); - } - return this; - } - - public ExtraBeesSpecies addSpecialty(ItemStack product, Float chance) { - if (product == null) { - setState(EnumBeeSpeciesState.INACTIVE); - } else { - specialties.put(product, chance); - allSpecialties.put(product, chance); - } - return this; - } - - private ExtraBeesSpecies addSpecialty(IItemEnum product, Float chance) { - if (product.isActive()) { - addSpecialty(product.get(1), chance); - } else { - setState(EnumBeeSpeciesState.INACTIVE); - allSpecialties.put(product.get(1), chance); - } - return this; - } - - public IAllele[] getTemplate() { - template[EnumBeeChromosome.SPECIES.ordinal()] = this; - return template; - } - - public ExtraBeesSpecies importTemplate(ForestryAllele.BeeSpecies species) { - importTemplate(species.getTemplate()); - return this; - } - - public ExtraBeesSpecies importTemplate(ExtraBeesSpecies species) { - importTemplate(species.getTemplate()); - return this; - } - - public void importTemplate(IAllele[] template) { - this.template = template.clone(); - setHumidity(((IAlleleSpecies) template[0]).getHumidity()); - setTemperature(((IAlleleSpecies) template[0]).getTemperature()); - setSecondaryColor(((IAlleleSpecies) template[0]).getIconColour(1)); - this.template[EnumBeeChromosome.SPECIES.ordinal()] = this; - } - - public ExtraBeesSpecies recessive() { - dominant = false; - return this; - } - - public ExtraBeesSpecies setIsSecret(boolean secret) { - isSecret = secret; - return this; - } - - public ExtraBeesSpecies setHasEffect(boolean effect) { - hasEffect = effect; - return this; - } - - public ExtraBeesSpecies setSecondaryColor(int colour) { - secondaryColor = colour; - return this; - } - - @Override - public boolean isJubilant(IBeeGenome genome, IBeeHousing housing) { - return true; - } - - @Override - public int getIconColour(int renderPass) { - if (renderPass == 0) { - return primaryColor; - } - if (renderPass == 1) { - return secondaryColor; - } - return 0xffffff; - } - - @Override - public IIconProvider getIconProvider() { - return this; - } - - @Override - public IIcon getIcon(short texUID) { - return null; - } - - @Override - @SideOnly(Side.CLIENT) - public void registerIcons(IIconRegister register) { - String iconType = "default"; - String mod = "forestry"; - if (this == ExtraBeesSpecies.JADED) { - iconType = "jaded"; - mod = "extrabees"; - } - - icons = new IIcon[EnumBeeType.values().length][3]; - IIcon body1 = BinnieCore.proxy.getIcon(register, mod, "bees/" + iconType + "/body1"); - for (int i = 0; i < EnumBeeType.values().length; ++i) { - if (EnumBeeType.values()[i] != EnumBeeType.NONE) { - icons[i][0] = BinnieCore.proxy.getIcon(register, mod, "bees/" + iconType + "/" + EnumBeeType.values()[i].toString().toLowerCase(Locale.ENGLISH) + ".outline"); - icons[i][1] = ((EnumBeeType.values()[i] != EnumBeeType.LARVAE) ? body1 : BinnieCore.proxy.getIcon(register, mod, "bees/" + iconType + "/" + EnumBeeType.values()[i].toString().toLowerCase(Locale.ENGLISH) + ".body")); - icons[i][2] = BinnieCore.proxy.getIcon(register, mod, "bees/" + iconType + "/" + EnumBeeType.values()[i].toString().toLowerCase(Locale.ENGLISH) + ".body2"); - } - } - } - - @Override - @SideOnly(Side.CLIENT) - public IIcon getIcon(EnumBeeType type, int renderPass) { - if (icons == null) { - return ExtraBeesSpecies.ARID.getIcon(type, renderPass); - } - return icons[type.ordinal()][renderPass]; - } - - @Override - public IBeeRoot getRoot() { - return Binnie.Genetics.getBeeRoot(); - } - - @Override - public boolean isNocturnal() { - return nocturnal; - } - - public ExtraBeesSpecies setNocturnal() { - nocturnal = true; - return this; - } - - public ExtraBeesSpecies setAllDay() { - return setAllDay(true); - } - - public ExtraBeesSpecies setAllDay(boolean allDay) { - template[EnumBeeChromosome.NOCTURNAL.ordinal()] = AlleleHelper.getAllele(allDay); - return this; - } - - public ExtraBeesSpecies setCaveDwelling() { - template[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = AlleleHelper.getAllele(true); - return this; - } - - public ExtraBeesSpecies setTolerantFlyer() { - template[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = AlleleHelper.getAllele(true); - return this; - } - - public ExtraBeesSpecies setFlowerProvider(String uid) { - IAllele allele = AlleleManager.alleleRegistry.getAllele(uid); - if (allele instanceof IAlleleFlowers) { - template[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = allele; - } - return this; - } - - public ExtraBeesSpecies setEffect(String uid) { - IAllele allele = AlleleManager.alleleRegistry.getAllele(uid); - if (allele instanceof IAlleleBeeEffect) { - template[EnumBeeChromosome.EFFECT.ordinal()] = allele; - } - return this; - } - - private ExtraBeesSpecies setFertility(EnumAllele.Fertility fertility) { - template[EnumBeeChromosome.FERTILITY.ordinal()] = AlleleHelper.getAllele(fertility); - return this; - } - - private ExtraBeesSpecies setLifespan(EnumAllele.Lifespan lifespan) { - template[EnumBeeChromosome.LIFESPAN.ordinal()] = AlleleHelper.getAllele(lifespan); - return this; - } - - private ExtraBeesSpecies setSpeed(EnumAllele.Speed speed) { - template[EnumBeeChromosome.SPEED.ordinal()] = AlleleHelper.getAllele(speed); - return this; - } - - private ExtraBeesSpecies setTerritory(EnumAllele.Territory territory) { - template[EnumBeeChromosome.TERRITORY.ordinal()] = AlleleHelper.getAllele(territory); - return this; - } - - private ExtraBeesSpecies setFlowering(EnumAllele.Flowering flowering) { - template[EnumBeeChromosome.FLOWERING.ordinal()] = AlleleHelper.getAllele(flowering); - return this; - } - - private ExtraBeesSpecies setHumidityTolerance(EnumTolerance humidityTolerance) { - template[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = AlleleHelper.getAllele(humidityTolerance); - return this; - } - - private ExtraBeesSpecies setTemperatureTolerance(EnumTolerance temperatureTolerance) { - template[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = AlleleHelper.getAllele(temperatureTolerance); - return this; - } - - @Override - public float getResearchSuitability(ItemStack itemstack) { - if (itemstack == null) { - return 0.0f; - } - - for (ItemStack stack : products.keySet()) { - if (stack.isItemEqual(itemstack)) { - return 1.0f; - } - } - - for (ItemStack stack : specialties.keySet()) { - if (stack.isItemEqual(itemstack)) { - return 1.0f; - } - } - - if (itemstack.getItem() == Items.glass_bottle) { - return 0.9f; - } - if (itemstack.getItem() == Mods.Forestry.item("honeyDrop")) { - return 0.5f; - } - if (itemstack.getItem() == Mods.Forestry.item("honeydew")) { - return 0.7f; - } - if (itemstack.getItem() == Mods.Forestry.item("beeComb")) { - return 0.4f; - } - if (AlleleManager.alleleRegistry.isIndividual(itemstack)) { - return 1.0f; - } - - for (Map.Entry entry : getRoot().getResearchCatalysts().entrySet()) { - if (entry.getKey().isItemEqual(itemstack)) { - return entry.getValue(); - } - } - return 0.0f; - } - - @Override - public ItemStack[] getResearchBounty(World world, GameProfile researcher, IIndividual individual, int bountyLevel) { - ArrayList bounty = new ArrayList(); - ItemStack research = null; - if (world.rand.nextFloat() < 10.0f / bountyLevel) { - Collection combinations = getRoot().getCombinations(this); - if (combinations.size() > 0) { - IMutation[] candidates = combinations.toArray(new IMutation[0]); - research = AlleleManager.alleleRegistry.getMutationNoteStack(researcher, candidates[world.rand.nextInt(candidates.length)]); - } - } - - if (research != null) { - bounty.add(research); - } - - if (bountyLevel > 10) { - for (ItemStack stack : specialties.keySet()) { - ItemStack stack2 = stack.copy(); - stack2.stackSize = world.rand.nextInt((int) (bountyLevel / 2.0f)) + 1; - bounty.add(stack2); - } - } - - for (ItemStack stack : products.keySet()) { - ItemStack stack2 = stack.copy(); - stack2.stackSize = world.rand.nextInt((int) (bountyLevel / 2.0f)) + 1; - bounty.add(stack2); - } - return bounty.toArray(new ItemStack[0]); - } - - @Override - public String getEntityTexture() { - return "/gfx/forestry/entities/bees/honeyBee.png"; - } - - @Override - public int getComplexity() { - return 1 + getGeneticAdvancement(this, new ArrayList<>()); - } - - private int getGeneticAdvancement(IAllele species, ArrayList exclude) { - int own = 1; - int highest = 0; - exclude.add(species); - - for (IMutation mutation : getRoot().getPaths(species, EnumBeeChromosome.SPECIES)) { - if (!exclude.contains(mutation.getAllele0())) { - int otherAdvance = getGeneticAdvancement(mutation.getAllele0(), exclude); - if (otherAdvance > highest) { - highest = otherAdvance; - } - } - if (!exclude.contains(mutation.getAllele1())) { - int otherAdvance = getGeneticAdvancement(mutation.getAllele1(), exclude); - if (otherAdvance <= highest) { - continue; - } - highest = otherAdvance; - } - } - return own + ((highest < 0) ? 0 : highest); - } - - @Override - public String getUnlocalizedName() { - return getUID(); - } - - @Override - public Map getProductChances() { - return getProducts(); - } - - @Override - public Map getSpecialtyChances() { - return getSpecialty(); - } -} diff --git a/src/main/java/binnie/extrabees/genetics/ModuleGenetics.java b/src/main/java/binnie/extrabees/genetics/ModuleGenetics.java index 8e0a8ca9..8b969f28 100644 --- a/src/main/java/binnie/extrabees/genetics/ModuleGenetics.java +++ b/src/main/java/binnie/extrabees/genetics/ModuleGenetics.java @@ -1,19 +1,13 @@ package binnie.extrabees.genetics; import binnie.Binnie; -import binnie.core.BinnieCore; import binnie.core.IInitializable; import binnie.extrabees.ExtraBees; import binnie.extrabees.genetics.effect.BlockEctoplasm; import binnie.extrabees.genetics.effect.ExtraBeesEffect; import binnie.extrabees.genetics.items.ItemDictionary; import cpw.mods.fml.common.registry.GameRegistry; -import forestry.api.apiculture.EnumBeeType; import forestry.api.apiculture.IAlleleBeeSpecies; -import forestry.api.apiculture.IBee; -import forestry.api.apiculture.IBeeGenome; -import forestry.api.genetics.AlleleManager; -import forestry.api.genetics.IAllele; import forestry.api.genetics.IGenome; import forestry.api.recipes.RecipeManagers; import net.minecraft.init.Blocks; @@ -25,50 +19,23 @@ public class ModuleGenetics implements IInitializable { return Binnie.Genetics.getBeeRoot().templateAsGenome(Binnie.Genetics.getBeeRoot().getTemplate(allele0.getUID())); } - // TODO unsused method? - public static ItemStack getBeeIcon(IAlleleBeeSpecies species) { - if (species == null) { - return null; - } - IAllele[] template = Binnie.Genetics.getBeeRoot().getTemplate(species.getUID()); - if (template == null) { - return null; - } - IBeeGenome genome = Binnie.Genetics.getBeeRoot().templateAsGenome(template); - IBee bee = Binnie.Genetics.getBeeRoot().getBee(BinnieCore.proxy.getWorld(), genome); - ItemStack item = Binnie.Genetics.getBeeRoot().getMemberStack(bee, EnumBeeType.PRINCESS.ordinal()); - return item; - } - @Override public void preInit() { - for (ExtraBeesSpecies species : ExtraBeesSpecies.values()) { - AlleleManager.alleleRegistry.registerAllele(species); - } ExtraBees.dictionary = new ItemDictionary(); - GameRegistry.registerBlock(ExtraBees.ectoplasm = new BlockEctoplasm(), "ectoplasm"); + + ExtraBees.ectoplasm = new BlockEctoplasm(); + GameRegistry.registerBlock(ExtraBees.ectoplasm, "ectoplasm"); } @Override public void init() { ExtraBeesEffect.doInit(); ExtraBeesFlowers.doInit(); - ExtraBeesSpecies.doInit(); - ExtraBeeMutation.doInit(); - ExtraBeesBranch.doInit(); + ExtraBeeDefinition.initBees(); } @Override public void postInit() { - // unused code? - /*int ebSpeciesCount = 0; - int ebTotalSpeciesCount = 0; - for (ExtraBeesSpecies species : ExtraBeesSpecies.values()) { - ++ebTotalSpeciesCount; - if (!AlleleManager.alleleRegistry.isBlacklisted(species.getUID())) { - ++ebSpeciesCount; - } - }*/ RecipeManagers.carpenterManager.addRecipe( 100, Binnie.Liquid.getLiquidStack("water", 2000), diff --git a/src/main/java/binnie/extrabees/genetics/effect/ExtraBeesEffect.java b/src/main/java/binnie/extrabees/genetics/effect/ExtraBeesEffect.java index 2b1f7c80..5f0de4f4 100644 --- a/src/main/java/binnie/extrabees/genetics/effect/ExtraBeesEffect.java +++ b/src/main/java/binnie/extrabees/genetics/effect/ExtraBeesEffect.java @@ -62,7 +62,7 @@ public enum ExtraBeesEffect implements IAlleleBeeEffect { BONEMEAL_SAPLING, BONEMEAL_FRUIT, BONEMEAL_MUSHROOM, - Power; + POWER; protected static List birthdays; @@ -302,7 +302,7 @@ public enum ExtraBeesEffect implements IAlleleBeeEffect { onBonemealMushroomEffect(world, x, y, z); break; - case Power: + case POWER: onPowerEffect(world, x, y, z); break; } diff --git a/src/main/java/binnie/extrabees/genetics/requirements/DummyMutationCondition.java b/src/main/java/binnie/extrabees/genetics/requirements/DummyMutationCondition.java new file mode 100644 index 00000000..e4bfdf11 --- /dev/null +++ b/src/main/java/binnie/extrabees/genetics/requirements/DummyMutationCondition.java @@ -0,0 +1,25 @@ +package binnie.extrabees.genetics.requirements; + + +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IGenome; +import forestry.api.genetics.IMutationCondition; +import net.minecraft.world.World; + +public class DummyMutationCondition implements IMutationCondition { + private final RequirementPerson requirement; + + public DummyMutationCondition(RequirementPerson requirement) { + this.requirement = requirement; + } + + @Override + public float getChance(World world, int i, int i1, int i2, IAllele iAllele, IAllele iAllele1, IGenome iGenome, IGenome iGenome1) { + return 1.0F; + } + + @Override + public String getDescription() { + return requirement.getDescription(); + } +} diff --git a/src/main/java/binnie/extrabees/genetics/requirements/IMutationRequirement.java b/src/main/java/binnie/extrabees/genetics/requirements/IMutationRequirement.java new file mode 100644 index 00000000..9e377efc --- /dev/null +++ b/src/main/java/binnie/extrabees/genetics/requirements/IMutationRequirement.java @@ -0,0 +1,11 @@ +package binnie.extrabees.genetics.requirements; + +import forestry.api.apiculture.IBeeHousing; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IGenome; + +public interface IMutationRequirement { + String getDescription(); + + boolean fufilled(IBeeHousing housing, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1); +} diff --git a/src/main/java/binnie/extrabees/genetics/requirements/RequirementPerson.java b/src/main/java/binnie/extrabees/genetics/requirements/RequirementPerson.java new file mode 100644 index 00000000..871a3f8c --- /dev/null +++ b/src/main/java/binnie/extrabees/genetics/requirements/RequirementPerson.java @@ -0,0 +1,24 @@ +package binnie.extrabees.genetics.requirements; + +import forestry.api.apiculture.IBeeHousing; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IGenome; + +public class RequirementPerson implements IMutationRequirement { + protected String name; + + public RequirementPerson(String name) { + this.name = name; + } + + @Override + public String getDescription() { + return "Can only be bred by " + name; + } + + @Override + public boolean fufilled(IBeeHousing housing, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1) { + String ownerName = housing.getOwner().getName(); + return ownerName != null && ownerName.equals(name); + } +} diff --git a/src/main/java/binnie/extrabees/gui/database/ControlProductsBox.java b/src/main/java/binnie/extrabees/gui/database/ControlProductsBox.java index 83cea4b0..a3276a1c 100644 --- a/src/main/java/binnie/extrabees/gui/database/ControlProductsBox.java +++ b/src/main/java/binnie/extrabees/gui/database/ControlProductsBox.java @@ -16,7 +16,6 @@ import java.util.Map; public class ControlProductsBox extends ControlListBox { protected IAlleleBeeSpecies species; - private int index; private Type type; public ControlProductsBox(IWidget parent, int x, int y, int width, int height, Type type) { diff --git a/src/main/java/binnie/extrabees/gui/database/ControlProductsItem.java b/src/main/java/binnie/extrabees/gui/database/ControlProductsItem.java index 8189acd4..f241c11c 100644 --- a/src/main/java/binnie/extrabees/gui/database/ControlProductsItem.java +++ b/src/main/java/binnie/extrabees/gui/database/ControlProductsItem.java @@ -24,7 +24,7 @@ public class ControlProductsItem extends ControlOption further = system.getFurtherMutations(speciesCurrent); if (ind instanceof IBee) { ItemStack hive = null; - if (ind.getGenome().getPrimary() == ExtraBeesSpecies.WATER) { + if (ind.getGenome().getPrimary() == ExtraBeeDefinition.WATER) { hive = new ItemStack(ExtraBees.hive, 1, 0); } - if (ind.getGenome().getPrimary() == ExtraBeesSpecies.ROCK) { + if (ind.getGenome().getPrimary() == ExtraBeeDefinition.ROCK) { hive = new ItemStack(ExtraBees.hive, 1, 1); } - if (ind.getGenome().getPrimary() == ExtraBeesSpecies.BASALT) { + if (ind.getGenome().getPrimary() == ExtraBeeDefinition.BASALT) { hive = new ItemStack(ExtraBees.hive, 1, 2); } - if (ind.getGenome().getPrimary() == ForestryAllele.BeeSpecies.Forest.getAllele()) { + if (ind.getGenome().getPrimary() == BeeDefinition.FOREST.getGenome().getPrimary()) { hive = new ItemStack(Mods.Forestry.block("beehives"), 1, 1); } - if (ind.getGenome().getPrimary() == ForestryAllele.BeeSpecies.Meadows.getAllele()) { + if (ind.getGenome().getPrimary() == BeeDefinition.MEADOWS.getGenome().getPrimary()) { hive = new ItemStack(Mods.Forestry.block("beehives"), 1, 2); } - if (ind.getGenome().getPrimary() == ForestryAllele.BeeSpecies.Modest.getAllele()) { + if (ind.getGenome().getPrimary() == BeeDefinition.MODEST.getGenome().getPrimary()) { hive = new ItemStack(Mods.Forestry.block("beehives"), 1, 3); } - if (ind.getGenome().getPrimary() == ForestryAllele.BeeSpecies.Tropical.getAllele()) { + if (ind.getGenome().getPrimary() == BeeDefinition.TROPICAL.getGenome().getPrimary()) { hive = new ItemStack(Mods.Forestry.block("beehives"), 1, 4); } - if (ind.getGenome().getPrimary() == ForestryAllele.BeeSpecies.Ended.getAllele()) { + if (ind.getGenome().getPrimary() == BeeDefinition.ENDED.getGenome().getPrimary()) { hive = new ItemStack(Mods.Forestry.block("beehives"), 1, 5); } - if (ind.getGenome().getPrimary() == ForestryAllele.BeeSpecies.Wintry.getAllele()) { + if (ind.getGenome().getPrimary() == BeeDefinition.WINTRY.getGenome().getPrimary()) { hive = new ItemStack(Mods.Forestry.block("beehives"), 1, 6); } - if (ind.getGenome().getPrimary() == ForestryAllele.BeeSpecies.Marshy.getAllele()) { + if (ind.getGenome().getPrimary() == BeeDefinition.MARSHY.getGenome().getPrimary()) { hive = new ItemStack(Mods.Forestry.block("beehives"), 1, 7); } - if (ind.getGenome().getPrimary() == ForestryAllele.BeeSpecies.Steadfast.getAllele()) { + if (ind.getGenome().getPrimary() == BeeDefinition.STEADFAST.getGenome().getPrimary()) { hive = new ItemStack(Blocks.chest); } - if (ind.getGenome().getPrimary() == ForestryAllele.BeeSpecies.Valiant.getAllele()) { + if (ind.getGenome().getPrimary() == BeeDefinition.VALIANT.getGenome().getPrimary()) { new ControlTextCentered(this, y, "Natural Habitat").setColor(getColor()); y += 10; new ControlTextCentered(this, y, EnumChatFormatting.ITALIC + "Found in any Hive").setColor(getColor()); y += 22; - } else if (ind.getGenome().getPrimary() == ForestryAllele.BeeSpecies.Monastic.getAllele()) { + } else if (ind.getGenome().getPrimary() == BeeDefinition.MONASTIC.getGenome().getPrimary()) { new ControlTextCentered(this, y, "Natural Habitat").setColor(getColor()); y += 10; new ControlTextCentered(this, y, EnumChatFormatting.ITALIC + "Bought from Villagers").setColor(getColor()); @@ -91,7 +91,7 @@ public class AnalystPageMutations extends ControlAnalystPage { new ControlTextCentered(this, y, "Natural Habitat").setColor(getColor()); y += 10; ControlItemDisplay display = new ControlItemDisplay(this, (w() - 16.0f) / 2.0f, y); - if (ind.getGenome().getPrimary() == ForestryAllele.BeeSpecies.Steadfast.getAllele()) { + if (ind.getGenome().getPrimary() == BeeDefinition.STEADFAST.getGenome().getPrimary()) { display.addTooltip("Dungeon Chests"); } else { display.setTooltip();