diff --git a/src/main/java/binnie/core/integration/extrabees/ExtraBeesIntegration.java b/src/main/java/binnie/core/integration/extrabees/ExtraBeesIntegration.java index fd62bdfe..78dd2991 100644 --- a/src/main/java/binnie/core/integration/extrabees/ExtraBeesIntegration.java +++ b/src/main/java/binnie/core/integration/extrabees/ExtraBeesIntegration.java @@ -17,7 +17,7 @@ import binnie.core.IInitializable; public class ExtraBeesIntegration implements IInitializable { private static final boolean loaded; - public static IAlleleBeeSpecies water, rock, basalt; + public static IAlleleBeeSpecies water, rock, basalt, marble; public static Block hive; public static Item dictionary; @@ -36,16 +36,16 @@ public class ExtraBeesIntegration implements IInitializable { @Override public void init() { - water = getExtraBeesSpecies("water"); - rock = getExtraBeesSpecies("rock"); - basalt = getExtraBeesSpecies("basalt"); hive = Preconditions.checkNotNull(ForgeRegistries.BLOCKS.getValue(new ResourceLocation("extrabees", "hive"))); dictionary = Preconditions.checkNotNull(ForgeRegistries.ITEMS.getValue(new ResourceLocation("genetics", "dictionary"))); } @Override public void postInit() { - + water = getExtraBeesSpecies("water"); + rock = getExtraBeesSpecies("rock"); + basalt = getExtraBeesSpecies("basalt"); + marble = getExtraBeesSpecies("marble"); } private IAlleleBeeSpecies getExtraBeesSpecies(String species) { diff --git a/src/main/java/binnie/extrabees/ExtraBees.java b/src/main/java/binnie/extrabees/ExtraBees.java index 70f1c39d..15a8c48d 100644 --- a/src/main/java/binnie/extrabees/ExtraBees.java +++ b/src/main/java/binnie/extrabees/ExtraBees.java @@ -24,7 +24,6 @@ import net.minecraftforge.fml.common.registry.GameRegistry; import forestry.api.apiculture.BeeManager; import forestry.api.apiculture.IAlleleBeeSpecies; -import forestry.api.genetics.AlleleManager; import forestry.api.genetics.AlleleSpeciesRegisterEvent; import forestry.core.gui.GuiIdRegistry; import forestry.core.gui.GuiType; @@ -32,10 +31,8 @@ import forestry.core.proxy.Proxies; import binnie.Constants; import binnie.extrabees.alveary.TileEntityExtraBeesAlvearyPart; -import binnie.extrabees.genetics.ExtraBeeMutation; -import binnie.extrabees.genetics.ExtraBeesBranch; +import binnie.extrabees.genetics.ExtraBeeDefinition; import binnie.extrabees.genetics.ExtraBeesFlowers; -import binnie.extrabees.genetics.ExtraBeesSpecies; import binnie.extrabees.genetics.effect.ExtraBeesEffect; import binnie.extrabees.init.BlockRegister; import binnie.extrabees.init.ItemRegister; @@ -110,8 +107,7 @@ public class ExtraBees { GameRegistry.registerWorldGenerator(extraBeesWorldGenerator, 0); ExtraBeesEffect.doInit(); ExtraBeesFlowers.doInit(); - ExtraBeesSpecies.doInit(); - ExtraBeeMutation.doInit(); + ExtraBeeDefinition.doInit(); } @Mod.EventHandler @@ -136,9 +132,6 @@ public class ExtraBees { if(event.getRoot() != BeeManager.beeRoot){ return; } - ExtraBeesBranch.setSpeciesBranches(); - for (final ExtraBeesSpecies species : ExtraBeesSpecies.values()) { - AlleleManager.alleleRegistry.registerAllele(species); - } + ExtraBeeDefinition.doPreInit(); } } diff --git a/src/main/java/binnie/extrabees/genetics/ConditionPerson.java b/src/main/java/binnie/extrabees/genetics/ConditionPerson.java new file mode 100644 index 00000000..7ea54878 --- /dev/null +++ b/src/main/java/binnie/extrabees/genetics/ConditionPerson.java @@ -0,0 +1,37 @@ +package binnie.extrabees.genetics; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +import forestry.api.apiculture.IBeeHousing; +import forestry.api.climate.IClimateProvider; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IGenome; +import forestry.api.genetics.IMutationCondition; + +public class ConditionPerson implements IMutationCondition { + + String name; + + public ConditionPerson(final String name) { + this.name = name; + } + + @Override + public String getDescription() { + return "Can only be bred by " + this.name; + } + + @Override + public float getChance(World world, BlockPos pos, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1, IClimateProvider climate) { + TileEntity tileEnity = world.getTileEntity(pos); + if (tileEnity instanceof IBeeHousing) { + IBeeHousing housing = (IBeeHousing) tileEnity; + if (housing.getOwner() != null && housing.getOwner().getName() != null && housing.getOwner().getName().equals(this.name)) { + return 1; + } + } + return 0; + } +} 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..44c8f133 --- /dev/null +++ b/src/main/java/binnie/extrabees/genetics/ExtraBeeBranchDefinition.java @@ -0,0 +1,329 @@ +package binnie.extrabees.genetics; + +import java.util.Arrays; +import java.util.Locale; + +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.AlleleEffects; +import forestry.core.genetics.IBranchDefinition; +import forestry.core.genetics.alleles.EnumAllele; + +import binnie.extrabees.genetics.effect.ExtraBeesEffect; +import binnie.genetics.genetics.AlleleHelper; + +@SuppressWarnings("Duplicates") +public enum ExtraBeeBranchDefinition implements IBranchDefinition { + BARREN("Vacapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.DOWN_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.DEAD.getUID())); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + } + }, + HOSTILE("Infenapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.DOWN_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TOLERATES_RAIN, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.DEAD.getUID())); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + } + }, + ROCKY("Monapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TOLERATES_RAIN, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + } + }, + METALLIC("Lamminapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TOLERATES_RAIN, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + } + }, + METALLIC2("Metalapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TOLERATES_RAIN, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + } + }, + ALLOY("Allapis"), + PRECIOUS("Pluriapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TOLERATES_RAIN, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + } + }, + MINERAL("Niphapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TOLERATES_RAIN, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + } + }, + GEMSTONE("Gemmapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TOLERATES_RAIN, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + } + }, + NUCLEAR("Levapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TOLERATES_RAIN, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.ROCK.getUID())); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTEST); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.RADIOACTIVE.getUID())); + } + }, + HISTORIC("Priscapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.ELONGATED); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOW); + } + }, + FOSSILIZED("Fosiapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.NORMAL); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOW); + } + }, + REFINED("Petrapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.NORMAL); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOW); + } + }, + AQUATIC("Aquapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TOLERATES_RAIN, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOWEST); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.BOTH_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.WATER.getUID())); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.WATER.getUID())); + } + }, + SACCHARINE("Sacchapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.SUGAR.getUID())); + } + }, + CLASSICAL("Grecapis"){ + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOW); + } + }, + VOLCANIC("Irrapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.NORMAL); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.METEOR.getUID())); + } + }, + VIRULENT("Virapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.JUNGLE); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleEffects.effectMiasmic); + } + }, + VISCOUS("Viscapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.JUNGLE); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.ECTOPLASM.getUID())); + } + }, + CAUSTIC("Morbapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.JUNGLE); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.FAST); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.AVERAGE); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.ACID.getUID())); + } + }, + ENERGETIC("Incitapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.CAVE_DWELLING, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.REDSTONE.getUID())); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.LIGHTNING.getUID())); + } + }, + FARMING("Agriapis"), + SHADOW("Pullapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.NORMAL); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.BLINDNESS.getUID())); + } + }, + PRIMARY("Primapis"), + SECONDARY("Secapis"), + TERTIARY("Tertiapis"), + FTB("Eftebeapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.NORMAL); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleEffects.effectBeatific); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.MAXIMUM); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.MAXIMUM); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TERRITORY, EnumAllele.Territory.LARGEST); + } + }, + QUANTUM("Quantapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.LONGER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.UP_1); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TERRITORY, EnumAllele.Territory.LARGE); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.END); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleHelper.getAllele(ExtraBeesEffect.GRAVITY.getUID())); + } + }, + BOTANIA("Botaniapis") { + @Override + protected void setBranchProperties(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.MYSTICAL.getUID())); + } + }; + + private static IAllele[] defaultTemplate; + + 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[] getDefaultTemplate() { + if (defaultTemplate == null) { + defaultTemplate = new IAllele[EnumBeeChromosome.values().length]; + + AlleleHelper.getInstance().set(defaultTemplate, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWEST); + AlleleHelper.getInstance().set(defaultTemplate, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTER); + AlleleHelper.getInstance().set(defaultTemplate, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.NORMAL); + AlleleHelper.getInstance().set(defaultTemplate, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.NONE); + AlleleHelper.getInstance().set(defaultTemplate, EnumBeeChromosome.NEVER_SLEEPS, false); + AlleleHelper.getInstance().set(defaultTemplate, EnumBeeChromosome.HUMIDITY_TOLERANCE, EnumAllele.Tolerance.NONE); + AlleleHelper.getInstance().set(defaultTemplate, EnumBeeChromosome.TOLERATES_RAIN, false); + AlleleHelper.getInstance().set(defaultTemplate, EnumBeeChromosome.CAVE_DWELLING, false); + AlleleHelper.getInstance().set(defaultTemplate, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.VANILLA); + AlleleHelper.getInstance().set(defaultTemplate, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.SLOWEST); + AlleleHelper.getInstance().set(defaultTemplate, EnumBeeChromosome.TERRITORY, EnumAllele.Territory.AVERAGE); + AlleleHelper.getInstance().set(defaultTemplate, EnumBeeChromosome.EFFECT, AlleleEffects.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..738d7ce3 --- /dev/null +++ b/src/main/java/binnie/extrabees/genetics/ExtraBeeDefinition.java @@ -0,0 +1,1971 @@ +package binnie.extrabees.genetics; + +import com.google.common.base.Preconditions; + +import java.awt.Color; +import java.util.Arrays; +import java.util.Locale; +import java.util.Map; + +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import net.minecraftforge.common.BiomeDictionary; + +import forestry.api.apiculture.BeeManager; +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.apiculture.EnumBeeType; +import forestry.api.apiculture.IAlleleBeeSpecies; +import forestry.api.apiculture.IAlleleBeeSpeciesBuilder; +import forestry.api.apiculture.IBee; +import forestry.api.apiculture.IBeeGenome; +import forestry.api.apiculture.IBeeMutationBuilder; +import forestry.api.core.EnumHumidity; +import forestry.api.core.EnumTemperature; +import forestry.api.genetics.IAllele; +import forestry.apiculture.PluginApiculture; +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.AlleleEffects; +import forestry.core.genetics.IBranchDefinition; +import forestry.core.genetics.alleles.EnumAllele; + +import binnie.extrabees.genetics.effect.ExtraBeesEffect; +import binnie.extrabees.items.ItemHoneyComb; +import binnie.extrabees.items.types.EnumHoneyComb; +import binnie.genetics.genetics.AlleleHelper; + +public enum ExtraBeeDefinition implements IBeeDefinition { + /* BARREN BRANCH */ + ARID(ExtraBeeBranchDefinition.BARREN, "aridus", true, new Color(0xbee854), new Color(0xcbe374)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.30f) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.30f) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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.getInstance().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(IAlleleBeeSpeciesBuilder 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.getInstance().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(IAlleleBeeSpeciesBuilder 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.getInstance().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(IAlleleBeeSpeciesBuilder 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.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.STONE.get(1), 0.30f); + } + + @Override + protected boolean isSecret() { + return false; + } + }, + STONE(ExtraBeeBranchDefinition.ROCKY, "lapis", false, new Color(0x757575), new Color(0x999999)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.STONE.get(1), 0.30f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.STONE.get(1), 0.30f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.BOTH_2); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.YELLORIUM.get(1), 0.02f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTEST); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.CYANITE.get(1), 0.01f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTEST); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.BARREN.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.BLUTONIUM.get(1), 0.01f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.LOW); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTEST); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.OLD.get(1), 0.30f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(EnumHoneyComb.OLD.get(1), 0.30f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.LONGER); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.OLD.get(1), 0.30f) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.WATER.get(1), 0.30f) + .setHumidity(EnumHumidity.DAMP); + } + + @Override + protected boolean isSecret() { + return false; + } + }, + RIVER(ExtraBeeBranchDefinition.AQUATIC, "flumen", true, new Color(0x83b3d4), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.35f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.HIGH); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.AVERAGE); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.35f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.HIGH); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.FAST); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.35f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.HIGH); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWERING, EnumAllele.Flowering.FASTEST); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, AlleleHelper.getAllele(ExtraBeesFlowers.SAPLING.getUID())); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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.getInstance().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(IAlleleBeeSpeciesBuilder 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.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.WHEATEN.get(), 0.30f) + .addSpecialty(EnumHoneyComb.ALCOHOL.get(1), 0.10f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.MOSSY.get(), 0.30f) + .setHumidity(EnumHumidity.DAMP); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.MOSSY.get(), 0.30f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.MOSSY.get(), 0.30f) + .addSpecialty(EnumHoneyComb.FUNGAL.get(1), 0.15f) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().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(ExtraBeeBranchDefinition.CLASSICAL, "marbla", true, new Color(0xd6c9cf), new Color(0xffdc16)){ + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f); + } + + @Override + protected boolean isSecret() { + return false; + } + }, + ROMAN(ExtraBeeBranchDefinition.CLASSICAL, "roman", true, new Color(0xad8bb0), new Color(0xffdc16)){ + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f); + } + + @Override + protected void registerMutations() { + registerMutation(ExtraBeeDefinition.MARBLE, BeeDefinition.HEROIC, 10); + } + }, + GREEK(ExtraBeeBranchDefinition.CLASSICAL, "greco", false, new Color(0x854c8a), new Color(0xffdc16)){ + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f); + } + + @Override + protected void registerMutations() { + registerMutation(ExtraBeeDefinition.ROMAN, ExtraBeeDefinition.MARBLE, 8); + } + }, + CLASSICAL(ExtraBeeBranchDefinition.CLASSICAL, "classica", false, new Color(0x831d8c), new Color(0xffdc16)){ + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f) + .addSpecialty(PluginApiculture.getItems().royalJelly.getItemStack(), 0.25f) + .setHasEffect(); + } + + @Override + protected void registerMutations() { + registerMutation(ExtraBeeDefinition.GREEK, ExtraBeeDefinition.ROMAN, 8); + } + }, + + /* VOLCANIC BRANCH */ + BASALT(ExtraBeeBranchDefinition.VOLCANIC, "aceri", true, new Color(0x8c6969), new Color(0x9a2323)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SIMMERING.get(), 0.25f) + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleEffects.effectAggressive); + } + + @Override + protected boolean isSecret() { + return false; + } + }, + TEMPERED(ExtraBeeBranchDefinition.VOLCANIC, "iratus", false, new Color(0x8a4848), new Color(0x9a2323)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.GLOWSTONE.get(1), 0.15f) + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleEffects.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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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.getInstance().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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f) + .setHumidity(EnumHumidity.DAMP) + .setTemperature(EnumTemperature.WARM); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f) + .addSpecialty(EnumHoneyComb.SLIME.get(1), 0.12f) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.REDSTONE.get(1), 0.20f) + .addSpecialty(EnumHoneyComb.IC2ENERGY.get(1), 0.08f) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.FROZEN.get(), 0.25f) + .setTemperature(EnumTemperature.ICY); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORT); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.SHADOW.get(1), 0.25f) + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID) + .setHasEffect(); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies.setTemperature(EnumTemperature.ICY); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, true); + AlleleHelper.getInstance().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(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f) + .addSpecialty(new ItemStack(PluginApiculture.getItems().pollenCluster), 0.20f) + .addSpecialty(EnumHoneyComb.PURPLE.get(1), 0.15f) + .setIsNotCounted() + .setHasEffect(); + } + + @Override + protected void registerMutations() { + registerMutation(BeeDefinition.ENDED, RELIC, 2) + .addMutationCondition(new ConditionPerson("jadedcat")); + } + }, + + /* AUSTERE BRANCH */ + HAZARDOUS(BeeBranchDefinition.AUSTERE, "infensus", true, new Color(0xb06c28), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(IAlleleBeeSpeciesBuilder beeSpecies) { + beeSpecies + .addProduct(EnumHoneyComb.SALTPETER.get(1), 0.12f) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void setAlleles(IAllele[] template) { + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWEST); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.LONGER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.DOWN_2); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleEffects.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(IAlleleBeeSpeciesBuilder 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.getInstance().set(template, EnumBeeChromosome.FERTILITY, EnumAllele.Fertility.NORMAL); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPEED, EnumAllele.Speed.SLOWEST); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.LIFESPAN, EnumAllele.Lifespan.SHORTER); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TEMPERATURE_TOLERANCE, EnumAllele.Tolerance.NONE); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.VANILLA); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.NEVER_SLEEPS, false); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.TERRITORY, EnumAllele.Territory.AVERAGE); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.EFFECT, AlleleEffects.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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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(IAlleleBeeSpeciesBuilder 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 final IBranchDefinition branch; + private final IAlleleBeeSpeciesBuilder speciesBuilder; + + private IAlleleBeeSpecies 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.speciesBuilder = BeeManager.beeFactory.createSpecies(uid, dominant, "Binnie", name, description, branch.getBranch(), binomial, primary.getRGB(), secondary.getRGB()); + } else { + this.speciesBuilder = null; + } + } + + protected void setSpeciesProperties(IAlleleBeeSpeciesBuilder 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 doInit() { + for (ExtraBeeDefinition bee : values()) { + if (bee.isNeedRegister()) { + bee.init(); + } + } + + for (ExtraBeeDefinition bee : values()) { + if (bee.isNeedRegister()) { + 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(ExtraBeeDefinition.WATER, ExtraBeeDefinition.MARBLE, BeeDefinition.COMMON, 15); + registerMutation(ExtraBeeDefinition.ROCK, ExtraBeeDefinition.MARBLE, BeeDefinition.COMMON, 15); + registerMutation(ExtraBeeDefinition.MARBLE, BeeDefinition.FOREST, BeeDefinition.COMMON, 15); + registerMutation(ExtraBeeDefinition.MARBLE, BeeDefinition.MEADOWS, BeeDefinition.COMMON, 15); + registerMutation(ExtraBeeDefinition.MARBLE, BeeDefinition.MODEST, BeeDefinition.COMMON, 15); + registerMutation(ExtraBeeDefinition.MARBLE, BeeDefinition.TROPICAL, BeeDefinition.COMMON, 15); + registerMutation(ExtraBeeDefinition.MARBLE, BeeDefinition.MARSHY, BeeDefinition.COMMON, 15); + registerMutation(ExtraBeeDefinition.MARBLE, BeeDefinition.COMMON, 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); + } + + protected boolean isSecret() { + return true; + } + + public static void doPreInit() { + } + + private void init() { + if(isSecret()){ + speciesBuilder.setIsSecret(); + } + setSpeciesProperties(speciesBuilder); + species = speciesBuilder.build(); + + template = branch.getTemplate(); + AlleleHelper.getInstance().set(template, EnumBeeChromosome.SPECIES, species); + setAlleles(template); + + genome = BeeManager.beeRoot.templateAsGenome(template); + BeeManager.beeRoot.registerTemplate(template); + } + + public IBeeMutationBuilder registerMutation(IBeeDefinition allele0, IBeeDefinition allele1, int chance) { + return registerMutation(allele0.getGenome().getPrimary(), allele1.getGenome().getPrimary(), getTemplate(), chance); + } + + public static IBeeMutationBuilder registerMutation(IBeeDefinition allele0, IBeeDefinition allele1, IBeeDefinition mutation, int chance) { + return registerMutation(allele0.getGenome().getPrimary(), allele1.getGenome().getPrimary(), mutation.getTemplate(), chance); + } + + public static IBeeMutationBuilder registerMutation(IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, IAllele[] template, int chance) { + Preconditions.checkNotNull(allele0); + Preconditions.checkNotNull(allele1); + Preconditions.checkNotNull(template); + return BeeManager.beeMutationFactory.createMutation(allele0, allele1, template, chance); + } + + @Override + public final IAllele[] getTemplate() { + return Arrays.copyOf(template, template.length); + } + + @Override + public final IBeeGenome getGenome() { + return genome; + } + + @Override + public final IBee getIndividual() { + return new Bee(genome); + } + + @Override + public final ItemStack getMemberStack(EnumBeeType beeType) { + IBee bee = getIndividual(); + return BeeManager.beeRoot.getMemberStack(bee, beeType); + } +} diff --git a/src/main/java/binnie/extrabees/genetics/ExtraBeeMutation.java b/src/main/java/binnie/extrabees/genetics/ExtraBeeMutation.java deleted file mode 100644 index 61224281..00000000 --- a/src/main/java/binnie/extrabees/genetics/ExtraBeeMutation.java +++ /dev/null @@ -1,276 +0,0 @@ -package binnie.extrabees.genetics; - -import com.google.common.base.Preconditions; - -import net.minecraft.tileentity.TileEntity; -import net.minecraft.util.math.BlockPos; -import net.minecraft.world.World; - -import net.minecraftforge.common.BiomeDictionary; - -import forestry.api.apiculture.BeeManager; -import forestry.api.apiculture.IAlleleBeeSpecies; -import forestry.api.apiculture.IBeeHousing; -import forestry.api.apiculture.IBeeMutationBuilder; -import forestry.api.climate.IClimateProvider; -import forestry.api.genetics.IAllele; -import forestry.api.genetics.IGenome; -import forestry.api.genetics.IMutationCondition; -import forestry.apiculture.genetics.BeeDefinition; - -import static forestry.apiculture.genetics.BeeDefinition.AUSTERE; -import static forestry.apiculture.genetics.BeeDefinition.BOGGY; -import static forestry.apiculture.genetics.BeeDefinition.COMMON; -import static forestry.apiculture.genetics.BeeDefinition.CULTIVATED; -import static forestry.apiculture.genetics.BeeDefinition.DEMONIC; -import static forestry.apiculture.genetics.BeeDefinition.DILIGENT; -import static forestry.apiculture.genetics.BeeDefinition.ENDED; -import static forestry.apiculture.genetics.BeeDefinition.EXOTIC; -import static forestry.apiculture.genetics.BeeDefinition.FARMERLY; -import static forestry.apiculture.genetics.BeeDefinition.FIENDISH; -import static forestry.apiculture.genetics.BeeDefinition.FOREST; -import static forestry.apiculture.genetics.BeeDefinition.FRUGAL; -import static forestry.apiculture.genetics.BeeDefinition.HERMITIC; -import static forestry.apiculture.genetics.BeeDefinition.HEROIC; -import static forestry.apiculture.genetics.BeeDefinition.IMPERIAL; -import static forestry.apiculture.genetics.BeeDefinition.INDUSTRIOUS; -import static forestry.apiculture.genetics.BeeDefinition.MAJESTIC; -import static forestry.apiculture.genetics.BeeDefinition.MARSHY; -import static forestry.apiculture.genetics.BeeDefinition.MEADOWS; -import static forestry.apiculture.genetics.BeeDefinition.MIRY; -import static forestry.apiculture.genetics.BeeDefinition.MODEST; -import static forestry.apiculture.genetics.BeeDefinition.MONASTIC; -import static forestry.apiculture.genetics.BeeDefinition.NOBLE; -import static forestry.apiculture.genetics.BeeDefinition.RURAL; -import static forestry.apiculture.genetics.BeeDefinition.SECLUDED; -import static forestry.apiculture.genetics.BeeDefinition.SINISTER; -import static forestry.apiculture.genetics.BeeDefinition.SPECTRAL; -import static forestry.apiculture.genetics.BeeDefinition.TROPICAL; -import static forestry.apiculture.genetics.BeeDefinition.UNWEARY; -import static forestry.apiculture.genetics.BeeDefinition.VALIANT; -import static forestry.apiculture.genetics.BeeDefinition.WINTRY; - -public class ExtraBeeMutation { - - public static void doInit() { - registerMutation(MEADOWS, FRUGAL, ExtraBeesSpecies.ARID, 10); - registerMutation(FOREST, FRUGAL, ExtraBeesSpecies.ARID, 10); - registerMutation(ExtraBeesSpecies.ARID, COMMON, ExtraBeesSpecies.BARREN, 8); - registerMutation(ExtraBeesSpecies.ARID, ExtraBeesSpecies.BARREN, ExtraBeesSpecies.DESOLATE, 8); - registerMutation(ExtraBeesSpecies.BARREN, FOREST, ExtraBeesSpecies.GNAWING, 15); - registerMutation(ExtraBeesSpecies.DESOLATE, MEADOWS, ExtraBeesSpecies.ROTTEN, 15); - registerMutation(ExtraBeesSpecies.DESOLATE, FOREST, ExtraBeesSpecies.BONE, 15); - registerMutation(ExtraBeesSpecies.DESOLATE, MODEST, ExtraBeesSpecies.CREEPER, 15); - registerMutation(ExtraBeesSpecies.BARREN, MARSHY, ExtraBeesSpecies.DECOMPOSING, 15); - registerMutation(ExtraBeesSpecies.ROCK, DILIGENT, ExtraBeesSpecies.STONE, 12); - registerMutation(ExtraBeesSpecies.STONE, UNWEARY, ExtraBeesSpecies.GRANITE, 10); - registerMutation(ExtraBeesSpecies.GRANITE, INDUSTRIOUS, ExtraBeesSpecies.MINERAL, 6); - registerMutation(ExtraBeesSpecies.MINERAL, MEADOWS, ExtraBeesSpecies.IRON, 5); - registerMutation(ExtraBeesSpecies.MINERAL, FOREST, ExtraBeesSpecies.IRON, 5); - registerMutation(ExtraBeesSpecies.MINERAL, WINTRY, ExtraBeesSpecies.COPPER, 5); - registerMutation(ExtraBeesSpecies.MINERAL, MODEST, ExtraBeesSpecies.COPPER, 5); - registerMutation(ExtraBeesSpecies.MINERAL, MARSHY, ExtraBeesSpecies.TIN, 5); - registerMutation(ExtraBeesSpecies.MINERAL, TROPICAL, ExtraBeesSpecies.TIN, 5); - registerMutation(ExtraBeesSpecies.MINERAL, MEADOWS, ExtraBeesSpecies.LEAD, 5); - registerMutation(ExtraBeesSpecies.MINERAL, MODEST, ExtraBeesSpecies.LEAD, 5); - registerMutation(ExtraBeesSpecies.MINERAL, WINTRY, ExtraBeesSpecies.ZINC, 5); - registerMutation(ExtraBeesSpecies.MINERAL, TROPICAL, ExtraBeesSpecies.ZINC, 5); - registerMutation(ExtraBeesSpecies.MINERAL, FOREST, ExtraBeesSpecies.NICKEL, 5); - registerMutation(ExtraBeesSpecies.MINERAL, MARSHY, ExtraBeesSpecies.NICKEL, 5); - registerMutation(ExtraBeesSpecies.MINERAL, CULTIVATED, ExtraBeesSpecies.TITANIUM, 3); - registerMutation(ExtraBeesSpecies.MINERAL, COMMON, ExtraBeesSpecies.TUNGSTATE, 3); - registerMutation(ExtraBeesSpecies.ZINC, MAJESTIC, ExtraBeesSpecies.SILVER, 2); - registerMutation(ExtraBeesSpecies.TIN, MAJESTIC, ExtraBeesSpecies.SILVER, 2); - registerMutation(ExtraBeesSpecies.LEAD, MAJESTIC, ExtraBeesSpecies.SILVER, 2); - registerMutation(ExtraBeesSpecies.TITANIUM, MAJESTIC, ExtraBeesSpecies.SILVER, 3); - registerMutation(ExtraBeesSpecies.IRON, MAJESTIC, ExtraBeesSpecies.GOLD, 2); - registerMutation(ExtraBeesSpecies.COPPER, MAJESTIC, ExtraBeesSpecies.GOLD, 2); - registerMutation(ExtraBeesSpecies.NICKEL, MAJESTIC, ExtraBeesSpecies.GOLD, 2); - registerMutation(ExtraBeesSpecies.TUNGSTATE, MAJESTIC, ExtraBeesSpecies.GOLD, 3); - registerMutation(ExtraBeesSpecies.GOLD, ExtraBeesSpecies.SILVER, ExtraBeesSpecies.PLATINUM, 2); - registerMutation(ExtraBeesSpecies.MINERAL, IMPERIAL, ExtraBeesSpecies.LAPIS, 5); - registerMutation(ExtraBeesSpecies.LAPIS, FOREST, ExtraBeesSpecies.EMERALD, 5); - registerMutation(ExtraBeesSpecies.LAPIS, MODEST, ExtraBeesSpecies.RUBY, 5); - registerMutation(ExtraBeesSpecies.LAPIS, ExtraBeesSpecies.WATER, ExtraBeesSpecies.SAPPHIRE, 5); - registerMutation(ExtraBeesSpecies.LAPIS, CULTIVATED, ExtraBeesSpecies.DIAMOND, 5); - registerMutation(ExtraBeesSpecies.PREHISTORIC, ExtraBeesSpecies.MINERAL, ExtraBeesSpecies.UNSTABLE, 5); - registerMutation(ExtraBeesSpecies.UNSTABLE, ExtraBeesSpecies.IRON, ExtraBeesSpecies.NUCLEAR, 5); - registerMutation(ExtraBeesSpecies.UNSTABLE, ExtraBeesSpecies.COPPER, ExtraBeesSpecies.NUCLEAR, 5); - registerMutation(ExtraBeesSpecies.UNSTABLE, ExtraBeesSpecies.TIN, ExtraBeesSpecies.NUCLEAR, 5); - registerMutation(ExtraBeesSpecies.UNSTABLE, ExtraBeesSpecies.ZINC, ExtraBeesSpecies.NUCLEAR, 5); - registerMutation(ExtraBeesSpecies.UNSTABLE, ExtraBeesSpecies.NICKEL, ExtraBeesSpecies.NUCLEAR, 5); - registerMutation(ExtraBeesSpecies.UNSTABLE, ExtraBeesSpecies.LEAD, ExtraBeesSpecies.NUCLEAR, 5); - registerMutation(ExtraBeesSpecies.NUCLEAR, ExtraBeesSpecies.GOLD, ExtraBeesSpecies.RADIOACTIVE, 5); - registerMutation(ExtraBeesSpecies.NUCLEAR, ExtraBeesSpecies.SILVER, ExtraBeesSpecies.RADIOACTIVE, 5); - registerMutation(ExtraBeesSpecies.NUCLEAR, FRUGAL, ExtraBeesSpecies.YELLORIUM, 5); - registerMutation(ExtraBeesSpecies.NUCLEAR, ExtraBeesSpecies.YELLORIUM, ExtraBeesSpecies.CYANITE, 5); - registerMutation(ExtraBeesSpecies.YELLORIUM, ExtraBeesSpecies.CYANITE, ExtraBeesSpecies.BLUTONIUM, 5); - registerMutation(NOBLE, DILIGENT, ExtraBeesSpecies.ANCIENT, 10); - registerMutation(ExtraBeesSpecies.ANCIENT, SECLUDED, ExtraBeesSpecies.PRIMEVAL, 8); - registerMutation(ExtraBeesSpecies.PRIMEVAL, ExtraBeesSpecies.ANCIENT, ExtraBeesSpecies.PREHISTORIC, 8); - registerMutation(ExtraBeesSpecies.PREHISTORIC, IMPERIAL, ExtraBeesSpecies.RELIC, 8); - registerMutation(ExtraBeesSpecies.PRIMEVAL, ExtraBeesSpecies.GROWING, ExtraBeesSpecies.COAL, 8); - registerMutation(ExtraBeesSpecies.PRIMEVAL, RURAL, ExtraBeesSpecies.COAL, 8); - registerMutation(ExtraBeesSpecies.PRIMEVAL, MIRY, ExtraBeesSpecies.RESIN, 8); - registerMutation(ExtraBeesSpecies.PRIMEVAL, ExtraBeesSpecies.OCEAN, ExtraBeesSpecies.OIL, 8); - registerMutation(ExtraBeesSpecies.PRIMEVAL, FRUGAL, ExtraBeesSpecies.OIL, 8); - registerMutation(ExtraBeesSpecies.OIL, INDUSTRIOUS, ExtraBeesSpecies.DISTILLED, 8); - registerMutation(ExtraBeesSpecies.DISTILLED, ExtraBeesSpecies.OIL, ExtraBeesSpecies.FUEL, 8); - registerMutation(ExtraBeesSpecies.DISTILLED, ExtraBeesSpecies.COAL, ExtraBeesSpecies.CREOSOTE, 8); - registerMutation(ExtraBeesSpecies.DISTILLED, ExtraBeesSpecies.RESIN, ExtraBeesSpecies.LATEX, 8); - registerMutation(ExtraBeesSpecies.WATER, DILIGENT, ExtraBeesSpecies.RIVER, 10).restrictBiomeType(BiomeDictionary.Type.RIVER); - registerMutation(ExtraBeesSpecies.WATER, DILIGENT, ExtraBeesSpecies.OCEAN, 10).restrictBiomeType(BiomeDictionary.Type.OCEAN); - registerMutation(ExtraBeesSpecies.BLACK, ExtraBeesSpecies.OCEAN, ExtraBeesSpecies.INK, 8); - registerMutation(FOREST, DILIGENT, ExtraBeesSpecies.GROWING, 10); - registerMutation(ExtraBeesSpecies.GROWING, UNWEARY, ExtraBeesSpecies.THRIVING, 10); - registerMutation(ExtraBeesSpecies.THRIVING, INDUSTRIOUS, ExtraBeesSpecies.BLOOMING, 8); - registerMutation(VALIANT, DILIGENT, ExtraBeesSpecies.SWEET, 15); - registerMutation(ExtraBeesSpecies.SWEET, RURAL, ExtraBeesSpecies.SUGAR, 15); - registerMutation(ExtraBeesSpecies.SWEET, ExtraBeesSpecies.GROWING, ExtraBeesSpecies.RIPENING, 5); - registerMutation(ExtraBeesSpecies.SWEET, ExtraBeesSpecies.THRIVING, ExtraBeesSpecies.FRUIT, 5); - registerMutation(FARMERLY, MEADOWS, ExtraBeesSpecies.ALCOHOL, 10); - registerMutation(FARMERLY, MEADOWS, ExtraBeesSpecies.FARM, 10); - registerMutation(ExtraBeesSpecies.WATER, FARMERLY, ExtraBeesSpecies.MILK, 10); - registerMutation(FARMERLY, TROPICAL, ExtraBeesSpecies.COFFEE, 10); - registerMutation(ExtraBeesSpecies.WATER, MIRY, ExtraBeesSpecies.SWAMP, 10); - registerMutation(ExtraBeesSpecies.SWAMP, BOGGY, ExtraBeesSpecies.BOGGY, 8); - registerMutation(ExtraBeesSpecies.BOGGY, ExtraBeesSpecies.SWAMP, ExtraBeesSpecies.FUNGAL, 8); - registerMutation(BOGGY, MIRY, ExtraBeesSpecies.FUNGAL, 8); - registerMutation(ExtraBeesSpecies.WATER, FOREST, COMMON, 15); - registerMutation(ExtraBeesSpecies.WATER, MEADOWS, COMMON, 15); - registerMutation(ExtraBeesSpecies.WATER, MODEST, COMMON, 15); - registerMutation(ExtraBeesSpecies.WATER, TROPICAL, COMMON, 15); - registerMutation(ExtraBeesSpecies.WATER, MARSHY, COMMON, 15); - registerMutation(ExtraBeesSpecies.WATER, WINTRY, COMMON, 15); - registerMutation(ExtraBeesSpecies.WATER, ExtraBeesSpecies.ROCK, COMMON.getTemplate(), 15); - registerMutation(ExtraBeesSpecies.WATER, ExtraBeesSpecies.BASALT, COMMON.getTemplate(), 15); - registerMutation(ExtraBeesSpecies.ROCK, FOREST, COMMON, 15); - registerMutation(ExtraBeesSpecies.ROCK, MEADOWS, COMMON, 15); - registerMutation(ExtraBeesSpecies.ROCK, MODEST, COMMON, 15); - registerMutation(ExtraBeesSpecies.ROCK, TROPICAL, COMMON, 15); - registerMutation(ExtraBeesSpecies.ROCK, MARSHY, COMMON, 15); - registerMutation(ExtraBeesSpecies.ROCK, WINTRY, COMMON, 15); - registerMutation(ExtraBeesSpecies.ROCK, ExtraBeesSpecies.BASALT, COMMON.getTemplate(), 15); - registerMutation(ExtraBeesSpecies.BASALT, FOREST, COMMON, 15); - registerMutation(ExtraBeesSpecies.BASALT, MEADOWS, COMMON, 15); - registerMutation(ExtraBeesSpecies.BASALT, MODEST, COMMON, 15); - registerMutation(ExtraBeesSpecies.BASALT, TROPICAL, COMMON, 15); - registerMutation(ExtraBeesSpecies.BASALT, MARSHY, COMMON, 15); - registerMutation(ExtraBeesSpecies.BASALT, WINTRY, COMMON, 15); - registerMutation(ExtraBeesSpecies.WATER, COMMON, CULTIVATED, 12); - registerMutation(ExtraBeesSpecies.ROCK, COMMON, CULTIVATED, 12); - registerMutation(ExtraBeesSpecies.BASALT, COMMON, CULTIVATED, 12); - registerMutation(ExtraBeesSpecies.BASALT, FIENDISH, ExtraBeesSpecies.TEMPERED, 30).restrictBiomeType(BiomeDictionary.Type.NETHER); - registerMutation(ExtraBeesSpecies.TEMPERED, DEMONIC, ExtraBeesSpecies.VOLCANIC, 20).restrictBiomeType(BiomeDictionary.Type.NETHER); - registerMutation(ExtraBeesSpecies.BASALT, CULTIVATED, SINISTER, 60).restrictBiomeType(BiomeDictionary.Type.NETHER); - registerMutation(ExtraBeesSpecies.BASALT, SINISTER, FIENDISH, 40).restrictBiomeType(BiomeDictionary.Type.NETHER); - registerMutation(SINISTER, TROPICAL, ExtraBeesSpecies.MALICIOUS, 10); - registerMutation(ExtraBeesSpecies.MALICIOUS, TROPICAL, ExtraBeesSpecies.INFECTIOUS, 8); - registerMutation(ExtraBeesSpecies.MALICIOUS, ExtraBeesSpecies.INFECTIOUS, ExtraBeesSpecies.VIRULENT, 8); - registerMutation(ExtraBeesSpecies.WATER, EXOTIC, ExtraBeesSpecies.VISCOUS, 10); - registerMutation(ExtraBeesSpecies.VISCOUS, EXOTIC, ExtraBeesSpecies.GLUTINOUS, 8); - registerMutation(ExtraBeesSpecies.VISCOUS, ExtraBeesSpecies.GLUTINOUS, ExtraBeesSpecies.STICKY, 8); - registerMutation(ExtraBeesSpecies.MALICIOUS, ExtraBeesSpecies.VISCOUS, ExtraBeesSpecies.CORROSIVE, 10); - registerMutation(ExtraBeesSpecies.CORROSIVE, FIENDISH, ExtraBeesSpecies.CAUSTIC, 8); - registerMutation(ExtraBeesSpecies.CORROSIVE, ExtraBeesSpecies.CAUSTIC, ExtraBeesSpecies.ACIDIC, 4); - registerMutation(CULTIVATED, VALIANT, ExtraBeesSpecies.EXCITED, 10); - registerMutation(ExtraBeesSpecies.EXCITED, DILIGENT, ExtraBeesSpecies.ENERGETIC, 8); - registerMutation(ExtraBeesSpecies.EXCITED, ExtraBeesSpecies.ENERGETIC, ExtraBeesSpecies.ECSTATIC, 8); - registerMutation(WINTRY, DILIGENT, ExtraBeesSpecies.ARTIC, 10); - registerMutation(ExtraBeesSpecies.OCEAN, ExtraBeesSpecies.ARTIC, ExtraBeesSpecies.FREEZING, 10); - registerMutation(ExtraBeesSpecies.ROCK, SINISTER, ExtraBeesSpecies.SHADOW, 10); - registerMutation(ExtraBeesSpecies.SHADOW, ExtraBeesSpecies.ROCK, ExtraBeesSpecies.DARKENED, 8); - registerMutation(ExtraBeesSpecies.SHADOW, ExtraBeesSpecies.DARKENED, ExtraBeesSpecies.ABYSS, 8); - registerMutation(FOREST, VALIANT, ExtraBeesSpecies.RED, 5); - registerMutation(MEADOWS, VALIANT, ExtraBeesSpecies.YELLOW, 5); - registerMutation(ExtraBeesSpecies.WATER, VALIANT, ExtraBeesSpecies.BLUE, 5); - registerMutation(TROPICAL, VALIANT, ExtraBeesSpecies.GREEN, 5); - registerMutation(ExtraBeesSpecies.ROCK, VALIANT, ExtraBeesSpecies.BLACK, 5); - registerMutation(WINTRY, VALIANT, ExtraBeesSpecies.WHITE, 5); - registerMutation(MARSHY, VALIANT, ExtraBeesSpecies.BROWN, 5); - registerMutation(ExtraBeesSpecies.RED, ExtraBeesSpecies.YELLOW, ExtraBeesSpecies.ORANGE, 5); - registerMutation(ExtraBeesSpecies.GREEN, ExtraBeesSpecies.BLUE, ExtraBeesSpecies.CYAN, 5); - registerMutation(ExtraBeesSpecies.RED, ExtraBeesSpecies.BLUE, ExtraBeesSpecies.PURPLE, 5); - registerMutation(ExtraBeesSpecies.BLACK, ExtraBeesSpecies.WHITE, ExtraBeesSpecies.GRAY, 5); - registerMutation(ExtraBeesSpecies.BLUE, ExtraBeesSpecies.WHITE, ExtraBeesSpecies.LIGHTBLUE, 5); - registerMutation(ExtraBeesSpecies.RED, ExtraBeesSpecies.WHITE, ExtraBeesSpecies.PINK, 5); - registerMutation(ExtraBeesSpecies.GREEN, ExtraBeesSpecies.WHITE, ExtraBeesSpecies.LIMEGREEN, 5); - registerMutation(ExtraBeesSpecies.PURPLE, ExtraBeesSpecies.PINK, ExtraBeesSpecies.MAGENTA, 5); - registerMutation(ExtraBeesSpecies.GRAY, ExtraBeesSpecies.WHITE, ExtraBeesSpecies.LIGHTGRAY, 5); - registerMutation(ExtraBeesSpecies.TEMPERED, ExtraBeesSpecies.EXCITED, ExtraBeesSpecies.GLOWSTONE, 5); - registerMutation(ExtraBeesSpecies.DESOLATE, AUSTERE, ExtraBeesSpecies.HAZARDOUS, 5); - registerMutation(ExtraBeesSpecies.RELIC, ENDED, ExtraBeesSpecies.JADED, 2).addMutationCondition(new ConditionPerson("jadedcat")); - registerMutation(ExtraBeesSpecies.EXCITED, AUSTERE, ExtraBeesSpecies.CELEBRATORY, 5); - registerMutation(SECLUDED, ENDED, ExtraBeesSpecies.UNUSUAL, 5); - registerMutation(ExtraBeesSpecies.UNUSUAL, HERMITIC, ExtraBeesSpecies.SPATIAL, 5); - registerMutation(ExtraBeesSpecies.SPATIAL, SPECTRAL, ExtraBeesSpecies.QUANTUM, 5); - registerMutation(NOBLE, MONASTIC, ExtraBeesSpecies.MYSTICAL, 5); - - registerMutation(ExtraBeesSpecies.WATER, ExtraBeesSpecies.MARBLE, COMMON, 15); - registerMutation(ExtraBeesSpecies.ROCK, ExtraBeesSpecies.MARBLE, COMMON, 15); - registerMutation(ExtraBeesSpecies.MARBLE, FOREST, COMMON, 15); - registerMutation(ExtraBeesSpecies.MARBLE, MEADOWS, COMMON, 15); - registerMutation(ExtraBeesSpecies.MARBLE, MODEST, COMMON, 15); - registerMutation(ExtraBeesSpecies.MARBLE, TROPICAL, COMMON, 15); - registerMutation(ExtraBeesSpecies.MARBLE, MARSHY, COMMON, 15); - registerMutation(ExtraBeesSpecies.MARBLE, COMMON, CULTIVATED, 12); - registerMutation(ExtraBeesSpecies.MARBLE, HEROIC, ExtraBeesSpecies.ROMAN, 10); - registerMutation(ExtraBeesSpecies.ROMAN, ExtraBeesSpecies.MARBLE, ExtraBeesSpecies.GREEK, 8); - registerMutation(ExtraBeesSpecies.ROMAN, ExtraBeesSpecies.MARBLE, ExtraBeesSpecies.GREEK, 8); - registerMutation(ExtraBeesSpecies.GREEK, ExtraBeesSpecies.ROMAN, ExtraBeesSpecies.CLASSICAL, 8); - - } - - public static IBeeMutationBuilder registerMutation(BeeDefinition allele0, BeeDefinition allele1, ExtraBeesSpecies mutation, int chance) { - return registerMutation(allele0.getGenome().getPrimary(), allele1.getGenome().getPrimary(), mutation, chance); - } - - public static IBeeMutationBuilder registerMutation(ExtraBeesSpecies allele0, ExtraBeesSpecies allele1, BeeDefinition mutation, int chance) { - return registerMutation(allele0, allele1, mutation.getTemplate(), chance); - } - - public static IBeeMutationBuilder registerMutation(IAlleleBeeSpecies allele0, BeeDefinition allele1, BeeDefinition mutation, int chance) { - return registerMutation(allele0, allele1.getGenome().getPrimary(), mutation.getTemplate(), chance); - } - - public static IBeeMutationBuilder registerMutation(IAlleleBeeSpecies allele0, BeeDefinition allele1, ExtraBeesSpecies mutation, int chance) { - return registerMutation(allele0, allele1.getGenome().getPrimary(), mutation, chance); - } - - public static IBeeMutationBuilder registerMutation(IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, ExtraBeesSpecies mutation, int chance) { - return registerMutation(allele0, allele1, mutation.getTemplate(), chance); - } - - public static IBeeMutationBuilder registerMutation(IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, IAllele[] template, int chance) { - Preconditions.checkNotNull(allele0); - Preconditions.checkNotNull(allele1); - Preconditions.checkNotNull(template); - return BeeManager.beeMutationFactory.createMutation(allele0, allele1, template, chance); - } - - static class ConditionPerson implements IMutationCondition { - - String name; - - public ConditionPerson(final String name) { - this.name = name; - } - - @Override - public String getDescription() { - return "Can only be bred by " + this.name; - } - - @Override - public float getChance(World world, BlockPos pos, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1, IClimateProvider climate) { - TileEntity tileEnity = world.getTileEntity(pos); - if (tileEnity instanceof IBeeHousing) { - IBeeHousing housing = (IBeeHousing) tileEnity; - if (housing.getOwner() != null && housing.getOwner().getName() != null && housing.getOwner().getName().equals(this.name)) { - return 1; - } - } - return 0; - } - } -} 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 d212b377..00000000 --- a/src/main/java/binnie/extrabees/genetics/ExtraBeesBranch.java +++ /dev/null @@ -1,309 +0,0 @@ -package binnie.extrabees.genetics; - -import javax.annotation.Nullable; -import java.util.LinkedHashSet; -import java.util.Set; - -import forestry.api.apiculture.IAlleleBeeSpecies; -import forestry.api.genetics.AlleleManager; -import forestry.api.genetics.IAlleleSpecies; -import forestry.api.genetics.IClassification; - -import binnie.core.util.I18N; - -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"); //TODO There is 1 bee in here, that produces the petal of the flowers around, move to MagicBEes? - - IClassification parent; - private String uid; - private String scientific; - private Set speciesSet; - - ExtraBeesBranch(final String scientific) { - this.uid = ""; - this.scientific = ""; - this.speciesSet = new LinkedHashSet<>(); - this.scientific = scientific; - this.uid = this.toString().toLowerCase(); - } - - public static void setSpeciesBranches() { - final 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); - } - final 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); - } - final 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); - } - final IClassification festiveBranch = AlleleManager.alleleRegistry.getClassification("genus.bees.festive"); - if (festiveBranch != null) { - festiveBranch.addMemberSpecies(ExtraBeesSpecies.CELEBRATORY); - ExtraBeesSpecies.CELEBRATORY.setBranch(festiveBranch); - } - final 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." + this.uid; - } - - @Override - public String getName() { - return I18N.localise("extrabees.branch." + this.toString().toLowerCase() + ".name"); - } - - @Override - public String getScientific() { - return this.scientific; - } - - @Override - public String getDescription() { - return I18N.localise("extrabees.branch." + this.toString().toLowerCase() + ".desc"); - } - - public void register() { - if (!this.speciesSet.isEmpty()) { - AlleleManager.alleleRegistry.registerClassification(this); - final IClassification parent = AlleleManager.alleleRegistry.getClassification("family.apidae"); - if (parent != null) { - parent.addMemberGroup(this); - this.setParent(parent); - } - } - } - - @Override - public IClassification.EnumClassLevel getLevel() { - return IClassification.EnumClassLevel.GENUS; - } - - @Override - @Nullable - public IClassification[] getMemberGroups() { - return null; - } - - @Override - public void addMemberGroup(final IClassification group) { - } - - @Override - public IAlleleSpecies[] getMemberSpecies() { - return this.speciesSet.toArray(new IAlleleSpecies[0]); - } - - @Override - public void addMemberSpecies(final IAlleleSpecies species) { - this.speciesSet.add((IAlleleBeeSpecies) species); - if (species instanceof ExtraBeesSpecies) { - ((ExtraBeesSpecies) species).setBranch(this); - } - } - - @Override - public IClassification getParent() { - return this.parent; - } - - @Override - public void setParent(final IClassification parent) { - this.parent = parent; - } - -} diff --git a/src/main/java/binnie/extrabees/genetics/ExtraBeesFlowers.java b/src/main/java/binnie/extrabees/genetics/ExtraBeesFlowers.java index b16860e4..59f125ec 100644 --- a/src/main/java/binnie/extrabees/genetics/ExtraBeesFlowers.java +++ b/src/main/java/binnie/extrabees/genetics/ExtraBeesFlowers.java @@ -14,21 +14,19 @@ import net.minecraft.world.World; import net.minecraftforge.common.EnumPlantType; +import forestry.api.apiculture.EnumBeeChromosome; import forestry.api.apiculture.FlowerManager; import forestry.api.genetics.AlleleManager; -import forestry.api.genetics.IAllele; import forestry.api.genetics.IAlleleFlowers; import forestry.api.genetics.ICheckPollinatable; -import forestry.api.genetics.IChromosomeType; import forestry.api.genetics.IFlowerProvider; import forestry.api.genetics.IFruitBearer; import forestry.api.genetics.IIndividual; -import forestry.api.genetics.ISpeciesRoot; import binnie.core.util.I18N; import binnie.extrabees.utils.Utils; -public enum ExtraBeesFlowers implements IFlowerProvider, IAlleleFlowers, IChromosomeType { +public enum ExtraBeesFlowers implements IFlowerProvider, IAlleleFlowers { WATER, SUGAR, ROCK, @@ -37,9 +35,9 @@ public enum ExtraBeesFlowers implements IFlowerProvider, IAlleleFlowers, IChromo REDSTONE, WOOD, LEAVES, - Sapling, - Fruit, - Mystical; + SAPLING, + FRUIT, + MYSTICAL; boolean dominant; @@ -80,7 +78,7 @@ public enum ExtraBeesFlowers implements IFlowerProvider, IAlleleFlowers, IChromo FlowerManager.flowerRegistry.registerAcceptableFlower(block, getUID()); } - AlleleManager.alleleRegistry.registerAllele(this, this); + AlleleManager.alleleRegistry.registerAllele(this, EnumBeeChromosome.FLOWER_PROVIDER); } public List getAcceptableBlocks() { @@ -103,13 +101,13 @@ public enum ExtraBeesFlowers implements IFlowerProvider, IAlleleFlowers, IChromo case DEAD: { return Collections.singletonList(Blocks.DEADBUSH); } - case Fruit: { + case FRUIT: { return Collections.emptyList(); // TODO: what is this supposed to be? It was Items.APPLE before. } case LEAVES: { return Collections.singletonList(Blocks.LEAVES); } - case Sapling: { + case SAPLING: { return Collections.singletonList(Blocks.SAPLING); } case WOOD: { @@ -145,16 +143,16 @@ public enum ExtraBeesFlowers implements IFlowerProvider, IAlleleFlowers, IChromo case WOOD: { return block.isWood(world, pos); } - case Fruit: { + case FRUIT: { return world.getTileEntity(pos) instanceof IFruitBearer; } case LEAVES: { return block.isLeaves(world.getBlockState(pos), world, pos); } - case Sapling: { + case SAPLING: { return block.getClass().getName().toLowerCase().contains("sapling"); } - case Mystical: { + case MYSTICAL: { return block == Utils.getBotaniaBlock("flower"); } default: { @@ -198,16 +196,6 @@ public enum ExtraBeesFlowers implements IFlowerProvider, IAlleleFlowers, IChromo return new HashSet(); }*/ - @Override - public Class getAlleleClass() { - return getClass(); - } - - @Override - public ISpeciesRoot getSpeciesRoot() { - return AlleleManager.alleleRegistry.getSpeciesRoot(getUID()); - } - @Override public boolean isAcceptedPollinatable(World world, ICheckPollinatable pollinatable) { return pollinatable.getPlantType() != EnumPlantType.Nether; @@ -215,7 +203,7 @@ public enum ExtraBeesFlowers implements IFlowerProvider, IAlleleFlowers, IChromo @Override public NonNullList affectProducts(World world, IIndividual individual, BlockPos pos, NonNullList products) { - if (this == ExtraBeesFlowers.Mystical) { + if (this == ExtraBeesFlowers.MYSTICAL) { final NonNullList prods = NonNullList.create(); prods.addAll(products); for (int k = 0; k < 50; ++k) { 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 cd0f43f8..00000000 --- a/src/main/java/binnie/extrabees/genetics/ExtraBeesSpecies.java +++ /dev/null @@ -1,1216 +0,0 @@ -package binnie.extrabees.genetics; - -import com.google.common.base.Preconditions; - -import javax.annotation.Nonnull; -import javax.annotation.Nullable; -import java.util.ArrayList; -import java.util.Collection; -import java.util.LinkedHashMap; -import java.util.Map; - -import net.minecraft.client.renderer.block.model.ModelResourceLocation; -import net.minecraft.init.Items; -import net.minecraft.item.Item; -import net.minecraft.item.ItemStack; -import net.minecraft.stats.Achievement; -import net.minecraft.util.NonNullList; -import net.minecraft.world.World; - -import com.mojang.authlib.GameProfile; - -import net.minecraftforge.fml.relauncher.Side; -import net.minecraftforge.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.IModelManager; -import forestry.api.genetics.AlleleManager; -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.apiculture.PluginApiculture; -import forestry.apiculture.genetics.BeeDefinition; -import forestry.core.genetics.alleles.AlleleHelper; -import forestry.core.genetics.alleles.EnumAllele; - -import binnie.extrabees.ExtraBees; -import binnie.extrabees.client.BeeModelProvider; -import binnie.extrabees.genetics.effect.ExtraBeesEffect; -import binnie.extrabees.items.ItemHoneyComb; -import binnie.extrabees.items.types.EnumHoneyComb; -import binnie.extrabees.items.types.IEBEnumItem; -import binnie.extrabees.utils.Utils; - -public enum ExtraBeesSpecies implements IAlleleBeeSpecies { - ARID("aridus", 12511316), - BARREN("infelix", 14733923), - DESOLATE("desolo", 13744272), - GNAWING("apica", 15234224), - ROTTEN("caries", 12574902), - BONE("os", 15330792), - CREEPER("erepo", 2942485), - DECOMPOSING("aegrus", 5388049), - ROCK("saxum", 11053224), - STONE("lapis", 7697781), - GRANITE("granum", 6903125), - MINERAL("minerale", 7239037), - COPPER("cuprous", 13722376), - TIN("stannus", 12431805), - IRON("ferrous", 11038808), - LEAD("plumbous", 11373483), - ZINC("spelta", 15592447), - TITANIUM("titania", 11578083), - 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("marbla", 14076367), - ROMAN("roman", 11373488), - GREEK("greco", 8735882), - CLASSICAL("classica", 8592780), - 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 final Map allProducts; - public final Map allSpecialties; - private final int primaryColor; - private final String binomial; - private final Map products; - private final Map specialties; - public State state; - boolean nocturnal; - private int secondaryColor; - private EnumTemperature temperature; - private EnumHumidity humidity; - private boolean hasEffect; - private boolean isSecret; - private boolean isCounted; - @Nullable - private IClassification branch; - private String uid; - @Nullable - private Achievement achievement; - private boolean dominant; - @Nullable - private IAllele[] template; - - ExtraBeesSpecies(final String binomial, final int colour) { - this.primaryColor = colour; - this.secondaryColor = 16768022; - this.temperature = EnumTemperature.NORMAL; - this.humidity = EnumHumidity.NORMAL; - this.hasEffect = false; - this.isSecret = true; - this.isCounted = true; - this.branch = null; - this.uid = ""; - this.achievement = null; - this.dominant = true; - this.products = new LinkedHashMap<>(); - this.specialties = new LinkedHashMap<>(); - this.allProducts = new LinkedHashMap<>(); - this.allSpecialties = new LinkedHashMap<>(); - this.state = State.Active; - this.nocturnal = false; - this.uid = this.toString().toLowerCase(); - this.binomial = binomial; - } - - ExtraBeesSpecies() { - this("", 16777215); - } - - public static IAllele[] getDefaultTemplate() { - return Utils.getBeeRoot().getDefaultTemplate(); - } - - public static void doInit() { - final int aridBody = 13362036; - final int rockBody = 10066329; - final int endBody = 14278302; - - for (ExtraBeesSpecies species : values()) { - species.importTemplate(getDefaultTemplate()); - } - - ExtraBeesSpecies.ARID.importTemplate(BeeDefinition.MODEST); - ExtraBeesSpecies.ARID.addProduct(EnumHoneyComb.BARREN, 0.30f); - ExtraBeesSpecies.ARID.setHumidity(EnumHumidity.ARID); - ExtraBeesSpecies.ARID.setFlowerProvider(ExtraBeesFlowers.DEAD.getUID()); - ExtraBeesSpecies.ARID.setTemperatureTolerance(EnumAllele.Tolerance.UP_1); - ExtraBeesSpecies.ARID.setSecondaryColor(aridBody); - - ExtraBeesSpecies.BARREN.importTemplate(ExtraBeesSpecies.ARID); - ExtraBeesSpecies.BARREN.setFertility(EnumAllele.Fertility.LOW); - ExtraBeesSpecies.BARREN.addProduct(EnumHoneyComb.BARREN, 0.30f); - - ExtraBeesSpecies.DESOLATE.importTemplate(ExtraBeesSpecies.BARREN); - ExtraBeesSpecies.DESOLATE.addProduct(EnumHoneyComb.BARREN, 0.30f); - ExtraBeesSpecies.DESOLATE.setEffect(ExtraBeesEffect.HUNGER.getUID()); - ExtraBeesSpecies.DESOLATE.setRecessive(); - ExtraBeesSpecies.DESOLATE.setNocturnal(); - ExtraBeesSpecies.DESOLATE.setHasEffect(); - - ExtraBeesSpecies.GNAWING.importTemplate(ExtraBeesSpecies.BARREN); - ExtraBeesSpecies.GNAWING.setFlowerProvider(ExtraBeesFlowers.WOOD.getUID()); - ExtraBeesSpecies.GNAWING.addProduct(EnumHoneyComb.BARREN, 0.25f); - ExtraBeesSpecies.GNAWING.addSpecialty(EnumHoneyComb.SAWDUST, 0.25f); - - ExtraBeesSpecies.ROTTEN.importTemplate(ExtraBeesSpecies.DESOLATE); - ExtraBeesSpecies.ROTTEN.setNocturnal(); - ExtraBeesSpecies.ROTTEN.setCaveDwelling(); - ExtraBeesSpecies.ROTTEN.setTolerantFlyer(); - ExtraBeesSpecies.ROTTEN.setEffect(ExtraBeesEffect.SPAWN_ZOMBIE.getUID()); - ExtraBeesSpecies.ROTTEN.addProduct(EnumHoneyComb.BARREN, 0.30f); - ExtraBeesSpecies.ROTTEN.addSpecialty(EnumHoneyComb.ROTTEN, 0.10f); - - ExtraBeesSpecies.BONE.importTemplate(ExtraBeesSpecies.ROTTEN); - ExtraBeesSpecies.BONE.addProduct(EnumHoneyComb.BARREN, 0.30f); - ExtraBeesSpecies.BONE.addSpecialty(EnumHoneyComb.BONE, 0.10f); - ExtraBeesSpecies.BONE.setEffect(ExtraBeesEffect.SPAWN_SKELETON.getUID()); - - ExtraBeesSpecies.CREEPER.importTemplate(ExtraBeesSpecies.ROTTEN); - ExtraBeesSpecies.CREEPER.setAllDay(); - ExtraBeesSpecies.CREEPER.addProduct(EnumHoneyComb.BARREN, 0.30f); - ExtraBeesSpecies.CREEPER.addSpecialty(ItemHoneyComb.VanillaComb.POWDERY.get(), 0.08f); - ExtraBeesSpecies.CREEPER.setEffect(ExtraBeesEffect.SPAWN_CREEPER.getUID()); - - ExtraBeesSpecies.DECOMPOSING.importTemplate(ExtraBeesSpecies.BARREN); - ExtraBeesSpecies.DECOMPOSING.addProduct(EnumHoneyComb.BARREN, 0.30f); - ExtraBeesSpecies.DECOMPOSING.addSpecialty(EnumHoneyComb.COMPOST, 0.08f); - - ExtraBeesSpecies.ROCK.addProduct(EnumHoneyComb.STONE, 0.30f); - ExtraBeesSpecies.ROCK.setIsSecret(false); - ExtraBeesSpecies.ROCK.setAllDay(); - ExtraBeesSpecies.ROCK.setCaveDwelling(); - ExtraBeesSpecies.ROCK.setTolerantFlyer(); - ExtraBeesSpecies.ROCK.setTemperatureTolerance(EnumAllele.Tolerance.BOTH_1); - ExtraBeesSpecies.ROCK.setHumidityTolerance(EnumAllele.Tolerance.BOTH_1); - ExtraBeesSpecies.ROCK.setFlowerProvider(ExtraBeesFlowers.ROCK.getUID()); - ExtraBeesSpecies.ROCK.setFertility(EnumAllele.Fertility.LOW); - ExtraBeesSpecies.ROCK.setLifespan(EnumAllele.Lifespan.SHORT); - ExtraBeesSpecies.ROCK.setSecondaryColor(rockBody); - - ExtraBeesSpecies.STONE.importTemplate(ExtraBeesSpecies.ROCK); - ExtraBeesSpecies.STONE.addProduct(EnumHoneyComb.STONE, 0.30f); - ExtraBeesSpecies.STONE.setRecessive(); - ExtraBeesSpecies.STONE.setSecondaryColor(rockBody); - - ExtraBeesSpecies.GRANITE.importTemplate(ExtraBeesSpecies.STONE); - ExtraBeesSpecies.GRANITE.addProduct(EnumHoneyComb.STONE, 0.30f); - ExtraBeesSpecies.GRANITE.setTemperatureTolerance(EnumAllele.Tolerance.BOTH_2); - ExtraBeesSpecies.GRANITE.setHumidityTolerance(EnumAllele.Tolerance.BOTH_2); - ExtraBeesSpecies.GRANITE.setSecondaryColor(rockBody); - - ExtraBeesSpecies.MINERAL.importTemplate(ExtraBeesSpecies.GRANITE); - ExtraBeesSpecies.MINERAL.addProduct(EnumHoneyComb.STONE, 0.30f); - ExtraBeesSpecies.MINERAL.setSecondaryColor(rockBody); - - ExtraBeesSpecies.COPPER.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.COPPER.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.COPPER.addSpecialty(EnumHoneyComb.COPPER, 0.06f); - ExtraBeesSpecies.COPPER.setSecondaryColor(rockBody); - - ExtraBeesSpecies.TIN.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.TIN.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.TIN.addSpecialty(EnumHoneyComb.TIN, 0.06f); - ExtraBeesSpecies.TIN.setSecondaryColor(rockBody); - - ExtraBeesSpecies.IRON.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.IRON.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.IRON.addSpecialty(EnumHoneyComb.IRON, 0.05f); - ExtraBeesSpecies.IRON.setRecessive(); - ExtraBeesSpecies.IRON.setSecondaryColor(rockBody); - - ExtraBeesSpecies.LEAD.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.LEAD.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.LEAD.addSpecialty(EnumHoneyComb.LEAD, 0.50f); - ExtraBeesSpecies.LEAD.setSecondaryColor(rockBody); - - ExtraBeesSpecies.NICKEL.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.NICKEL.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.NICKEL.addSpecialty(EnumHoneyComb.NICKEL, 0.05f); - ExtraBeesSpecies.NICKEL.setSecondaryColor(rockBody); - - ExtraBeesSpecies.ZINC.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.ZINC.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.ZINC.addSpecialty(EnumHoneyComb.ZINC, 0.05f); - ExtraBeesSpecies.ZINC.setSecondaryColor(rockBody); - - ExtraBeesSpecies.TITANIUM.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.TITANIUM.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.TITANIUM.addSpecialty(EnumHoneyComb.TITANIUM, 0.02f); - ExtraBeesSpecies.TITANIUM.setSecondaryColor(rockBody); - - ExtraBeesSpecies.TUNGSTATE.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.TUNGSTATE.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.TUNGSTATE.addSpecialty(EnumHoneyComb.TUNGSTEN, 0.01f); - ExtraBeesSpecies.TUNGSTATE.setSecondaryColor(rockBody); - - ExtraBeesSpecies.GOLD.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.GOLD.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.GOLD.addSpecialty(EnumHoneyComb.GOLD, 0.02f); - ExtraBeesSpecies.GOLD.setSecondaryColor(rockBody); - - ExtraBeesSpecies.SILVER.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.SILVER.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.SILVER.addSpecialty(EnumHoneyComb.SILVER, 0.02f); - ExtraBeesSpecies.SILVER.setRecessive(); - ExtraBeesSpecies.SILVER.setSecondaryColor(rockBody); - - ExtraBeesSpecies.PLATINUM.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.PLATINUM.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.PLATINUM.addSpecialty(EnumHoneyComb.PLATINUM, 0.01f); - ExtraBeesSpecies.PLATINUM.setRecessive(); - ExtraBeesSpecies.PLATINUM.setSecondaryColor(rockBody); - - ExtraBeesSpecies.LAPIS.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.LAPIS.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.LAPIS.addSpecialty(EnumHoneyComb.LAPIS, 0.05f); - ExtraBeesSpecies.LAPIS.setSecondaryColor(rockBody); - - ExtraBeesSpecies.EMERALD.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.EMERALD.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.EMERALD.addSpecialty(EnumHoneyComb.EMERALD, 0.04f); - ExtraBeesSpecies.EMERALD.setSecondaryColor(rockBody); - - ExtraBeesSpecies.RUBY.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.RUBY.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.RUBY.addSpecialty(EnumHoneyComb.RUBY, 0.03f); - ExtraBeesSpecies.RUBY.setSecondaryColor(rockBody); - - ExtraBeesSpecies.SAPPHIRE.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.SAPPHIRE.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.SAPPHIRE.addSpecialty(EnumHoneyComb.SAPPHIRE, 0.03f); - ExtraBeesSpecies.SAPPHIRE.setSecondaryColor(rockBody); - - ExtraBeesSpecies.DIAMOND.importTemplate(ExtraBeesSpecies.MINERAL); - ExtraBeesSpecies.DIAMOND.addProduct(EnumHoneyComb.STONE, 0.20f); - ExtraBeesSpecies.DIAMOND.addSpecialty(EnumHoneyComb.DIAMOND, 0.01f); - 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.setRecessive(); - - ExtraBeesSpecies.NUCLEAR.importTemplate(ExtraBeesSpecies.UNSTABLE); - ExtraBeesSpecies.NUCLEAR.addProduct(EnumHoneyComb.BARREN, 0.20f); - ExtraBeesSpecies.NUCLEAR.setRecessive(); - - ExtraBeesSpecies.RADIOACTIVE.importTemplate(ExtraBeesSpecies.NUCLEAR); - ExtraBeesSpecies.RADIOACTIVE.addProduct(EnumHoneyComb.BARREN, 0.20f); - ExtraBeesSpecies.RADIOACTIVE.addSpecialty(EnumHoneyComb.URANIUM, 0.02f); - ExtraBeesSpecies.RADIOACTIVE.setHasEffect(); - ExtraBeesSpecies.RADIOACTIVE.setRecessive(); - - ExtraBeesSpecies.ANCIENT.importTemplate(BeeDefinition.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.setRecessive(); - - ExtraBeesSpecies.RELIC.importTemplate(ExtraBeesSpecies.ANCIENT); - ExtraBeesSpecies.RELIC.addProduct(EnumHoneyComb.OLD, 0.30f); - ExtraBeesSpecies.RELIC.setHasEffect(); - 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.setRecessive(); - - 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.setRecessive(); - - ExtraBeesSpecies.FUEL.importTemplate(ExtraBeesSpecies.OIL); - ExtraBeesSpecies.FUEL.addProduct(EnumHoneyComb.OIL, 0.10f); - ExtraBeesSpecies.FUEL.addSpecialty(EnumHoneyComb.FUEL, 0.04f); - ExtraBeesSpecies.FUEL.setHasEffect(); - - ExtraBeesSpecies.CREOSOTE.importTemplate(ExtraBeesSpecies.COAL); - ExtraBeesSpecies.CREOSOTE.addProduct(EnumHoneyComb.COAL, 0.10f); - ExtraBeesSpecies.CREOSOTE.addSpecialty(EnumHoneyComb.CREOSOTE, 0.07f); - ExtraBeesSpecies.CREOSOTE.setHasEffect(); - - ExtraBeesSpecies.LATEX.importTemplate(ExtraBeesSpecies.RESIN); - ExtraBeesSpecies.LATEX.addProduct(EnumHoneyComb.RESIN, 0.10f); - ExtraBeesSpecies.LATEX.addSpecialty(EnumHoneyComb.LATEX, 0.05f); - ExtraBeesSpecies.LATEX.setHasEffect(); - - ExtraBeesSpecies.WATER.addProduct(EnumHoneyComb.WATER, 0.30f); - ExtraBeesSpecies.WATER.setIsSecret(false); - ExtraBeesSpecies.WATER.setTolerantFlyer(); - ExtraBeesSpecies.WATER.setHumidityTolerance(EnumAllele.Tolerance.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.OCEAN.importTemplate(ExtraBeesSpecies.WATER); - ExtraBeesSpecies.OCEAN.addProduct(EnumHoneyComb.WATER, 0.30f); - ExtraBeesSpecies.OCEAN.importTemplate(ExtraBeesSpecies.WATER); - ExtraBeesSpecies.OCEAN.setRecessive(); - - 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(BeeDefinition.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.BonemealSapling.getUID()); - - ExtraBeesSpecies.SWEET.importTemplate(BeeDefinition.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.importTemplate(ExtraBeesSpecies.SWEET); - ExtraBeesSpecies.SUGAR.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.40f); - ExtraBeesSpecies.SUGAR.addProduct(new ItemStack(Items.SUGAR, 1, 0), 0.20f); - - ExtraBeesSpecies.RIPENING.importTemplate(ExtraBeesSpecies.SUGAR); - 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.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.BonemealFruit.getUID()); - ExtraBeesSpecies.FRUIT.setHasEffect(); - - 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.setRecessive(); - - ExtraBeesSpecies.FARM.importTemplate(BeeDefinition.RURAL); - ExtraBeesSpecies.FARM.addProduct(ItemHoneyComb.VanillaComb.WHEATEN.get(), 0.30f); - ExtraBeesSpecies.FARM.addSpecialty(EnumHoneyComb.SEED, 0.10f); - - ExtraBeesSpecies.MILK.importTemplate(BeeDefinition.RURAL); - ExtraBeesSpecies.MILK.addProduct(ItemHoneyComb.VanillaComb.WHEATEN.get(), 0.30f); - ExtraBeesSpecies.MILK.addSpecialty(EnumHoneyComb.MILK, 0.10f); - - ExtraBeesSpecies.COFFEE.importTemplate(BeeDefinition.RURAL); - ExtraBeesSpecies.COFFEE.addProduct(ItemHoneyComb.VanillaComb.WHEATEN.get(), 0.30f); - ExtraBeesSpecies.COFFEE.addSpecialty(EnumHoneyComb.COFFEE, 0.08f); - - ExtraBeesSpecies.SWAMP.importTemplate(BeeDefinition.MARSHY); - ExtraBeesSpecies.SWAMP.addProduct(ItemHoneyComb.VanillaComb.MOSSY.get(), 0.30f); - 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.setRecessive(); - - 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.BonemealMushroom.getUID()); - ExtraBeesSpecies.FUNGAL.setHasEffect(); - - ExtraBeesSpecies.BASALT.importTemplate(BeeDefinition.SINISTER); - ExtraBeesSpecies.BASALT.addProduct(ItemHoneyComb.VanillaComb.SIMMERING.get(), 0.25f); - ExtraBeesSpecies.BASALT.setEffect("forestry.effectAggressive"); - ExtraBeesSpecies.BASALT.setSecondaryColor(10101539); - ExtraBeesSpecies.BASALT.setHumidity(EnumHumidity.ARID); - ExtraBeesSpecies.BASALT.setTemperature(EnumTemperature.HELLISH); - - ExtraBeesSpecies.TEMPERED.importTemplate(ExtraBeesSpecies.BASALT); - ExtraBeesSpecies.TEMPERED.addProduct(ItemHoneyComb.VanillaComb.SIMMERING.get(), 0.25f); - ExtraBeesSpecies.TEMPERED.setEffect(ExtraBeesEffect.METEOR.getUID()); - ExtraBeesSpecies.TEMPERED.setRecessive(); - ExtraBeesSpecies.TEMPERED.setSecondaryColor(10101539); - - ExtraBeesSpecies.VOLCANIC.importTemplate(ExtraBeesSpecies.TEMPERED); - ExtraBeesSpecies.VOLCANIC.addProduct(ItemHoneyComb.VanillaComb.SIMMERING.get(), 0.25f); - ExtraBeesSpecies.VOLCANIC.addSpecialty(EnumHoneyComb.BLAZE, 0.10f); - ExtraBeesSpecies.VOLCANIC.setHasEffect(); - ExtraBeesSpecies.VOLCANIC.setSecondaryColor(10101539); - - ExtraBeesSpecies.MALICIOUS.importTemplate(BeeDefinition.TROPICAL); - ExtraBeesSpecies.MALICIOUS.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f); - ExtraBeesSpecies.MALICIOUS.setSecondaryColor(431972); - 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(431972); - - 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.setRecessive(); - ExtraBeesSpecies.VIRULENT.setHasEffect(); - ExtraBeesSpecies.VIRULENT.setSecondaryColor(431972); - - ExtraBeesSpecies.VISCOUS.importTemplate(BeeDefinition.TROPICAL); - ExtraBeesSpecies.VISCOUS.setEffect(ExtraBeesEffect.ECTOPLASM.getUID()); - ExtraBeesSpecies.VISCOUS.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f); - ExtraBeesSpecies.VISCOUS.setSecondaryColor(431972); - 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(431972); - - 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(); - ExtraBeesSpecies.STICKY.setSecondaryColor(431972); - - 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(), 0.20f); - ExtraBeesSpecies.CORROSIVE.setRecessive(); - ExtraBeesSpecies.CORROSIVE.setSecondaryColor(431972); - - ExtraBeesSpecies.CAUSTIC.importTemplate(ExtraBeesSpecies.CORROSIVE); - ExtraBeesSpecies.CAUSTIC.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.25f); - ExtraBeesSpecies.CAUSTIC.addSpecialty(EnumHoneyComb.ACIDIC, 0.03f); - ExtraBeesSpecies.CAUSTIC.setSecondaryColor(431972); - - ExtraBeesSpecies.ACIDIC.importTemplate(ExtraBeesSpecies.CAUSTIC); - ExtraBeesSpecies.ACIDIC.addProduct(ItemHoneyComb.VanillaComb.SILKY.get(), 0.20f); - ExtraBeesSpecies.ACIDIC.addSpecialty(EnumHoneyComb.ACIDIC, 0.16f); - ExtraBeesSpecies.ACIDIC.setHasEffect(); - ExtraBeesSpecies.ACIDIC.setSecondaryColor(431972); - - 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.setRecessive(); - - 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(); - - ExtraBeesSpecies.ARTIC.importTemplate(BeeDefinition.WINTRY); - ExtraBeesSpecies.ARTIC.addProduct(ItemHoneyComb.VanillaComb.FROZEN.get(), 0.25f); - ExtraBeesSpecies.ARTIC.setTemperature(EnumTemperature.ICY); - ExtraBeesSpecies.ARTIC.setSecondaryColor(14349811); - - ExtraBeesSpecies.FREEZING.importTemplate(ExtraBeesSpecies.ARTIC); - ExtraBeesSpecies.FREEZING.addProduct(ItemHoneyComb.VanillaComb.FROZEN.get(), 0.20f); - ExtraBeesSpecies.FREEZING.addSpecialty(EnumHoneyComb.GLACIAL, 0.10f); - ExtraBeesSpecies.FREEZING.setSecondaryColor(14349811); - - 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.setRecessive(); - ExtraBeesSpecies.SHADOW.setSecondaryColor(3355443); - - ExtraBeesSpecies.DARKENED.importTemplate(ExtraBeesSpecies.SHADOW); - ExtraBeesSpecies.DARKENED.addProduct(EnumHoneyComb.SHADOW, 0.10f); - ExtraBeesSpecies.DARKENED.setNocturnal(); - ExtraBeesSpecies.DARKENED.setSecondaryColor(3355443); - - ExtraBeesSpecies.ABYSS.importTemplate(ExtraBeesSpecies.DARKENED); - ExtraBeesSpecies.ABYSS.setNocturnal(); - ExtraBeesSpecies.ABYSS.addProduct(EnumHoneyComb.SHADOW, 0.25f); - ExtraBeesSpecies.ABYSS.setEffect(ExtraBeesEffect.WITHER.getUID()); - ExtraBeesSpecies.ABYSS.setHasEffect(); - ExtraBeesSpecies.ABYSS.setSecondaryColor(3355443); - - ExtraBeesSpecies.CELEBRATORY.importTemplate(BeeDefinition.MERRY); - ExtraBeesSpecies.CELEBRATORY.setEffect(ExtraBeesEffect.FIREWORKS.getUID()); - - ExtraBeesSpecies.GLOWSTONE.importTemplate(ExtraBeesSpecies.BASALT); - ExtraBeesSpecies.GLOWSTONE.addProduct(EnumHoneyComb.GLOWSTONE, 0.15f); - ExtraBeesSpecies.GLOWSTONE.setSecondaryColor(10101539); - - ExtraBeesSpecies.HAZARDOUS.importTemplate(BeeDefinition.AUSTERE); - ExtraBeesSpecies.HAZARDOUS.addProduct(EnumHoneyComb.SALTPETER, 0.12f); - - ExtraBeesSpecies.JADED.importTemplate(BeeDefinition.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(new ItemStack(PluginApiculture.getItems().pollenCluster), 0.20f); - ExtraBeesSpecies.JADED.setHasEffect(); - ExtraBeesSpecies.JADED.setSecondaryColor(14453483); - ExtraBeesSpecies.JADED.addSpecialty(EnumHoneyComb.PURPLE, 0.15f); - ExtraBeesSpecies.JADED.isCounted = false; - - ExtraBeesSpecies.UNUSUAL.importTemplate(BeeDefinition.ENDED); - ExtraBeesSpecies.UNUSUAL.setEffect(ExtraBeesEffect.GRAVITY.getUID()); - ExtraBeesSpecies.UNUSUAL.setSecondaryColor(12231403); - ExtraBeesSpecies.UNUSUAL.addProduct(ItemHoneyComb.VanillaComb.QUARTZ.get(), 0.25f); - - ExtraBeesSpecies.SPATIAL.importTemplate(ExtraBeesSpecies.UNUSUAL); - ExtraBeesSpecies.SPATIAL.setEffect(ExtraBeesEffect.GRAVITY.getUID()); - ExtraBeesSpecies.SPATIAL.setSecondaryColor(10768076); - ExtraBeesSpecies.SPATIAL.addProduct(ItemHoneyComb.VanillaComb.QUARTZ.get(), 0.25f); - ExtraBeesSpecies.SPATIAL.addSpecialty(EnumHoneyComb.CERTUS, 0.05f); - - ExtraBeesSpecies.QUANTUM.setEffect(ExtraBeesEffect.TELEPORT.getUID()); - ExtraBeesSpecies.QUANTUM.setSecondaryColor(13963227); - 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); - ExtraBeesSpecies.YELLORIUM.addProduct(EnumHoneyComb.BARREN, 0.20f); - ExtraBeesSpecies.YELLORIUM.addSpecialty(EnumHoneyComb.YELLORIUM, 0.02f); - ExtraBeesSpecies.YELLORIUM.setEffect(ExtraBeesEffect.RADIOACTIVE.getUID()); - ExtraBeesSpecies.YELLORIUM.setFertility(EnumAllele.Fertility.LOW); - ExtraBeesSpecies.YELLORIUM.setLifespan(EnumAllele.Lifespan.SHORTEST); - - ExtraBeesSpecies.CYANITE.importTemplate(ExtraBeesSpecies.YELLORIUM); - ExtraBeesSpecies.CYANITE.addProduct(EnumHoneyComb.BARREN, 0.20f); - ExtraBeesSpecies.CYANITE.addSpecialty(EnumHoneyComb.CYANITE, 0.01f); - - ExtraBeesSpecies.BLUTONIUM.importTemplate(ExtraBeesSpecies.CYANITE); - ExtraBeesSpecies.BLUTONIUM.addProduct(EnumHoneyComb.BARREN, 0.20f); - ExtraBeesSpecies.BLUTONIUM.addSpecialty(EnumHoneyComb.BLUTONIUM, 0.01f); - - ExtraBeesSpecies.MARBLE.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f); - ExtraBeesSpecies.MARBLE.importTemplate(BeeDefinition.NOBLE); - - ExtraBeesSpecies.ROMAN.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f); - ExtraBeesSpecies.ROMAN.importTemplate(MARBLE); - - ExtraBeesSpecies.GREEK.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f); - ExtraBeesSpecies.GREEK.setRecessive(); - ExtraBeesSpecies.GREEK.importTemplate(ROMAN); - - ExtraBeesSpecies.CLASSICAL.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.30f); - ExtraBeesSpecies.CLASSICAL.addSpecialty(PluginApiculture.getItems().royalJelly.getItemStack(), 0.25f); - ExtraBeesSpecies.CLASSICAL.setHasEffect(); - ExtraBeesSpecies.CLASSICAL.importTemplate(GREEK); - - ExtraBeesSpecies.MYSTICAL.importTemplate(BeeDefinition.NOBLE); - for (final Map.Entry entry : Utils.getSpecies(BeeDefinition.NOBLE).getProductChances().entrySet()) { - ExtraBeesSpecies.MYSTICAL.addProduct(entry.getKey(), entry.getValue()); - } - ExtraBeesSpecies.MYSTICAL.setFlowerProvider(ExtraBeesFlowers.Mystical.getUID()); - - for (final ExtraBeesSpecies species : values()) { - if (species.state != State.Active) { - AlleleManager.alleleRegistry.blacklistAllele(species.getUID()); - } - for (final EnumBeeChromosome chromo : EnumBeeChromosome.values()) { - if (chromo != EnumBeeChromosome.HUMIDITY_TOLERANCE) { - final IAllele allele = species.getTemplate()[chromo.ordinal()]; - if (allele == null || !chromo.getAlleleClass().isInstance(allele)) { - throw new RuntimeException(species.getName() + " has an invalid " + chromo.toString() + " chromosome!"); - } - } - } - } - - for (int i = 0; i < 16; ++i) { - final ExtraBeesSpecies species3 = values()[ExtraBeesSpecies.RED.ordinal() + i]; - final EnumHoneyComb comb = EnumHoneyComb.values()[EnumHoneyComb.RED.ordinal() + i]; - species3.addProduct(ItemHoneyComb.VanillaComb.HONEY.get(), 0.75f); - species3.addSpecialty(comb, 0.25f); - species3.setSecondaryColor(9240320); - } - - for (final ExtraBeesSpecies species2 : values()) { - species2.registerTemplate(); - ExtraBees.proxy.registerBeeModel(species2); - } - } - - @Override - public String getName() { - return ExtraBees.proxy.localiseWithOutPrefix(getUnlocalizedName()); - } - - @Override - public String getDescription() { - return ExtraBees.proxy.localiseWithOutPrefix(getUID() + ".desc"); - } - - @Override - public EnumTemperature getTemperature() { - return this.temperature; - } - - private void setTemperature(final EnumTemperature temperature) { - this.temperature = temperature; - } - - @Override - public EnumHumidity getHumidity() { - return this.humidity; - } - - private void setHumidity(final EnumHumidity humidity) { - this.humidity = humidity; - } - - @Override - public boolean hasEffect() { - return this.hasEffect; - } - - @Override - public boolean isSecret() { - return this.isSecret; - } - - @Override - public boolean isCounted() { - return this.isCounted; - } - - @Override - public String getBinomial() { - return this.binomial; - } - - @Override - public String getAuthority() { - return "Binnie"; - } - - @Override - public IClassification getBranch() { - return this.branch; - } - - void setBranch(final IClassification branch) { - this.branch = branch; - } - - @Override - public String getUID() { - return "extrabees.species." + this.uid; - } - - @Override - public boolean isDominant() { - return this.dominant; - } - - public Map getProducts() { - return this.products; - } - - public Map getSpecialty() { - return this.specialties; - } - - private void setState(final State state) { - this.state = state; - } - - public void registerTemplate() { - Utils.getBeeRoot().registerTemplate(this.getTemplate()); - if (this.state != State.Active) { - AlleleManager.alleleRegistry.blacklistAllele(this.getUID()); - } - } - - public void addProduct(final ItemStack product, final Float chance) { - if (product.isEmpty()) { - this.setState(State.Inactive); - } else { - this.products.put(product, chance); - this.allProducts.put(product, chance); - } - } - - public void addProduct(final IEBEnumItem product, final Float chance) { - if (product.isActive()) { - this.addProduct(product.get(1), chance); - } else { - this.allProducts.put(product.get(1), chance); - this.setState(State.Inactive); - } - } - - public void addSpecialty(final ItemStack product, final Float chance) { - if (product.isEmpty()) { - this.setState(State.Inactive); - } else { - this.specialties.put(product, chance); - this.allSpecialties.put(product, chance); - } - } - - private void addSpecialty(final IEBEnumItem product, final Float chance) { - if (product.isActive()) { - this.addSpecialty(product.get(1), chance); - } else { - this.setState(State.Inactive); - this.allSpecialties.put(product.get(1), chance); - } - } - - public IAllele[] getTemplate() { - Preconditions.checkState(this.template != null, "Species Template has not been set: %s", name()); - this.template[EnumBeeChromosome.SPECIES.ordinal()] = this; - return this.template; - } - - public void importTemplate(final BeeDefinition species) { - this.importTemplate(species.getTemplate()); - } - - public void importTemplate(final ExtraBeesSpecies species) { - this.importTemplate(species.getTemplate()); - } - - public void importTemplate(final IAllele[] template) { - IAllele[] templateCopy = template.clone(); - this.setHumidity(((IAlleleSpecies) template[0]).getHumidity()); - this.setTemperature(((IAlleleSpecies) template[0]).getTemperature()); - this.setSecondaryColor(((IAlleleSpecies) template[0]).getSpriteColour(1)); - templateCopy[EnumBeeChromosome.SPECIES.ordinal()] = this; - this.template = templateCopy; - } - - public void setRecessive() { - this.dominant = false; - } - - public void setIsSecret(final boolean secret) { - this.isSecret = secret; - } - - public void setHasEffect() { - this.hasEffect = true; - } - - public void setSecondaryColor(final int colour) { - this.secondaryColor = colour; - } - - public boolean isJubilant(final World world, final int biomeid, final int x, final int y, final int z) { - return true; - } - - @Override - public boolean isJubilant(final IBeeGenome genome, final IBeeHousing housing) { - return true; - } - - /*@Override - public int getIconColour(final int renderPass) { - return (renderPass == 0) ? this.primaryColor : ((renderPass == 1) ? this.secondaryColor : 16777215); - } - - @Override - public IIconProvider getIconProvider() { - return this; - } - - @Override - public IIcon getIcon(final short texUID) { - return null; - } - - @Override - @SideOnly(Side.CLIENT) - public void registerIcons(final IIconRegister register) { - String iconType = "default"; - String mod = "forestry"; - if (this == ExtraBeesSpecies.JADED) { - iconType = "jaded"; - mod = "extrabees"; - } - this.icons = new IIcon[EnumBeeType.values().length][3]; - final 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) { - this.icons[i][0] = BinnieCore.proxy.getIcon(register, mod, "bees/" + iconType + "/" + EnumBeeType.values()[i].toString().toLowerCase(Locale.ENGLISH) + ".outline"); - this.icons[i][1] = ((EnumBeeType.values()[i] != EnumBeeType.LARVAE) ? body1 : BinnieCore.proxy.getIcon(register, mod, "bees/" + iconType + "/" + EnumBeeType.values()[i].toString().toLowerCase(Locale.ENGLISH) + ".body")); - this.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(final EnumBeeType type, final int renderPass) { - if (this.icons == null) { - return ExtraBeesSpecies.ARID.getIcon(type, renderPass); - } - return this.icons[type.ordinal()][renderPass]; - }*/ - - @Override - public IBeeRoot getRoot() { - return Utils.getBeeRoot(); - } - - @Override - public boolean isNocturnal() { - return this.nocturnal; - } - - public void setNocturnal() { - this.nocturnal = true; - } - - public void setAllDay() { - this.setAllDay(true); - } - - public void setAllDay(final boolean allDay) { - if (allDay) { - this.getTemplate()[EnumBeeChromosome.NEVER_SLEEPS.ordinal()] = AlleleManager.alleleRegistry.getAllele("forestry.boolTrue"); - } else { - this.getTemplate()[EnumBeeChromosome.NEVER_SLEEPS.ordinal()] = AlleleManager.alleleRegistry.getAllele("forestry.boolFalse"); - } - } - - public void setCaveDwelling() { - this.getTemplate()[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = AlleleManager.alleleRegistry.getAllele("forestry.boolTrue"); - } - - public void setTolerantFlyer() { - this.getTemplate()[EnumBeeChromosome.TOLERATES_RAIN.ordinal()] = AlleleManager.alleleRegistry.getAllele("forestry.boolTrue"); - } - - public void setFlowerProvider(final String uid) { - final IAllele allele = AlleleManager.alleleRegistry.getAllele(uid); - if (allele instanceof IAlleleFlowers) { - this.getTemplate()[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = allele; - } - } - - public void setEffect(final String uid) { - final IAllele allele = AlleleManager.alleleRegistry.getAllele(uid); - if (allele instanceof IAlleleBeeEffect) { - this.getTemplate()[EnumBeeChromosome.EFFECT.ordinal()] = AlleleManager.alleleRegistry.getAllele(uid); - } - } - - private void setFertility(final EnumAllele.Fertility fert) { - AlleleHelper.getInstance().set(this.getTemplate(), EnumBeeChromosome.FERTILITY, fert); - } - - private void setLifespan(final EnumAllele.Lifespan fert) { - AlleleHelper.getInstance().set(this.getTemplate(), EnumBeeChromosome.LIFESPAN, fert); - } - - private void setSpeed(final EnumAllele.Speed fert) { - AlleleHelper.getInstance().set(this.getTemplate(), EnumBeeChromosome.SPEED, fert); - } - - private void setTerritory(final EnumAllele.Territory fert) { - AlleleHelper.getInstance().set(this.getTemplate(), EnumBeeChromosome.TERRITORY, fert); - } - - private void setFlowering(final EnumAllele.Flowering fert) { - AlleleHelper.getInstance().set(this.getTemplate(), EnumBeeChromosome.FLOWERING, fert); - } - - private void setHumidityTolerance(final EnumAllele.Tolerance fert) { - AlleleHelper.getInstance().set(this.getTemplate(), EnumBeeChromosome.HUMIDITY_TOLERANCE, fert); - } - - private void setTemperatureTolerance(final EnumAllele.Tolerance both1) { - AlleleHelper.getInstance().set(this.getTemplate(), EnumBeeChromosome.TEMPERATURE_TOLERANCE, both1); - } - - @Override - public float getResearchSuitability(final ItemStack itemstack) { - if (itemstack.isEmpty()) { - return 0.0f; - } - for (final ItemStack stack : this.products.keySet()) { - if (stack.isItemEqual(itemstack)) { - return 1.0f; - } - } - for (final ItemStack stack : this.specialties.keySet()) { - if (stack.isItemEqual(itemstack)) { - return 1.0f; - } - } - if (itemstack.getItem() == Items.GLASS_BOTTLE) { - return 0.9f; - } - if (itemstack.getItem() == PluginApiculture.getItems().honeyDrop) { - return 0.5f; - } - if (itemstack.getItem() == PluginApiculture.getItems().honeydew) { - return 0.7f; - } - if (itemstack.getItem() == PluginApiculture.getItems().beeComb) { - return 0.4f; - } - if (AlleleManager.alleleRegistry.isIndividual(itemstack)) { - return 1.0f; - } - for (final Map.Entry entry : this.getRoot().getResearchCatalysts().entrySet()) { - if (entry.getKey().isItemEqual(itemstack)) { - return entry.getValue(); - } - } - return 0.0f; - } - - @Override - public NonNullList getResearchBounty(final World world, final GameProfile researcher, final IIndividual individual, final int bountyLevel) { - final NonNullList bounty = NonNullList.create(); - ItemStack research = null; - if (world.rand.nextFloat() < 10.0f / bountyLevel) { - final Collection combinations = this.getRoot().getCombinations(this); - if (combinations.size() > 0) { - final 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 (final ItemStack stack : this.specialties.keySet()) { - final ItemStack stack2 = stack.copy(); - stack2.setCount(world.rand.nextInt((int) (bountyLevel / 2.0f)) + 1); - bounty.add(stack2); - } - } - for (final ItemStack stack : this.products.keySet()) { - final ItemStack stack2 = stack.copy(); - stack2.setCount(world.rand.nextInt((int) (bountyLevel / 2.0f)) + 1); - bounty.add(stack2); - } - return bounty; - } - - @Override - public int getComplexity() { - return 1 + this.getGeneticAdvancement(this, new ArrayList<>()); - } - - private int getGeneticAdvancement(final IAllele species, final ArrayList exclude) { - final int own = 1; - int highest = 0; - exclude.add(species); - for (final IMutation mutation : this.getRoot().getPaths(species, EnumBeeChromosome.SPECIES)) { - if (!exclude.contains(mutation.getAllele0())) { - final int otherAdvance = this.getGeneticAdvancement(mutation.getAllele0(), exclude); - if (otherAdvance > highest) { - highest = otherAdvance; - } - } - if (!exclude.contains(mutation.getAllele1())) { - final int otherAdvance = this.getGeneticAdvancement(mutation.getAllele1(), exclude); - if (otherAdvance <= highest) { - continue; - } - highest = otherAdvance; - } - } - return own + ((highest < 0) ? 0 : highest); - } - - @Override - public String getUnlocalizedName() { - return this.getUID() + ".name"; - } - - @Override - public Map getProductChances() { - return this.getProducts(); - } - - @Override - public Map getSpecialtyChances() { - return this.getSpecialty(); - } - - @Override - public int getSpriteColour(int renderPass) { - return (renderPass == 0) ? this.primaryColor : ((renderPass == 1) ? this.secondaryColor : 16777215); - } - - @SideOnly(Side.CLIENT) - @Override - public ModelResourceLocation getModel(EnumBeeType type) { - return BeeModelProvider.instance.getModel(type); - } - - @SideOnly(Side.CLIENT) - @Override - public void registerModels(Item item, @Nonnull IModelManager manager) { - BeeModelProvider.instance.registerModels(item, manager); - } - - public enum State { - Active, - Inactive, - Deprecated, - } -} diff --git a/src/main/java/binnie/extrabees/genetics/effect/ExtraBeesEffect.java b/src/main/java/binnie/extrabees/genetics/effect/ExtraBeesEffect.java index 90a26483..4e65513b 100644 --- a/src/main/java/binnie/extrabees/genetics/effect/ExtraBeesEffect.java +++ b/src/main/java/binnie/extrabees/genetics/effect/ExtraBeesEffect.java @@ -75,10 +75,10 @@ public enum ExtraBeesEffect implements IAlleleBeeEffect { WITHER, WATER, SLOW, - BonemealSapling, - BonemealFruit, - BonemealMushroom, - Power; + BONEMEAL_SAPLING, + BONEMEAL_FRUIT, + BONEMEAL_MUSHROOM, + POWER; private static final List birthdays = new ArrayList<>(); @@ -436,27 +436,27 @@ public enum ExtraBeesEffect implements IAlleleBeeEffect { } break; } - case BonemealSapling: { + case BONEMEAL_SAPLING: { if (world.rand.nextInt(20) > 1) { return storedData; } - if (ExtraBeesFlowers.Sapling.isAcceptedFlower(world, pos)) { + if (ExtraBeesFlowers.SAPLING.isAcceptedFlower(world, pos)) { ItemDye.applyBonemeal(new ItemStack(Blocks.DIRT, 1), world, pos); break; } break; } - case BonemealFruit: { + case BONEMEAL_FRUIT: { if (world.rand.nextInt(20) > 1) { return storedData; } - if (ExtraBeesFlowers.Fruit.isAcceptedFlower(world, pos)) { + if (ExtraBeesFlowers.FRUIT.isAcceptedFlower(world, pos)) { ItemDye.applyBonemeal(new ItemStack(Blocks.DIRT, 1), world, pos); break; } break; } - case BonemealMushroom: { + case BONEMEAL_MUSHROOM: { if (world.rand.nextInt(20) > 1) { return storedData; } @@ -466,7 +466,7 @@ public enum ExtraBeesEffect implements IAlleleBeeEffect { } break; } - case Power: { + case POWER: { final TileEntity tile2 = world.getTileEntity(pos); if (tile2.hasCapability(CapabilityEnergy.ENERGY, EnumFacing.UP)) { IEnergyStorage storage = tile2.getCapability(CapabilityEnergy.ENERGY, EnumFacing.UP); diff --git a/src/main/java/binnie/extrabees/init/BlockRegister.java b/src/main/java/binnie/extrabees/init/BlockRegister.java index bbda6156..942c0df7 100644 --- a/src/main/java/binnie/extrabees/init/BlockRegister.java +++ b/src/main/java/binnie/extrabees/init/BlockRegister.java @@ -11,7 +11,7 @@ import binnie.extrabees.alveary.TileEntityExtraBeesAlvearyPart; import binnie.extrabees.blocks.BlockEctoplasm; import binnie.extrabees.blocks.BlockExtraBeeHive; import binnie.extrabees.blocks.type.EnumHiveType; -import binnie.extrabees.genetics.ExtraBeesSpecies; +import binnie.extrabees.genetics.ExtraBeeDefinition; import binnie.extrabees.utils.HiveDrop; import binnie.extrabees.utils.Utils; import binnie.extrabees.utils.config.ConfigurationMain; @@ -40,13 +40,13 @@ public final class BlockRegister { private static void registerHiveDrops() { IAlleleBeeSpecies valiantSpecies = Utils.getSpecies(BeeDefinition.VALIANT); - EnumHiveType.Water.drops.add(new HiveDrop(ExtraBeesSpecies.WATER, 80)); + EnumHiveType.Water.drops.add(new HiveDrop(ExtraBeeDefinition.WATER, 80)); EnumHiveType.Water.drops.add(new HiveDrop(valiantSpecies, 3)); - EnumHiveType.Rock.drops.add(new HiveDrop(ExtraBeesSpecies.ROCK, 80)); + EnumHiveType.Rock.drops.add(new HiveDrop(ExtraBeeDefinition.ROCK, 80)); EnumHiveType.Rock.drops.add(new HiveDrop(valiantSpecies, 3)); - EnumHiveType.Nether.drops.add(new HiveDrop(ExtraBeesSpecies.BASALT, 80)); + EnumHiveType.Nether.drops.add(new HiveDrop(ExtraBeeDefinition.BASALT, 80)); EnumHiveType.Nether.drops.add(new HiveDrop(valiantSpecies, 3)); - EnumHiveType.Marble.drops.add(new HiveDrop(ExtraBeesSpecies.MARBLE, 80)); + EnumHiveType.Marble.drops.add(new HiveDrop(ExtraBeeDefinition.MARBLE, 80)); EnumHiveType.Marble.drops.add(new HiveDrop(valiantSpecies, 3)); ExtraBees.hive.setHarvestLevel("scoop", 0, ExtraBees.hive.getDefaultState().withProperty(BlockExtraBeeHive.hiveType, EnumHiveType.Water)); diff --git a/src/main/java/binnie/extrabees/proxy/ExtraBeesCommonProxy.java b/src/main/java/binnie/extrabees/proxy/ExtraBeesCommonProxy.java index 04923420..ff45916b 100644 --- a/src/main/java/binnie/extrabees/proxy/ExtraBeesCommonProxy.java +++ b/src/main/java/binnie/extrabees/proxy/ExtraBeesCommonProxy.java @@ -6,11 +6,11 @@ import net.minecraft.util.text.translation.I18n; import net.minecraftforge.fml.common.registry.GameRegistry; -import binnie.extrabees.genetics.ExtraBeesSpecies; +import binnie.extrabees.genetics.ExtraBeeDefinition; public class ExtraBeesCommonProxy { - public void registerBeeModel(ExtraBeesSpecies type) { + public void registerBeeModel(ExtraBeeDefinition type) { } public Block registerBlock(Block block) { diff --git a/src/main/java/binnie/extrabees/utils/HiveDrop.java b/src/main/java/binnie/extrabees/utils/HiveDrop.java index 56221a83..c9f38aeb 100644 --- a/src/main/java/binnie/extrabees/utils/HiveDrop.java +++ b/src/main/java/binnie/extrabees/utils/HiveDrop.java @@ -9,6 +9,7 @@ import forestry.api.apiculture.IAlleleBeeSpecies; import forestry.api.apiculture.IBee; import forestry.api.apiculture.IHiveDrop; import forestry.api.genetics.IAllele; +import forestry.apiculture.genetics.IBeeDefinition; public class HiveDrop implements IHiveDrop { @@ -16,6 +17,10 @@ public class HiveDrop implements IHiveDrop { private NonNullList extra; private int chance; + public HiveDrop(IBeeDefinition species, final int chance) { + this(species.getTemplate(), NonNullList.create(), chance); + } + public HiveDrop(final IAlleleBeeSpecies species, final int chance) { this(Utils.getBeeRoot().getTemplate(species), NonNullList.create(), chance); } diff --git a/src/main/java/binnie/genetics/gui/AnalystPageMutations.java b/src/main/java/binnie/genetics/gui/AnalystPageMutations.java index 2bc410de..bb344dc1 100644 --- a/src/main/java/binnie/genetics/gui/AnalystPageMutations.java +++ b/src/main/java/binnie/genetics/gui/AnalystPageMutations.java @@ -60,6 +60,9 @@ public class AnalystPageMutations extends ControlAnalystPage { if (ind.getGenome().getPrimary() == ExtraBeesIntegration.basalt) { hive = new ItemStack(ExtraBeesIntegration.hive, 1, 2); } + if (ind.getGenome().getPrimary() == ExtraBeesIntegration.marble) { + hive = new ItemStack(ExtraBeesIntegration.hive, 1, 3); + } } if (ind.getGenome().getPrimary() == ForestryAllele.BeeSpecies.Forest.getAllele()) { hive = new ItemStack(Mods.Forestry.block("beehives"), 1, 1);