diff --git a/api/forestry b/api/forestry index ecb6bf020..024ccf2c4 160000 --- a/api/forestry +++ b/api/forestry @@ -1 +1 @@ -Subproject commit ecb6bf0209e703f171615985dbb16587966175d9 +Subproject commit 024ccf2c406ba0e5a23f0a36451d1d5e036ac43a diff --git a/lang b/lang index fa0f81998..2bd40ad11 160000 --- a/lang +++ b/lang @@ -1 +1 @@ -Subproject commit fa0f81998bce75b242fdc80118c9e32f3e156d15 +Subproject commit 2bd40ad1185c1499bda6a769280204329be1750d diff --git a/src/main/java/forestry/apiculture/VillageHandlerApiculture.java b/src/main/java/forestry/apiculture/VillageHandlerApiculture.java index c2df740db..a15316c21 100755 --- a/src/main/java/forestry/apiculture/VillageHandlerApiculture.java +++ b/src/main/java/forestry/apiculture/VillageHandlerApiculture.java @@ -27,14 +27,13 @@ import cpw.mods.fml.common.registry.VillagerRegistry.IVillageCreationHandler; import cpw.mods.fml.common.registry.VillagerRegistry.IVillageTradeHandler; import forestry.api.apiculture.EnumBeeType; -import forestry.apiculture.genetics.BeeTemplates; +import forestry.apiculture.genetics.BeeDefinition; import forestry.apiculture.items.ItemHoneycomb; import forestry.apiculture.worldgen.ComponentVillageBeeHouse; import forestry.core.config.Defaults; import forestry.core.config.ForestryBlock; import forestry.core.config.ForestryItem; import forestry.core.proxy.Proxies; -import forestry.plugins.PluginApiculture; public class VillageHandlerApiculture implements IVillageCreationHandler, IVillageTradeHandler { @@ -53,10 +52,7 @@ public class VillageHandlerApiculture implements IVillageCreationHandler, IVilla recipeList.add(new MerchantRecipe(new ItemStack(Items.wheat, 2), ItemHoneycomb.getRandomComb(1, random, false))); recipeList.add(new MerchantRecipe(new ItemStack(Blocks.log, 24, Defaults.WILDCARD), ForestryBlock.apiculture.getItemStack(1, Defaults.DEFINITION_APIARY_META))); recipeList.add(new MerchantRecipe(new ItemStack(Items.emerald, 1), ForestryItem.frameProven.getItemStack(6))); - recipeList.add(new MerchantRecipe(new ItemStack(Items.emerald, 12), ForestryItem.beePrincessGE.getItemStack(1, Defaults.WILDCARD), - PluginApiculture.beeInterface.getMemberStack( - PluginApiculture.beeInterface.getBee(villager.worldObj, PluginApiculture.beeInterface.templateAsGenome(BeeTemplates.getMonasticTemplate())), - EnumBeeType.DRONE.ordinal()))); + recipeList.add(new MerchantRecipe(new ItemStack(Items.emerald, 12), ForestryItem.beePrincessGE.getItemStack(1, Defaults.WILDCARD), BeeDefinition.MONASTIC.getMemberStack(EnumBeeType.DRONE))); } @Override diff --git a/src/main/java/forestry/apiculture/genetics/AlleleBeeSpecies.java b/src/main/java/forestry/apiculture/genetics/AlleleBeeSpecies.java index 840f3c3ce..8147adb7e 100755 --- a/src/main/java/forestry/apiculture/genetics/AlleleBeeSpecies.java +++ b/src/main/java/forestry/apiculture/genetics/AlleleBeeSpecies.java @@ -32,7 +32,6 @@ import forestry.api.apiculture.IBeeGenome; import forestry.api.apiculture.IBeeHousing; import forestry.api.apiculture.IBeeRoot; import forestry.api.core.IIconProvider; -import forestry.api.genetics.AlleleManager; import forestry.api.genetics.IAllele; import forestry.api.genetics.IClassification; import forestry.api.genetics.IIndividual; @@ -41,13 +40,12 @@ import forestry.core.config.Defaults; import forestry.core.genetics.AlleleSpecies; import forestry.core.render.TextureManager; import forestry.core.utils.StackUtils; +import forestry.plugins.PluginApiculture; public class AlleleBeeSpecies extends AlleleSpecies implements IAlleleBeeSpecies, IIconProvider { public IJubilanceProvider jubilanceProvider; - private final IBeeRoot root; - private final HashMap products = new HashMap(); private final HashMap specialty = new HashMap(); @@ -57,19 +55,14 @@ public class AlleleBeeSpecies extends AlleleSpecies implements IAlleleBeeSpecies private static final String iconType = "default"; - public AlleleBeeSpecies(String uid, boolean dominant, String name, IClassification branch, int primaryColor, int secondaryColor) { - this(uid, dominant, name, branch, null, primaryColor, secondaryColor); - } - public AlleleBeeSpecies(String uid, boolean dominant, String name, IClassification branch, String binomial, int primaryColor, int secondaryColor) { this(uid, dominant, name, branch, binomial, primaryColor, secondaryColor, new JubilanceDefault()); } public AlleleBeeSpecies(String uid, boolean dominant, String name, IClassification branch, String binomial, int primaryColor, int secondaryColor, IJubilanceProvider jubilanceProvider) { - super(uid, dominant, name, branch, binomial); + super(uid, dominant, name, branch, binomial, false); - this.root = (IBeeRoot) AlleleManager.alleleRegistry.getSpeciesRoot("rootBees"); this.primaryColour = primaryColor; this.secondaryColour = secondaryColor; this.jubilanceProvider = jubilanceProvider; @@ -78,7 +71,7 @@ public class AlleleBeeSpecies extends AlleleSpecies implements IAlleleBeeSpecies @Override public IBeeRoot getRoot() { - return root; + return PluginApiculture.beeInterface; } public AlleleBeeSpecies setEntityTexture(String texture) { diff --git a/src/main/java/forestry/apiculture/genetics/Bee.java b/src/main/java/forestry/apiculture/genetics/Bee.java index 5de2a826d..9fd6ff820 100755 --- a/src/main/java/forestry/apiculture/genetics/Bee.java +++ b/src/main/java/forestry/apiculture/genetics/Bee.java @@ -93,7 +93,7 @@ public class Bee extends IndividualLiving implements IBee { public void readFromNBT(NBTTagCompound nbttagcompound) { if (nbttagcompound == null) { - this.genome = PluginApiculture.beeInterface.templateAsGenome(BeeTemplates.getForestTemplate()); + genome = BeeDefinition.FOREST.getGenome(); return; } @@ -110,7 +110,7 @@ public class Bee extends IndividualLiving implements IBee { if (nbttagcompound.hasKey("Genome")) { genome = new BeeGenome(nbttagcompound.getCompoundTag("Genome")); } else { - genome = PluginApiculture.beeInterface.templateAsGenome(BeeTemplates.getForestTemplate()); + genome = BeeDefinition.FOREST.getGenome(); } if (nbttagcompound.hasKey("Mate")) { diff --git a/src/main/java/forestry/apiculture/genetics/BeeDefinition.java b/src/main/java/forestry/apiculture/genetics/BeeDefinition.java new file mode 100644 index 000000000..f54e69aaa --- /dev/null +++ b/src/main/java/forestry/apiculture/genetics/BeeDefinition.java @@ -0,0 +1,1029 @@ +package forestry.apiculture.genetics; + +import java.awt.Color; +import java.util.Arrays; +import java.util.EnumSet; +import java.util.Locale; + +import org.apache.commons.lang3.text.WordUtils; + +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import net.minecraftforge.common.BiomeDictionary; + +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.apiculture.EnumBeeType; +import forestry.api.apiculture.IBee; +import forestry.api.apiculture.IBeeGenome; +import forestry.api.core.EnumHumidity; +import forestry.api.core.EnumTemperature; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IAllele; +import forestry.core.config.ForestryItem; +import forestry.core.genetics.Allele; +import forestry.plugins.PluginApiculture; + +public enum BeeDefinition implements IBeeDefinition { + /* HONEY BRANCH */ + FOREST(EnumBeeBranch.HONEY, "nigrocincta", true, new Color(0x19d0ec), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 0), 30); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlower; + template[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityHigh; + } + + @Override + protected void registerMutations() { + // found in hives + } + }, + MEADOWS(EnumBeeBranch.HONEY, "florea", true, new Color(0xef131e), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 0), 30); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlower; + } + + @Override + protected void registerMutations() { + // found in hives + } + }, + COMMON(EnumBeeBranch.HONEY, "cerana", true, new Color(0xb2b2b2), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 0), 35); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + } + + @Override + protected void registerMutations() { + for (BeeDefinition hiveBee0 : overworldHiveBees) { + for (BeeDefinition hiveBee1 : overworldHiveBees) { + if (hiveBee0 != hiveBee1) { + registerMutation(hiveBee0, hiveBee1, 15); + } + } + } + } + }, + CULTIVATED(EnumBeeBranch.HONEY, "mellifera", true, new Color(0x5734ec), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 0), 40); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedFast; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShortest; + } + + @Override + protected void registerMutations() { + for (BeeDefinition hiveBee : overworldHiveBees) { + registerMutation(COMMON, hiveBee, 12); + } + } + }, + + /* NOBLE BRANCH */ + NOBLE(EnumBeeBranch.NOBLE, "nobilis", false, new Color(0xec9a19), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 5), 20); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; + template[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlow; + } + + @Override + protected void registerMutations() { + registerMutation(COMMON, CULTIVATED, 10); + } + }, + MAJESTIC(EnumBeeBranch.NOBLE, "regalis", true, new Color(0x7f0000), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 5), 30); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShortened; + template[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityMaximum; + } + + @Override + protected void registerMutations() { + registerMutation(NOBLE, CULTIVATED, 8); + } + }, + IMPERIAL(EnumBeeBranch.NOBLE, "imperatorius", false, new Color(0xa3e02f), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 5), 20) + .addProduct(ForestryItem.royalJelly.getItemStack(), 15) + .setHasEffect(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectBeatific; + } + + @Override + protected void registerMutations() { + registerMutation(NOBLE, MAJESTIC, 8); + } + }, + + /* INDUSTRIOUS BRANCH */ + DILIGENT(EnumBeeBranch.INDUSTRIOUS, "sedulus", false, new Color(0xc219ec), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 3), 20); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; + template[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlow; + } + + @Override + protected void registerMutations() { + registerMutation(COMMON, CULTIVATED, 10); + } + }, + UNWEARY(EnumBeeBranch.INDUSTRIOUS, "assiduus", true, new Color(0x19ec5a), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 3), 30); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShortened; + } + + @Override + protected void registerMutations() { + registerMutation(DILIGENT, CULTIVATED, 8); + } + }, + INDUSTRIOUS(EnumBeeBranch.INDUSTRIOUS, "industria", false, new Color(0xffffff), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 3), 20) + .addProduct(ForestryItem.pollenCluster.getItemStack(), 15) + .setHasEffect(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; + template[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFast; + } + + @Override + protected void registerMutations() { + registerMutation(DILIGENT, UNWEARY, 8); + } + }, + + /* HEROIC BRANCH */ + STEADFAST(EnumBeeBranch.HEROIC, "legio", false, new Color(0x4d2b15), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 1), 20) + .setHasEffect(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; + template[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; + template[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolTrue; + } + + @Override + protected void registerMutations() { + // only found in dungeons chests + } + }, + VALIANT(EnumBeeBranch.HEROIC, "centurio", true, new Color(0x626bdd), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 1), 30) + .addSpecialty(new ItemStack(Items.sugar), 15); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong; + template[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; + template[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolTrue; + } + + @Override + protected void registerMutations() { + // found rarely at random in other bee's hives + } + }, + HEROIC(EnumBeeBranch.HEROIC, "kraphti", false, new Color(0xb3d5e4), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 1), 40) + .setHasEffect(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong; + template[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; + template[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolTrue; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectHeroic; + } + + @Override + protected void registerMutations() { + registerMutation(STEADFAST, VALIANT, 6) + .restrictBiomeType(BiomeDictionary.Type.FOREST) + .enableStrictBiomeCheck(); + } + }, + + /* INFERNAL BRANCH */ + SINISTER(EnumBeeBranch.INFERNAL, "caecus", false, new Color(0xb3d5e4), new Color(0x9a2323)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 2), 45) + .setEntityTexture("sinisterBee") + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectAggressive; + } + + @Override + protected void registerMutations() { + for (BeeDefinition parent2 : EnumSet.of(MODEST, TROPICAL)) { + registerMutation(CULTIVATED, parent2, 60) + .restrictBiomeType(BiomeDictionary.Type.NETHER); + } + } + }, + FIENDISH(EnumBeeBranch.INFERNAL, "diabolus", true, new Color(0xd7bee5), new Color(0x9a2323)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 2), 55) + .addProduct(ForestryItem.ash.getItemStack(), 15) + .setEntityTexture("sinisterBee") + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectAggressive; + } + + @Override + protected void registerMutations() { + for (BeeDefinition parent2 : EnumSet.of(CULTIVATED, MODEST, TROPICAL)) { + registerMutation(SINISTER, parent2, 40) + .restrictBiomeType(BiomeDictionary.Type.NETHER); + } + } + }, + DEMONIC(EnumBeeBranch.INFERNAL, "draco", false, new Color(0xf4e400), new Color(0x9a2323)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 2), 45) + .addProduct(new ItemStack(Items.glowstone_dust), 15) + .setEntityTexture("sinisterBee") + .setHasEffect() + .setTemperature(EnumTemperature.HELLISH) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectIgnition; + } + + @Override + protected void registerMutations() { + registerMutation(SINISTER, FIENDISH, 25) + .restrictBiomeType(BiomeDictionary.Type.NETHER); + } + }, + + /* AUSTERE BRANCH */ + MODEST(EnumBeeBranch.AUSTERE, "modicus", false, new Color(0xc5be86), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 7), 20) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; + } + + @Override + protected void registerMutations() { + // found in hives + } + }, + FRUGAL(EnumBeeBranch.AUSTERE, "permodestus", true, new Color(0xe8dcb1), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 7), 30) + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong; + } + + @Override + protected void registerMutations() { + registerMutation(MODEST, SINISTER, 16) + .setTemperatureRainfall(1.9f, 2.0f, 0.0f, 0.1f); + registerMutation(MODEST, FIENDISH, 10) + .setTemperatureRainfall(1.9f, 2.0f, 0.0f, 0.1f); + } + }, + AUSTERE(EnumBeeBranch.AUSTERE, "correpere", false, new Color(0xfffac2), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 7), 20) + .addSpecialty(ForestryItem.beeComb.getItemStack(1, 10), 50) + .setHasEffect() + .setTemperature(EnumTemperature.HOT) + .setHumidity(EnumHumidity.ARID); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger; + template[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceDown2; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectCreeper; + } + + @Override + protected void registerMutations() { + registerMutation(MODEST, FRUGAL, 8) + .setTemperatureRainfall(1.9f, 2.0f, 0.0f, 0.1f); + } + }, + + /* TROPICAL BRANCH */ + TROPICAL(EnumBeeBranch.TROPICAL, "mendelia", false, new Color(0x378020), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 6), 20) + .setEntityTexture("tropicalBee") + .setTemperature(EnumTemperature.WARM) + .setHumidity(EnumHumidity.DAMP); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; + } + + @Override + protected void registerMutations() { + // found in hives + } + }, + EXOTIC(EnumBeeBranch.TROPICAL, "darwini", true, new Color(0x304903), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 6), 30) + .setEntityTexture("tropicalBee") + .setTemperature(EnumTemperature.WARM) + .setHumidity(EnumHumidity.DAMP); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong; + } + + @Override + protected void registerMutations() { + registerMutation(AUSTERE, TROPICAL, 12); + } + }, + EDENIC(EnumBeeBranch.TROPICAL, "humboldti", false, new Color(0x393d0d), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 6), 20) + .setEntityTexture("tropicalBee") + .setHasEffect() + .setTemperature(EnumTemperature.WARM) + .setHumidity(EnumHumidity.DAMP); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger; + template[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth2; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectExploration; + } + + @Override + protected void registerMutations() { + registerMutation(EXOTIC, TROPICAL, 8); + } + }, + + /* END BRANCH */ + ENDED(EnumBeeBranch.END, "notchi", false, new Color(0xe079fa), new Color(0xd9de9e)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 8), 30) + .setEntityTexture("endBee") + .setTemperature(EnumTemperature.COLD); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + + } + + @Override + protected void registerMutations() { + // found in hives + } + }, + SPECTRAL(EnumBeeBranch.END, "idolum", true, new Color(0xa98bed), new Color(0xd9de9e)) { + + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 8), 50) + .setEntityTexture("endBee") + .setTemperature(EnumTemperature.COLD); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectReanimation; + } + + @Override + protected void registerMutations() { + registerMutation(HERMITIC, ENDED, 4); + } + }, + PHANTASMAL(EnumBeeBranch.END, "lemur", false, new Color(0xcc00fa), new Color(0xd9de9e)) { + + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 8), 40) + .setEntityTexture("endBee") + .setHasEffect() + .setTemperature(EnumTemperature.COLD); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLongest; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectResurrection; + } + + @Override + protected void registerMutations() { + registerMutation(SPECTRAL, ENDED, 2); + } + }, + + /* FROZEN BRANCH */ + WINTRY(EnumBeeBranch.FROZEN, "brumalis", false, new Color(0xa0ffc8), new Color(0xdaf5f3)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 4), 30) + .setEntityTexture("icyBee") + .setTemperature(EnumTemperature.ICY); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; + template[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityMaximum; + } + + @Override + protected void registerMutations() { + // found in hives + } + }, + ICY(EnumBeeBranch.FROZEN, "coagulis", true, new Color(0xa0ffff), new Color(0xdaf5f3)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 4), 20) + .addProduct(ForestryItem.craftingMaterial.getItemStack(1, 5), 20) + .setEntityTexture("icyBee") + .setTemperature(EnumTemperature.ICY); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; + } + + @Override + protected void registerMutations() { + registerMutation(INDUSTRIOUS, WINTRY, 12) + .setTemperature(0f, 0.15f); + } + }, + GLACIAL(EnumBeeBranch.FROZEN, "glacialis", false, new Color(0xefffff), new Color(0xdaf5f3)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 4), 20) + .addProduct(ForestryItem.craftingMaterial.getItemStack(1, 5), 40) + .setEntityTexture("icyBee") + .setTemperature(EnumTemperature.ICY) + .setHasEffect(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; + } + + @Override + protected void registerMutations() { + registerMutation(ICY, WINTRY, 8) + .setTemperature(0f, 0.15f); + } + }, + + /* VENGEFUL BRANCH */ + VINDICTIVE(EnumBeeBranch.VENGEFUL, "ultio", false, new Color(0xeafff3), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 9), 25) + .setIsNotCounted(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; + } + + @Override + protected void registerMutations() { + registerMutation(MONASTIC, DEMONIC, 4).setIsSecret(); + } + }, + VENGEFUL(EnumBeeBranch.VENGEFUL, "punire", false, new Color(0xc2de00), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 9), 40) + .setIsNotCounted(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger; + } + + @Override + protected void registerMutations() { + registerMutation(DEMONIC, VINDICTIVE, 8).setIsSecret(); + registerMutation(MONASTIC, VINDICTIVE, 8).setIsSecret(); + } + }, + AVENGING(EnumBeeBranch.VENGEFUL, "hostimentum", false, new Color(0xddff00), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 9), 40) + .setHasEffect() + .setIsNotCounted(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest; + template[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLongest; + } + + @Override + protected void registerMutations() { + registerMutation(VENGEFUL, VINDICTIVE, 4); + } + }, + + /* FESTIVE BRANCH */ + LEPORINE(EnumBeeBranch.FESTIVE, "lepus", false, new Color(0xfeff8f), new Color(0x3cd757)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 6), 30) + .addProduct(new ItemStack(Items.egg), 10) + .setHasEffect() + .setIsNotCounted(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectFestiveEaster; + } + + @Override + protected void registerMutations() { + registerMutationTimeLimited(MEADOWS, FOREST, 10, 3, 29, 4, 15).setIsSecret(); + } + }, + MERRY(EnumBeeBranch.FESTIVE, "feliciter", false, new Color(0xffffff), new Color(0xd40000)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 4), 30) + .addProduct(ForestryItem.craftingMaterial.getItemStack(1, 5), 20) + .setTemperature(EnumTemperature.ICY) + .setHasEffect() + .setIsNotCounted(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectSnowing; + } + + @Override + protected void registerMutations() { + registerMutationTimeLimited(WINTRY, FOREST, 10, 12, 21, 12, 27).setIsSecret(); + } + }, + TIPSY(EnumBeeBranch.FESTIVE, "ebrius", false, new Color(0xffffff), new Color(0xc219ec)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 4), 30) + .addProduct(ForestryItem.craftingMaterial.getItemStack(1, 5), 20) + .setTemperature(EnumTemperature.ICY) + .setHasEffect() + .setIsNotCounted(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectDrunkard; + } + + @Override + protected void registerMutations() { + registerMutationTimeLimited(WINTRY, MEADOWS, 10, 12, 27, 1, 2).setIsSecret(); + } + }, + // 35 Solstice + TRICKY(EnumBeeBranch.FESTIVE, "libita", false, new Color(0x49413B), new Color(0xFF6A00)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 0), 40) + .addProduct(new ItemStack(Items.cookie), 15) + .addSpecialty(new ItemStack(Items.skull, 1, 0), 2) + .addSpecialty(new ItemStack(Items.skull, 1, 2), 2) + .addSpecialty(new ItemStack(Items.skull, 1, 3), 2) + .addSpecialty(new ItemStack(Items.skull, 1, 4), 2) + .setHasEffect() + .setIsNotCounted(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; + template[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolTrue; + template[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersGourd; + } + + @Override + protected void registerMutations() { + registerMutationTimeLimited(SINISTER, COMMON, 10, 10, 15, 11, 3).setIsSecret(); + } + }, + // 37 Thanksgiving + + /* AGRARIAN BRANCH */ + RURAL(EnumBeeBranch.AGRARIAN, "rustico", false, new Color(0xfeff8f), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 14), 20); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + + } + + @Override + protected void registerMutations() { + registerMutation(MEADOWS, DILIGENT, 12) + .restrictBiomeType(BiomeDictionary.Type.PLAINS) + .enableStrictBiomeCheck(); + } + }, + FARMERLY(EnumBeeBranch.AGRARIAN, "arator", true, new Color(0xD39728), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 14), 27); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow; + template[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLarge; + } + + @Override + protected void registerMutations() { + registerMutation(RURAL, UNWEARY, 10) + .restrictBiomeType(BiomeDictionary.Type.PLAINS) + .enableStrictBiomeCheck(); + } + }, + AGRARIAN(EnumBeeBranch.AGRARIAN, "arator", true, new Color(0xFFCA75), new Color(0xFFE047)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 14), 35) + .setHasEffect(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow; + template[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth2; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectFertile; + template[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLarge; + } + + @Override + protected void registerMutations() { + registerMutation(FARMERLY, INDUSTRIOUS, 6) + .restrictBiomeType(BiomeDictionary.Type.PLAINS) + .enableStrictBiomeCheck(); + } + }, + + /* BOGGY BRANCH */ + MARSHY(EnumBeeBranch.BOGGY, "adorasti", true, new Color(0x546626), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 15), 30) + .setHumidity(EnumHumidity.DAMP); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + + } + + @Override + protected void registerMutations() { + // found in hives + } + }, + MIRY(EnumBeeBranch.BOGGY, "humidium", true, new Color(0x92AF42), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 15), 36) + .setHumidity(EnumHumidity.DAMP); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityMaximum; + template[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolTrue; + template[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; + } + + @Override + protected void registerMutations() { + registerMutation(MARSHY, NOBLE, 15) + .setTemperatureRainfall(0.75f, 0.94f, 0.75f, 2.0f); + } + }, + BOGGY(EnumBeeBranch.BOGGY, "paluster", true, new Color(0x698948), new Color(0xffdc16)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 15), 39) + .addSpecialty(ForestryItem.peat.getItemStack(), 8) + .setHumidity(EnumHumidity.DAMP); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolTrue; + template[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectMycophilic; + template[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLarger; + } + + @Override + protected void registerMutations() { + registerMutation(MARSHY, MIRY, 9) + .setTemperatureRainfall(0.75f, 0.94f, 0.75f, 2.0f); + } + }, + + /* MONASTIC BRANCH */ + MONASTIC(EnumBeeBranch.MONASTIC, "monachus", false, new Color(0x42371c), new Color(0xfff7b6)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 14), 30) + .addSpecialty(ForestryItem.beeComb.getItemStack(1, 16), 10) + .setJubilanceProvider(new JubilanceProviderHermit()); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + + } + + @Override + protected void registerMutations() { + // can only be bought from Apiarist Villagers + } + }, + SECLUDED(EnumBeeBranch.MONASTIC, "contractus", true, new Color(0x7b6634), new Color(0xfff7b6)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addSpecialty(ForestryItem.beeComb.getItemStack(1, 16), 20) + .setJubilanceProvider(new JubilanceProviderHermit()); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFastest; + } + + @Override + protected void registerMutations() { + registerMutation(MONASTIC, AUSTERE, 12); + } + }, + HERMITIC(EnumBeeBranch.MONASTIC, "anachoreta", false, new Color(0xffd46c), new Color(0xfff7b6)) { + @Override + protected void setSpeciesProperties(AlleleBeeSpecies beeSpecies) { + beeSpecies.addSpecialty(ForestryItem.beeComb.getItemStack(1, 16), 20) + .setJubilanceProvider(new JubilanceProviderHermit()) + .setHasEffect(); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFastest; + template[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectRepulsion; + } + + @Override + protected void registerMutations() { + registerMutation(MONASTIC, SECLUDED, 8); + } + }; + + public static final EnumSet overworldHiveBees = EnumSet.of(FOREST, MARSHY, MEADOWS, MODEST, TROPICAL, WINTRY); + + private final EnumBeeBranch branch; + private final AlleleBeeSpecies species; + private IAllele[] template; + private IBeeGenome genome; + + BeeDefinition(EnumBeeBranch branch, String binomial, boolean dominant, Color primary, Color secondary) { + String lowercaseName = this.toString().toLowerCase(Locale.ENGLISH); + String uid = "species" + WordUtils.capitalize(lowercaseName); + String name = "bees.species." + lowercaseName; + + this.species = new AlleleBeeSpecies(uid, dominant, name, branch.getBranch(), binomial, primary.getRGB(), secondary.getRGB()); + this.branch = branch; + } + + protected abstract void setSpeciesProperties(AlleleBeeSpecies beeSpecies); + + protected abstract void initializeTemplate(IAllele[] template); + + public static void initBees() { + for (BeeDefinition bee : values()) { + bee.init(); + } + for (BeeDefinition bee : values()) { + bee.registerMutations(); + } + } + + private void init() { + if (!overworldHiveBees.contains(this)) { + species.setIsSecret(); + } + setSpeciesProperties(species); + + template = branch.getTemplate(); + template[EnumBeeChromosome.SPECIES.ordinal()] = species; + initializeTemplate(template); + + genome = PluginApiculture.beeInterface.templateAsGenome(template); + + AlleleManager.alleleRegistry.registerAllele(species); + PluginApiculture.beeInterface.registerTemplate(template); + } + + protected abstract void registerMutations(); + + protected final BeeMutation registerMutation(BeeDefinition parent1, BeeDefinition parent2, int chance) { + BeeMutation beeMutation = new BeeMutation(parent1, parent2, this, chance); + PluginApiculture.beeInterface.registerMutation(beeMutation); + return beeMutation; + } + + protected final BeeMutation registerMutationTimeLimited(BeeDefinition parent1, BeeDefinition parent2, int chance, int startMonth, int startDay, int endMonth, int endDay) { + MutationTimeLimited.DayMonth start = new MutationTimeLimited.DayMonth(startDay, startMonth); + MutationTimeLimited.DayMonth end = new MutationTimeLimited.DayMonth(endDay, endMonth); + + MutationTimeLimited beeMutation = new MutationTimeLimited(parent1, parent2, this, chance, start, end); + PluginApiculture.beeInterface.registerMutation(beeMutation); + return beeMutation; + } + + @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 PluginApiculture.beeInterface.getMemberStack(bee, beeType.ordinal()); + } + + public final IBeeDefinition getRainResist() { + return new BeeVariation.RainResist(this); + } +} diff --git a/src/main/java/forestry/apiculture/genetics/BeeHelper.java b/src/main/java/forestry/apiculture/genetics/BeeHelper.java index 02e574d5b..94289683b 100755 --- a/src/main/java/forestry/apiculture/genetics/BeeHelper.java +++ b/src/main/java/forestry/apiculture/genetics/BeeHelper.java @@ -221,7 +221,7 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot { @Override public IAllele[] getDefaultTemplate() { - return BeeTemplates.getDefaultTemplate(); + return EnumBeeBranch.HONEY.getTemplate(); } /* MUTATIONS */ diff --git a/src/main/java/forestry/apiculture/genetics/BeeMutation.java b/src/main/java/forestry/apiculture/genetics/BeeMutation.java index 3d01d4e2d..303d4917d 100755 --- a/src/main/java/forestry/apiculture/genetics/BeeMutation.java +++ b/src/main/java/forestry/apiculture/genetics/BeeMutation.java @@ -11,6 +11,7 @@ package forestry.apiculture.genetics; import java.util.ArrayList; +import java.util.List; import net.minecraft.world.World; import net.minecraft.world.biome.BiomeGenBase; @@ -21,32 +22,25 @@ import forestry.api.apiculture.IBeeGenome; import forestry.api.apiculture.IBeeHousing; import forestry.api.apiculture.IBeeMutation; import forestry.api.apiculture.IBeeRoot; -import forestry.api.genetics.AlleleManager; import forestry.api.genetics.IAllele; import forestry.api.genetics.IGenome; import forestry.core.genetics.Mutation; import forestry.plugins.PluginApiculture; public class BeeMutation extends Mutation implements IBeeMutation { - - private final IBeeRoot root; - boolean requiresDay = false; boolean requiresNight = false; - private final ArrayList restrictBiomeTypes = new ArrayList(); + private final List restrictBiomeTypes = new ArrayList(); private boolean strictBiomeCheck = false; - public BeeMutation(IAllele allele0, IAllele allele1, IAllele[] template, int chance) { - super(allele0, allele1, template, chance); - - root = (IBeeRoot) AlleleManager.alleleRegistry.getSpeciesRoot("rootBees"); - PluginApiculture.beeInterface.registerMutation(this); + public BeeMutation(BeeDefinition bee0, BeeDefinition bee1, BeeDefinition result, int chance) { + super(bee0.getGenome().getPrimary(), bee1.getGenome().getPrimary(), result.getTemplate(), chance); } @Override public IBeeRoot getRoot() { - return root; + return PluginApiculture.beeInterface; } public BeeMutation enableStrictBiomeCheck() { @@ -124,10 +118,10 @@ public class BeeMutation extends Mutation implements IBeeMutation { return 0; } - if (this.allele0.getUID().equals(allele0.getUID()) && this.allele1.getUID().equals(allele1.getUID())) { + if (this.species0.getUID().equals(allele0.getUID()) && this.species1.getUID().equals(allele1.getUID())) { return processedChance; } - if (this.allele1.getUID().equals(allele0.getUID()) && this.allele0.getUID().equals(allele1.getUID())) { + if (this.species1.getUID().equals(allele0.getUID()) && this.species0.getUID().equals(allele1.getUID())) { return processedChance; } diff --git a/src/main/java/forestry/apiculture/genetics/BeeTemplates.java b/src/main/java/forestry/apiculture/genetics/BeeTemplates.java deleted file mode 100755 index 2132adaa9..000000000 --- a/src/main/java/forestry/apiculture/genetics/BeeTemplates.java +++ /dev/null @@ -1,640 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2011-2014 SirSengir. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser Public License v3 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl-3.0.txt - * - * Various Contributors including, but not limited to: - * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges - ******************************************************************************/ -package forestry.apiculture.genetics; - -import java.util.Arrays; - -import forestry.api.apiculture.EnumBeeChromosome; -import forestry.api.genetics.IAllele; -import forestry.api.genetics.IMutation; -import forestry.core.genetics.Allele; - -public class BeeTemplates { - - // / MUTATIONS - public static IMutation commonA; - - public static IMutation commonB; - public static IMutation commonC; - - public static IMutation commonD; - public static IMutation commonE; - public static IMutation commonF; - - public static IMutation commonG; - public static IMutation commonH; - public static IMutation commonI; - public static IMutation commonJ; - - public static IMutation commonK; - public static IMutation commonL; - public static IMutation commonM; - public static IMutation commonN; - public static IMutation commonO; - - public static IMutation cultivatedA; - public static IMutation cultivatedB; - public static IMutation cultivatedC; - public static IMutation cultivatedD; - public static IMutation cultivatedE; - public static IMutation cultivatedF; - - public static IMutation nobleA; - public static IMutation majesticA; - public static IMutation imperialA; - - public static IMutation diligentA; - public static IMutation unwearyA; - public static IMutation industriousA; - - public static IMutation heroicA; - - public static IMutation sinisterA; - public static IMutation sinisterB; - public static IMutation fiendishA; - public static IMutation fiendishB; - public static IMutation fiendishC; - public static IMutation demonicA; - - // Austere branch - public static IMutation frugalA; - public static IMutation frugalB; - public static IMutation austereA; - - // Tropical branch - public static IMutation exoticA; - public static IMutation edenicA; - - // Wintry branch - public static IMutation icyA; - public static IMutation glacialA; - - // Festive branch - public static IMutation leporineA; - public static IMutation merryA; - public static IMutation tipsyA; - public static IMutation trickyA; - - // Agrarian branch - public static IMutation ruralA; - - // Monastic branch - public static IMutation secludedA; - public static IMutation hermiticA; - - // End branch - public static IMutation spectralA; - public static IMutation phantasmalA; - - public static IMutation vindictiveA; - - public static IMutation vengefulA; - public static IMutation vengefulB; - public static IMutation avengingA; - - public static IAllele[] defaultTemplate; - - public static IAllele[] getDefaultTemplate() { - if (defaultTemplate == null) { - defaultTemplate = new IAllele[EnumBeeChromosome.values().length]; - - defaultTemplate[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesForest; - defaultTemplate[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest; - defaultTemplate[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShorter; - defaultTemplate[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityNormal; - defaultTemplate[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceNone; - defaultTemplate[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolFalse; - defaultTemplate[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceNone; - defaultTemplate[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolFalse; - defaultTemplate[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolFalse; - defaultTemplate[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersVanilla; - defaultTemplate[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlowest; - defaultTemplate[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryDefault; - defaultTemplate[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectNone; - } - return Arrays.copyOf(defaultTemplate, defaultTemplate.length); - } - - // / COMMON BRANCH - - public static IAllele[] getForestTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlower; - alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityHigh; - return alleles; - } - - public static IAllele[] getForestRainResistTemplate() { - IAllele[] alleles = getForestTemplate(); - alleles[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolTrue; - return alleles; - } - - public static IAllele[] getMeadowsTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesMeadows; - alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlower; - return alleles; - } - - public static IAllele[] getCommonTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesCommon; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - return alleles; - } - - public static IAllele[] getCultivatedTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesCultivated; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedFast; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShortest; - return alleles; - } - - // / NOBLE BRANCH - - public static IAllele[] getNobleTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesNoble; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; - alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlow; - return alleles; - } - - public static IAllele[] getMajesticTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesMajestic; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShortened; - alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityMaximum; - return alleles; - } - - public static IAllele[] getImperialTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesImperial; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectBeatific; - return alleles; - } - - // / INDUSTRIOUS BRANCH - - public static IAllele[] getDiligentTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesDiligent; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; - alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlow; - return alleles; - } - - public static IAllele[] getUnwearyTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesUnweary; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShortened; - return alleles; - } - - public static IAllele[] getIndustriousTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesIndustrious; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; - alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFast; - return alleles; - } - - // / HEROIC BRANCH - - public static IAllele[] getSteadfastTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesSteadfast; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; - alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolTrue; - return alleles; - } - - public static IAllele[] getValiantTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesValiant; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong; - alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolTrue; - return alleles; - } - - public static IAllele[] getHeroicTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesHeroic; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong; - alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectHeroic; - return alleles; - } - - // / INFERNAL BRANCH - - public static IAllele[] getBranchInfernalTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceDown2; - alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersNether; - alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringAverage; - return alleles; - } - - public static IAllele[] getSinisterTemplate() { - IAllele[] alleles = getBranchInfernalTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesSinister; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectAggressive; - return alleles; - } - - public static IAllele[] getFiendishTemplate() { - IAllele[] alleles = getBranchInfernalTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesFiendish; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectAggressive; - return alleles; - } - - public static IAllele[] getDemonicTemplate() { - IAllele[] alleles = getBranchInfernalTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesDemonic; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectIgnition; - return alleles; - } - - // / AUSTERE BRANCH - - public static IAllele[] getAustereBranchTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth1; - alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceDown1; - alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersCacti; - return alleles; - } - - public static IAllele[] getModestTemplate() { - IAllele[] alleles = getAustereBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesModest; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; - return alleles; - } - - public static IAllele[] getFrugalTemplate() { - IAllele[] alleles = getAustereBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesFrugal; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong; - return alleles; - } - - public static IAllele[] getAustereTemplate() { - IAllele[] alleles = getAustereBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesAustere; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger; - alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceDown2; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectCreeper; - return alleles; - } - - // / TROPICAL BRANCH - public static IAllele[] getTropicalBranchTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceUp1; - alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceUp1; - alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersJungle; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectMiasmic; - return alleles; - } - - public static IAllele[] getTropicalTemplate() { - IAllele[] alleles = getTropicalBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesTropical; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; - return alleles; - } - - public static IAllele[] getExoticTemplate() { - IAllele[] alleles = getTropicalBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesExotic; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong; - return alleles; - } - - public static IAllele[] getEdenicTemplate() { - IAllele[] alleles = getTropicalBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesEdenic; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger; - alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth2; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectExploration; - return alleles; - } - - // / END BRANCH - public static IAllele[] getEndBranchTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityLow; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger; - alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceUp1; - alleles[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLarge; - alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersEnd; - alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectMisanthrope; - return alleles; - } - - public static IAllele[] getEnderTemplate() { - IAllele[] alleles = getEndBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesEnded; - return alleles; - } - - public static IAllele[] getSpectralTemplate() { - IAllele[] alleles = getEndBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesSpectral; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectReanimation; - return alleles; - } - - public static IAllele[] getPhantasmalTemplate() { - IAllele[] alleles = getEndBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesPhantasmal; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLongest; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectResurrection; - return alleles; - } - - // / FROZEN BRANCH - public static IAllele[] getFrozenBranchTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceUp1; - alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth1; - alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersSnow; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectGlacial; - return alleles; - } - - public static IAllele[] getWintryTemplate() { - IAllele[] alleles = getFrozenBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesWintry; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; - alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityMaximum; - return alleles; - } - - public static IAllele[] getIcyTemplate() { - IAllele[] alleles = getFrozenBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesIcy; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; - return alleles; - } - - public static IAllele[] getGlacialTemplate() { - IAllele[] alleles = getFrozenBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesGlacial; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShort; - return alleles; - } - - // / VENGEFUL BRANCH - public static IAllele[] getVengefulBranchTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLargest; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectRadioactive; - return alleles; - } - - public static IAllele[] getVindictiveTemplate() { - IAllele[] alleles = getVengefulBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesVindictive; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; - return alleles; - } - - public static IAllele[] getVengefulTemplate() { - IAllele[] alleles = getVengefulBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesVengeful; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedNorm; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger; - return alleles; - } - - public static IAllele[] getAvengingTemplate() { - IAllele[] alleles = getVengefulBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesAvenging; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLongest; - return alleles; - } - - // / REDDENED BRANCH - public static IAllele[] getReddenedBranchTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; - alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth2; - alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth1; - return alleles; - } - - public static IAllele[] getDarkenedTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesDarkened; - return alleles; - } - - public static IAllele[] getReddenedTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesReddened; - return alleles; - } - - public static IAllele[] getOmegaTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesOmega; - return alleles; - } - - // / FESTIVE BRANCH - public static IAllele[] getFestiveBranchTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth2; - alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth1; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; - return alleles; - } - - public static IAllele[] getLeporineTemplate() { - IAllele[] alleles = getFestiveBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesLeporine; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectFestiveEaster; - return alleles; - } - - public static IAllele[] getMerryTemplate() { - IAllele[] alleles = getFestiveBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesMerry; - alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectSnowing; - return alleles; - } - - public static IAllele[] getTipsyTemplate() { - IAllele[] alleles = getFestiveBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesTipsy; - alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectDrunkard; - return alleles; - } - - public static IAllele[] getTrickyTemplate() { - IAllele[] alleles = getFestiveBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesTricky; - alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersGourd; - return alleles; - } - - // / AGRARIAN BRANCH - public static IAllele[] getAgrarianBranchTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShorter; - alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersWheat; - alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFaster; - return alleles; - } - - public static IAllele[] getRuralTemplate() { - IAllele[] alleles = getAgrarianBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesRural; - return alleles; - } - - public static IAllele[] getFarmerlyTemplate() { - IAllele[] alleles = getAgrarianBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesFarmerly; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow; - alleles[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLarge; - return alleles; - } - - public static IAllele[] getAgrarianTemplate() { - IAllele[] alleles = getAgrarianBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesArgrarian; - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlow; - alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth2; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectFertile; - alleles[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLarge; - return alleles; - } - - // / BOGGY BRANCH - public static IAllele[] getBoggyBranchTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersMushrooms; - alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlower; - alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth1; - return alleles; - } - - public static IAllele[] getMarshyTemplate() { - IAllele[] alleles = getBoggyBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesMarshy; - return alleles; - } - - public static IAllele[] getMiryTemplate() { - IAllele[] alleles = getBoggyBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesMiry; - alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityMaximum; - alleles[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; - return alleles; - } - - public static IAllele[] getBoggyTemplate() { - IAllele[] alleles = getBoggyBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesBoggy; - alleles[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectMycophilic; - alleles[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLarger; - return alleles; - } - - /* MONASTIC BRANCH */ - public static IAllele[] getMonasticBranchTemplate() { - IAllele[] alleles = getDefaultTemplate(); - alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; - alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong; - alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityLow; - alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFaster; - alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth1; - alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth1; - alleles[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolTrue; - alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersWheat; - return alleles; - } - - public static IAllele[] getMonasticTemplate() { - IAllele[] alleles = getMonasticBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesMonastic; - return alleles; - } - - public static IAllele[] getSecludedTemplate() { - IAllele[] alleles = getMonasticBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesSecluded; - alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFastest; - return alleles; - } - - public static IAllele[] getHermiticTemplate() { - IAllele[] alleles = getMonasticBranchTemplate(); - alleles[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesHermitic; - alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFastest; - alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectRepulsion; - return alleles; - } - -} diff --git a/src/main/java/forestry/apiculture/genetics/BeeVariation.java b/src/main/java/forestry/apiculture/genetics/BeeVariation.java new file mode 100644 index 000000000..f6c0bcc4b --- /dev/null +++ b/src/main/java/forestry/apiculture/genetics/BeeVariation.java @@ -0,0 +1,57 @@ +package forestry.apiculture.genetics; + +import net.minecraft.item.ItemStack; + +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.apiculture.EnumBeeType; +import forestry.api.apiculture.IBee; +import forestry.api.apiculture.IBeeGenome; +import forestry.api.genetics.IAllele; +import forestry.core.genetics.Allele; +import forestry.plugins.PluginApiculture; + +public abstract class BeeVariation implements IBeeDefinition { + + private final IAllele[] template; + private final IBeeGenome genome; + + public BeeVariation(IBeeDefinition bee) { + template = bee.getTemplate(); + initializeTemplate(template); + genome = PluginApiculture.beeInterface.templateAsGenome(template); + } + + protected abstract void initializeTemplate(IAllele[] template); + + @Override + public IAllele[] getTemplate() { + return template; + } + + @Override + public IBeeGenome getGenome() { + return genome; + } + + @Override + public IBee getIndividual() { + return new Bee(genome); + } + + @Override + public final ItemStack getMemberStack(EnumBeeType beeType) { + IBee bee = getIndividual(); + return PluginApiculture.beeInterface.getMemberStack(bee, beeType.ordinal()); + } + + public static class RainResist extends BeeVariation { + public RainResist(IBeeDefinition bee) { + super(bee); + } + + @Override + protected void initializeTemplate(IAllele[] template) { + template[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolTrue; + } + } +} diff --git a/src/main/java/forestry/apiculture/genetics/EnumBeeBranch.java b/src/main/java/forestry/apiculture/genetics/EnumBeeBranch.java new file mode 100644 index 000000000..de7a04a7d --- /dev/null +++ b/src/main/java/forestry/apiculture/genetics/EnumBeeBranch.java @@ -0,0 +1,153 @@ +package forestry.apiculture.genetics; + +import java.util.Arrays; + +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.genetics.IAllele; +import forestry.core.genetics.Allele; + +public enum EnumBeeBranch { + HONEY("Apis"), + NOBLE("Probapis"), + INDUSTRIOUS("Industrapis"), + HEROIC("Herapis"), + INFERNAL("Diapis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceDown2; + alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; + alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersNether; + alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringAverage; + } + }, + AUSTERE("Modapis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth1; + alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceDown1; + alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; + alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersCacti; + } + }, + TROPICAL("Caldapis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceUp1; + alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceUp1; + alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersJungle; + alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectMiasmic; + } + }, + END("Finapis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityLow; + alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLonger; + alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceUp1; + alleles[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLarge; + alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersEnd; + alleles[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolTrue; + alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectMisanthrope; + } + }, + FROZEN("Coagapis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceUp1; + alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth1; + alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersSnow; + alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectGlacial; + } + }, + VENGEFUL("Punapis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + alleles[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryLargest; + alleles[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectRadioactive; + } + }, + FESTIVE("Festapis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth2; + alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth1; + alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanNormal; + } + }, + AGRARIAN("Rustapis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShorter; + alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersWheat; + alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFaster; + } + }, + BOGGY("Paludapis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersMushrooms; + alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlower; + alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth1; + } + }, + MONASTIC("Monapis") { + @Override + protected void setBranchProperties(IAllele[] alleles) { + alleles[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlower; + alleles[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanLong; + alleles[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityLow; + alleles[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringFaster; + alleles[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceBoth1; + alleles[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceBoth1; + alleles[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolTrue; + alleles[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersWheat; + } + } + ; + + private final BranchBees branch; + + EnumBeeBranch(String scientific) { + branch = new BranchBees(this.name().toLowerCase(), scientific); + } + + protected void setBranchProperties(IAllele[] template) { + + } + + public final IAllele[] getTemplate() { + IAllele[] template = getDefaultTemplate(); + setBranchProperties(template); + return template; + } + + public final BranchBees getBranch() { + return branch; + } + + private static IAllele[] defaultTemplate; + + private static IAllele[] getDefaultTemplate() { + if (defaultTemplate == null) { + defaultTemplate = new IAllele[EnumBeeChromosome.values().length]; + + defaultTemplate[EnumBeeChromosome.SPECIES.ordinal()] = Allele.speciesForest; + defaultTemplate[EnumBeeChromosome.SPEED.ordinal()] = Allele.speedSlowest; + defaultTemplate[EnumBeeChromosome.LIFESPAN.ordinal()] = Allele.lifespanShorter; + defaultTemplate[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.fertilityNormal; + defaultTemplate[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.toleranceNone; + defaultTemplate[EnumBeeChromosome.NOCTURNAL.ordinal()] = Allele.boolFalse; + defaultTemplate[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.toleranceNone; + defaultTemplate[EnumBeeChromosome.TOLERANT_FLYER.ordinal()] = Allele.boolFalse; + defaultTemplate[EnumBeeChromosome.CAVE_DWELLING.ordinal()] = Allele.boolFalse; + defaultTemplate[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowersVanilla; + defaultTemplate[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.floweringSlowest; + defaultTemplate[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.territoryDefault; + defaultTemplate[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectNone; + } + return Arrays.copyOf(defaultTemplate, defaultTemplate.length); + } +} diff --git a/src/main/java/forestry/apiculture/genetics/HiveDrop.java b/src/main/java/forestry/apiculture/genetics/HiveDrop.java index bd4c02c8b..84bc7da4f 100755 --- a/src/main/java/forestry/apiculture/genetics/HiveDrop.java +++ b/src/main/java/forestry/apiculture/genetics/HiveDrop.java @@ -12,6 +12,7 @@ package forestry.apiculture.genetics; import java.util.ArrayList; import java.util.Collections; +import java.util.List; import net.minecraft.item.ItemStack; import net.minecraft.world.World; @@ -19,18 +20,17 @@ import net.minecraft.world.World; import forestry.api.apiculture.EnumBeeType; import forestry.api.apiculture.IBee; import forestry.api.apiculture.IHiveDrop; -import forestry.api.genetics.IAllele; import forestry.plugins.PluginApiculture; public class HiveDrop implements IHiveDrop { - private final IAllele[] template; + private final IBeeDefinition beeTemplate; private final ArrayList additional = new ArrayList(); private final int chance; private float ignobleShare = 0.0f; - public HiveDrop(int chance, IAllele[] template, ItemStack... bonus) { - this.template = template; + public HiveDrop(int chance, IBeeDefinition beeTemplate, ItemStack... bonus) { + this.beeTemplate = beeTemplate; this.chance = chance; Collections.addAll(this.additional, bonus); @@ -41,13 +41,9 @@ public class HiveDrop implements IHiveDrop { return this; } - private IBee createBee(World world) { - return PluginApiculture.beeInterface.getBee(world, PluginApiculture.beeInterface.templateAsGenome(template)); - } - @Override public ItemStack getPrincess(World world, int x, int y, int z, int fortune) { - IBee bee = createBee(world); + IBee bee = beeTemplate.getIndividual(); if (world.rand.nextFloat() < ignobleShare) { bee.setIsNatural(false); } @@ -56,10 +52,9 @@ public class HiveDrop implements IHiveDrop { } @Override - public ArrayList getDrones(World world, int x, int y, int z, int fortune) { - ArrayList ret = new ArrayList(); - ret.add(PluginApiculture.beeInterface.getMemberStack(createBee(world), EnumBeeType.DRONE.ordinal())); - return ret; + public List getDrones(World world, int x, int y, int z, int fortune) { + ItemStack drone = beeTemplate.getMemberStack(EnumBeeType.DRONE); + return Collections.singletonList(drone); } @Override diff --git a/src/main/java/forestry/apiculture/genetics/IBeeDefinition.java b/src/main/java/forestry/apiculture/genetics/IBeeDefinition.java new file mode 100644 index 000000000..858591732 --- /dev/null +++ b/src/main/java/forestry/apiculture/genetics/IBeeDefinition.java @@ -0,0 +1,18 @@ +package forestry.apiculture.genetics; + +import net.minecraft.item.ItemStack; + +import forestry.api.apiculture.EnumBeeType; +import forestry.api.apiculture.IBee; +import forestry.api.apiculture.IBeeGenome; +import forestry.core.genetics.IGeneticDefinition; + +public interface IBeeDefinition extends IGeneticDefinition { + @Override + IBeeGenome getGenome(); + + @Override + IBee getIndividual(); + + ItemStack getMemberStack(EnumBeeType beeType); +} diff --git a/src/main/java/forestry/apiculture/genetics/MutationEMC.java b/src/main/java/forestry/apiculture/genetics/MutationEMC.java index c00e65ec3..f001199e6 100755 --- a/src/main/java/forestry/apiculture/genetics/MutationEMC.java +++ b/src/main/java/forestry/apiculture/genetics/MutationEMC.java @@ -28,9 +28,8 @@ public class MutationEMC extends MutationReqRes { private final Class condenserClass; private final Field emcField; - public MutationEMC(IAllele allele0, IAllele allele1, IAllele[] template, int chance, ItemStack blockRequired, Class condenserClass, Field emcField, - int emcRequired) { - super(allele0, allele1, template, chance, blockRequired); + public MutationEMC(BeeDefinition bee0, BeeDefinition bee1, BeeDefinition result, int chance, ItemStack blockRequired, Class condenserClass, Field emcField, int emcRequired) { + super(bee0, bee1, result, chance, blockRequired); this.condenserClass = condenserClass; this.emcField = emcField; diff --git a/src/main/java/forestry/apiculture/genetics/MutationReqRes.java b/src/main/java/forestry/apiculture/genetics/MutationReqRes.java index abbd62af5..313801025 100755 --- a/src/main/java/forestry/apiculture/genetics/MutationReqRes.java +++ b/src/main/java/forestry/apiculture/genetics/MutationReqRes.java @@ -23,8 +23,8 @@ public class MutationReqRes extends BeeMutation { private final ItemStack blockRequired; - public MutationReqRes(IAllele allele0, IAllele allele1, IAllele[] template, int chance, ItemStack blockRequired) { - super(allele0, allele1, template, chance); + public MutationReqRes(BeeDefinition bee0, BeeDefinition bee1, BeeDefinition result, int chance, ItemStack blockRequired) { + super(bee0, bee1, result, chance); this.blockRequired = blockRequired; } diff --git a/src/main/java/forestry/apiculture/genetics/MutationTimeLimited.java b/src/main/java/forestry/apiculture/genetics/MutationTimeLimited.java index 593681735..f3509370e 100755 --- a/src/main/java/forestry/apiculture/genetics/MutationTimeLimited.java +++ b/src/main/java/forestry/apiculture/genetics/MutationTimeLimited.java @@ -107,12 +107,9 @@ public class MutationTimeLimited extends BeeMutation { private final DayMonth start; private final DayMonth end; - public MutationTimeLimited(IAllele allele0, IAllele allele1, IAllele[] template, int chance, DayMonth start) { - this(allele0, allele1, template, chance, start, null); - } + protected MutationTimeLimited(BeeDefinition bee0, BeeDefinition bee1, BeeDefinition result, int chance, DayMonth start, DayMonth end) { + super(bee0, bee1, result, chance); - public MutationTimeLimited(IAllele allele0, IAllele allele1, IAllele[] template, int chance, DayMonth start, DayMonth end) { - super(allele0, allele1, template, chance); this.start = start; this.end = end; } diff --git a/src/main/java/forestry/apiculture/worldgen/HiveDescription.java b/src/main/java/forestry/apiculture/worldgen/HiveDescription.java index 358eb9a00..82e89750c 100644 --- a/src/main/java/forestry/apiculture/worldgen/HiveDescription.java +++ b/src/main/java/forestry/apiculture/worldgen/HiveDescription.java @@ -26,24 +26,22 @@ import forestry.api.core.EnumHumidity; import forestry.api.core.EnumTemperature; import forestry.api.genetics.AlleleManager; import forestry.api.genetics.EnumTolerance; -import forestry.api.genetics.IAllele; -import forestry.apiculture.genetics.BeeTemplates; +import forestry.apiculture.genetics.BeeDefinition; import forestry.core.config.ForestryBlock; -import forestry.plugins.PluginApiculture; public enum HiveDescription implements IHiveDescription { - FOREST(1, 3.0f, BeeTemplates.getForestTemplate(), HiveManager.genHelper.tree()), - MEADOWS(2, 1.0f, BeeTemplates.getMeadowsTemplate(), HiveManager.genHelper.ground(Blocks.dirt, Blocks.grass)), - DESERT(3, 1.0f, BeeTemplates.getModestTemplate(), HiveManager.genHelper.ground(Blocks.dirt, Blocks.grass, Blocks.sand, Blocks.sandstone)), - JUNGLE(4, 4.0f, BeeTemplates.getTropicalTemplate(), HiveManager.genHelper.tree()), - END(5, 4.0f, BeeTemplates.getEnderTemplate(), HiveManager.genHelper.ground(Blocks.end_stone)) { + FOREST(1, 3.0f, BeeDefinition.FOREST, HiveManager.genHelper.tree()), + MEADOWS(2, 1.0f, BeeDefinition.MEADOWS, HiveManager.genHelper.ground(Blocks.dirt, Blocks.grass)), + DESERT(3, 1.0f, BeeDefinition.MODEST, HiveManager.genHelper.ground(Blocks.dirt, Blocks.grass, Blocks.sand, Blocks.sandstone)), + JUNGLE(4, 4.0f, BeeDefinition.TROPICAL, HiveManager.genHelper.tree()), + END(5, 4.0f, BeeDefinition.ENDED, HiveManager.genHelper.ground(Blocks.end_stone)) { @Override public boolean isGoodBiome(BiomeGenBase biome) { return BiomeDictionary.isBiomeOfType(biome, BiomeDictionary.Type.END); } }, - SNOW(6, 2.0f, BeeTemplates.getWintryTemplate(), HiveManager.genHelper.ground(Blocks.dirt, Blocks.grass, Blocks.snow)) { + SNOW(6, 2.0f, BeeDefinition.WINTRY, HiveManager.genHelper.ground(Blocks.dirt, Blocks.grass, Blocks.snow)) { @Override public void postGen(World world, int x, int y, int z) { if (world.isAirBlock(x, y + 1, z)) { @@ -51,17 +49,17 @@ public enum HiveDescription implements IHiveDescription { } } }, - SWAMP(7, 2.0f, BeeTemplates.getMarshyTemplate(), HiveManager.genHelper.ground(Blocks.dirt, Blocks.grass)),; + SWAMP(7, 2.0f, BeeDefinition.MARSHY, HiveManager.genHelper.ground(Blocks.dirt, Blocks.grass)),; private final int meta; private final float genChance; private final IBeeGenome beeGenome; private final IHiveGen hiveGen; - HiveDescription(int meta, float genChance, IAllele[] beeTemplate, IHiveGen hiveGen) { + HiveDescription(int meta, float genChance, BeeDefinition beeTemplate, IHiveGen hiveGen) { this.meta = meta; this.genChance = genChance; - this.beeGenome = PluginApiculture.beeInterface.templateAsGenome(beeTemplate); + this.beeGenome = beeTemplate.getGenome(); this.hiveGen = hiveGen; } diff --git a/src/main/java/forestry/arboriculture/genetics/AlleleTreeSpecies.java b/src/main/java/forestry/arboriculture/genetics/AlleleTreeSpecies.java index 6fcc792f6..ec071da66 100755 --- a/src/main/java/forestry/arboriculture/genetics/AlleleTreeSpecies.java +++ b/src/main/java/forestry/arboriculture/genetics/AlleleTreeSpecies.java @@ -93,7 +93,7 @@ public class AlleleTreeSpecies extends AlleleSpecies implements IAlleleTreeSpeci public AlleleTreeSpecies(String uid, boolean isDominant, String name, IClassification branch, String binomial, int primaryColor, int secondaryColor, Class generator, ItemStack wood) { - super(uid, isDominant, "trees.species." + name, branch, binomial); + super(uid, isDominant, "trees.species." + name, branch, binomial, true); this.root = (ITreeRoot) AlleleManager.alleleRegistry.getSpeciesRoot("rootTrees"); this.generatorClass = generator; diff --git a/src/main/java/forestry/arboriculture/genetics/TreeMutation.java b/src/main/java/forestry/arboriculture/genetics/TreeMutation.java index a9bd5ff8a..3fbe8ae92 100755 --- a/src/main/java/forestry/arboriculture/genetics/TreeMutation.java +++ b/src/main/java/forestry/arboriculture/genetics/TreeMutation.java @@ -18,6 +18,7 @@ import forestry.api.arboriculture.ITreeMutation; import forestry.api.arboriculture.ITreeRoot; import forestry.api.genetics.AlleleManager; import forestry.api.genetics.IAllele; +import forestry.api.genetics.IAlleleSpecies; import forestry.api.genetics.IGenome; import forestry.core.genetics.Mutation; import forestry.plugins.PluginArboriculture; @@ -26,7 +27,7 @@ public class TreeMutation extends Mutation implements ITreeMutation { private final ITreeRoot root; - public TreeMutation(IAllele allele0, IAllele allele1, IAllele[] template, int chance) { + public TreeMutation(IAlleleSpecies allele0, IAlleleSpecies allele1, IAllele[] template, int chance) { super(allele0, allele1, template, chance); root = (ITreeRoot) AlleleManager.alleleRegistry.getSpeciesRoot("rootTrees"); @@ -52,10 +53,10 @@ public class TreeMutation extends Mutation implements ITreeMutation { processedChance *= PluginArboriculture.treeInterface.getTreekeepingMode(world).getMutationModifier((ITreeGenome) genome0, (ITreeGenome) genome1, 1f); - if (this.allele0.getUID().equals(allele0.getUID()) && this.allele1.getUID().equals(allele1.getUID())) { + if (this.species0.getUID().equals(allele0.getUID()) && this.species1.getUID().equals(allele1.getUID())) { return processedChance; } - if (this.allele1.getUID().equals(allele0.getUID()) && this.allele0.getUID().equals(allele1.getUID())) { + if (this.species1.getUID().equals(allele0.getUID()) && this.species0.getUID().equals(allele1.getUID())) { return processedChance; } diff --git a/src/main/java/forestry/core/genetics/AlleleSpecies.java b/src/main/java/forestry/core/genetics/AlleleSpecies.java index 65bb2a00e..8c4b8b0c0 100755 --- a/src/main/java/forestry/core/genetics/AlleleSpecies.java +++ b/src/main/java/forestry/core/genetics/AlleleSpecies.java @@ -45,7 +45,7 @@ public abstract class AlleleSpecies extends Allele implements IAlleleSpecies { private EnumTemperature climate = EnumTemperature.NORMAL; private EnumHumidity humidity = EnumHumidity.NORMAL; - public AlleleSpecies(String uid, boolean isDominant, String name, IClassification branch, String binomial) { + public AlleleSpecies(String uid, boolean isDominant, String name, IClassification branch, String binomial, boolean doRegister) { super(uid, isDominant, true); this.branch = branch; @@ -53,7 +53,10 @@ public abstract class AlleleSpecies extends Allele implements IAlleleSpecies { this.binomial = binomial; this.description = StringUtil.localize("description." + uid); - AlleleManager.alleleRegistry.registerAllele(this); + // FIXME: do not register here + if (doRegister) { + AlleleManager.alleleRegistry.registerAllele(this); + } } @Override diff --git a/src/main/java/forestry/core/genetics/Chromosome.java b/src/main/java/forestry/core/genetics/Chromosome.java index b3f5e7d91..77a8db9f3 100755 --- a/src/main/java/forestry/core/genetics/Chromosome.java +++ b/src/main/java/forestry/core/genetics/Chromosome.java @@ -46,20 +46,6 @@ public class Chromosome implements IChromosome { // / SAVING & LOADING @Override public void readFromNBT(NBTTagCompound nbttagcompound) { - - // Legacy - if (nbttagcompound.hasKey("PrimaryId")) { - primary = ((ILegacyHandler) AlleleManager.alleleRegistry).getFromLegacyMap(nbttagcompound.getInteger("PrimaryId")); - secondary = ((ILegacyHandler) AlleleManager.alleleRegistry).getFromLegacyMap(nbttagcompound.getInteger("SecondaryId")); - - if (primary == null || secondary == null) { - throw new RuntimeException("Legacy conversion of chromosome failed. Did one of your bee addons not update? No legacy mapping for ids: " - + nbttagcompound.getInteger("PrimaryId") + " - " + nbttagcompound.getInteger("SecondaryId")); - } - - return; - } - primary = AlleleManager.alleleRegistry.getAllele(nbttagcompound.getString(UID0_TAG)); secondary = AlleleManager.alleleRegistry.getAllele(nbttagcompound.getString(UID1_TAG)); } @@ -82,6 +68,9 @@ public class Chromosome implements IChromosome { @Override public IAllele getActiveAllele() { + if (primary == null || secondary == null) { + Proxies.log.severe("Chromosome is missing alleles"); + } if (primary.isDominant()) { return primary; } diff --git a/src/main/java/forestry/core/genetics/IGeneticDefinition.java b/src/main/java/forestry/core/genetics/IGeneticDefinition.java new file mode 100644 index 000000000..4e58b374f --- /dev/null +++ b/src/main/java/forestry/core/genetics/IGeneticDefinition.java @@ -0,0 +1,16 @@ +package forestry.core.genetics; + +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IAlleleSpecies; +import forestry.api.genetics.IGenome; +import forestry.api.genetics.IIndividual; + +public interface IGeneticDefinition { + + IAllele[] getTemplate(); + + IGenome getGenome(); + + IIndividual getIndividual(); + +} diff --git a/src/main/java/forestry/core/genetics/Mutation.java b/src/main/java/forestry/core/genetics/Mutation.java index 2c2f58678..d205640bd 100755 --- a/src/main/java/forestry/core/genetics/Mutation.java +++ b/src/main/java/forestry/core/genetics/Mutation.java @@ -10,13 +10,13 @@ ******************************************************************************/ package forestry.core.genetics; - import java.util.ArrayList; import java.util.Collection; import forestry.api.core.EnumHumidity; import forestry.api.core.EnumTemperature; import forestry.api.genetics.IAllele; +import forestry.api.genetics.IAlleleSpecies; import forestry.api.genetics.IMutation; public abstract class Mutation implements IMutation { @@ -24,8 +24,8 @@ public abstract class Mutation implements IMutation { protected final int chance; boolean isSecret = false; - protected final IAllele allele0; - protected final IAllele allele1; + protected final IAllele species0; + protected final IAllele species1; private final IAllele[] template; @@ -36,9 +36,9 @@ public abstract class Mutation implements IMutation { protected final ArrayList specialConditions = new ArrayList(); - public Mutation(IAllele allele0, IAllele allele1, IAllele[] template, int chance) { - this.allele0 = allele0; - this.allele1 = allele1; + public Mutation(IAlleleSpecies species0, IAlleleSpecies species1, IAllele[] template, int chance) { + this.species0 = species0; + this.species1 = species1; this.template = template; this.chance = chance; } @@ -95,12 +95,12 @@ public abstract class Mutation implements IMutation { @Override public IAllele getAllele0() { - return allele0; + return species0; } @Override public IAllele getAllele1() { - return allele1; + return species1; } @Override @@ -115,15 +115,15 @@ public abstract class Mutation implements IMutation { @Override public boolean isPartner(IAllele allele) { - return allele0.getUID().equals(allele.getUID()) || allele1.getUID().equals(allele.getUID()); + return species0.getUID().equals(allele.getUID()) || species1.getUID().equals(allele.getUID()); } @Override public IAllele getPartner(IAllele allele) { - if (allele0.getUID().equals(allele.getUID())) { - return allele1; + if (species0.getUID().equals(allele.getUID())) { + return species1; } else { - return allele0; + return species0; } } diff --git a/src/main/java/forestry/lepidopterology/genetics/AlleleButterflySpecies.java b/src/main/java/forestry/lepidopterology/genetics/AlleleButterflySpecies.java index 21e9b8fca..2c5e19b05 100755 --- a/src/main/java/forestry/lepidopterology/genetics/AlleleButterflySpecies.java +++ b/src/main/java/forestry/lepidopterology/genetics/AlleleButterflySpecies.java @@ -52,7 +52,7 @@ public class AlleleButterflySpecies extends AlleleSpecies implements IAlleleButt private final Map caterpillarLoot = new HashMap(); public AlleleButterflySpecies(String uid, boolean isDominant, String name, IClassification branch, String binomial, int serumColour) { - super(uid, isDominant, "butterflies.species." + branch.getParent().getUID().substring((branch.getParent().getLevel().name().toLowerCase(Locale.ENGLISH)).length() + 1) + "." + name, branch, binomial); + super(uid, isDominant, "butterflies.species." + branch.getParent().getUID().substring((branch.getParent().getLevel().name().toLowerCase(Locale.ENGLISH)).length() + 1) + "." + name, branch, binomial, true); this.root = (IButterflyRoot) AlleleManager.alleleRegistry.getSpeciesRoot("rootButterflies"); this.serumColour = serumColour; texture = "forestry:" + Defaults.TEXTURE_PATH_ENTITIES + "/butterflies/" + uid + ".png"; diff --git a/src/main/java/forestry/plugins/PluginApiculture.java b/src/main/java/forestry/plugins/PluginApiculture.java index 89b054995..cf553d077 100644 --- a/src/main/java/forestry/plugins/PluginApiculture.java +++ b/src/main/java/forestry/plugins/PluginApiculture.java @@ -30,7 +30,6 @@ import net.minecraft.world.World; import net.minecraft.world.chunk.IChunkProvider; import net.minecraftforge.client.event.TextureStitchEvent; -import net.minecraftforge.common.BiomeDictionary; import net.minecraftforge.common.ChestGenHooks; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.oredict.OreDictionary; @@ -49,15 +48,11 @@ import cpw.mods.fml.relauncher.SideOnly; import forestry.api.apiculture.BeeManager; import forestry.api.apiculture.EnumBeeType; import forestry.api.apiculture.FlowerManager; -import forestry.api.apiculture.IBee; import forestry.api.apiculture.IBeeGenome; import forestry.api.apiculture.IBeeRoot; import forestry.api.apiculture.hives.HiveManager; -import forestry.api.core.EnumHumidity; -import forestry.api.core.EnumTemperature; import forestry.api.core.Tabs; import forestry.api.genetics.AlleleManager; -import forestry.api.genetics.IAllele; import forestry.api.genetics.IClassification; import forestry.api.genetics.IClassification.EnumClassLevel; import forestry.api.recipes.RecipeManagers; @@ -86,7 +81,6 @@ import forestry.apiculture.gadgets.TileApiary; import forestry.apiculture.gadgets.TileBeehouse; import forestry.apiculture.gadgets.TileCandle; import forestry.apiculture.gadgets.TileSwarm; -import forestry.apiculture.genetics.AlleleBeeSpecies; import forestry.apiculture.genetics.AlleleEffectAggressive; import forestry.apiculture.genetics.AlleleEffectCreeper; import forestry.apiculture.genetics.AlleleEffectExploration; @@ -104,16 +98,11 @@ import forestry.apiculture.genetics.AlleleEffectRepulsion; import forestry.apiculture.genetics.AlleleEffectResurrection; import forestry.apiculture.genetics.AlleleEffectSnowing; import forestry.apiculture.genetics.AlleleFlowers; -import forestry.apiculture.genetics.Bee; import forestry.apiculture.genetics.BeeHelper; -import forestry.apiculture.genetics.BeeMutation; -import forestry.apiculture.genetics.BeeTemplates; import forestry.apiculture.genetics.BeekeepingMode; -import forestry.apiculture.genetics.BranchBees; +import forestry.apiculture.genetics.BeeDefinition; +import forestry.apiculture.genetics.EnumBeeBranch; import forestry.apiculture.genetics.HiveDrop; -import forestry.apiculture.genetics.JubilanceNone; -import forestry.apiculture.genetics.JubilanceProviderHermit; -import forestry.apiculture.genetics.MutationTimeLimited; import forestry.apiculture.items.ItemAlvearyBlock; import forestry.apiculture.items.ItemArmorApiarist; import forestry.apiculture.items.ItemBeeGE; @@ -143,7 +132,6 @@ import forestry.core.gadgets.BlockBase; import forestry.core.gadgets.MachineDefinition; import forestry.core.gadgets.TileAnalyzer; import forestry.core.genetics.Allele; -import forestry.core.interfaces.IOreDictionaryHandler; import forestry.core.interfaces.IPacketHandler; import forestry.core.interfaces.ISaveEventHandler; import forestry.core.items.ItemForestry; @@ -306,17 +294,15 @@ public class PluginApiculture extends ForestryPlugin { // Genetics createAlleles(); - createMutations(); + BeeDefinition.initBees(); // Hives - registerBeehiveDrops(); createHives(); + registerBeehiveDrops(); // Inducers for swarmer BeeManager.inducers.put(ForestryItem.royalJelly.getItemStack(), 10); - registerTemplates(); - GameRegistry.registerTileEntity(TileAlvearyPlain.class, "forestry.Alveary"); GameRegistry.registerTileEntity(TileSwarm.class, "forestry.Swarm"); GameRegistry.registerTileEntity(TileAlvearySwarmer.class, "forestry.AlvearySwarmer"); @@ -327,16 +313,17 @@ public class PluginApiculture extends ForestryPlugin { GameRegistry.registerTileEntity(TileAlvearySieve.class, "forestry.AlvearySieve"); GameRegistry.registerTileEntity(TileCandle.class, "forestry.Candle"); - BeeManager.villageBees[0].add(beeInterface.templateAsGenome(BeeTemplates.getForestTemplate())); - BeeManager.villageBees[0].add(beeInterface.templateAsGenome(BeeTemplates.getMeadowsTemplate())); - BeeManager.villageBees[0].add(beeInterface.templateAsGenome(BeeTemplates.getModestTemplate())); - BeeManager.villageBees[0].add(beeInterface.templateAsGenome(BeeTemplates.getMarshyTemplate())); - BeeManager.villageBees[0].add(beeInterface.templateAsGenome(BeeTemplates.getWintryTemplate())); - BeeManager.villageBees[0].add(beeInterface.templateAsGenome(BeeTemplates.getTropicalTemplate())); - BeeManager.villageBees[1].add(beeInterface.templateAsGenome(BeeTemplates.getForestRainResistTemplate())); - BeeManager.villageBees[1].add(beeInterface.templateAsGenome(BeeTemplates.getCommonTemplate())); - BeeManager.villageBees[1].add(beeInterface.templateAsGenome(BeeTemplates.getValiantTemplate())); + BeeManager.villageBees[0].add(BeeDefinition.FOREST.getGenome()); + BeeManager.villageBees[0].add(BeeDefinition.MEADOWS.getGenome()); + BeeManager.villageBees[0].add(BeeDefinition.MODEST.getGenome()); + BeeManager.villageBees[0].add(BeeDefinition.MARSHY.getGenome()); + BeeManager.villageBees[0].add(BeeDefinition.WINTRY.getGenome()); + BeeManager.villageBees[0].add(BeeDefinition.TROPICAL.getGenome()); + + BeeManager.villageBees[1].add(BeeDefinition.FOREST.getRainResist().getGenome()); + BeeManager.villageBees[1].add(BeeDefinition.COMMON.getGenome()); + BeeManager.villageBees[1].add(BeeDefinition.VALIANT.getGenome()); if (Config.enableVillager) { // Register villager stuff @@ -708,43 +695,43 @@ public class PluginApiculture extends ForestryPlugin { private static void registerBeehiveDrops() { ItemStack honeyComb = ForestryItem.beeComb.getItemStack(1, 0); hiveRegistry.addDrops(HiveRegistry.forest, - new HiveDrop(80, BeeTemplates.getForestTemplate(), honeyComb).setIgnobleShare(0.7f), - new HiveDrop(8, BeeTemplates.getForestRainResistTemplate(), honeyComb), - new HiveDrop(3, BeeTemplates.getValiantTemplate(), honeyComb) + new HiveDrop(80, BeeDefinition.FOREST, honeyComb).setIgnobleShare(0.7f), + new HiveDrop(8, BeeDefinition.FOREST.getRainResist(), honeyComb), + new HiveDrop(3, BeeDefinition.VALIANT, honeyComb) ); hiveRegistry.addDrops(HiveRegistry.meadows, - new HiveDrop(80, BeeTemplates.getMeadowsTemplate(), honeyComb).setIgnobleShare(0.7f), - new HiveDrop(3, BeeTemplates.getValiantTemplate(), honeyComb) + new HiveDrop(80, BeeDefinition.MEADOWS, honeyComb).setIgnobleShare(0.7f), + new HiveDrop(3, BeeDefinition.VALIANT, honeyComb) ); ItemStack parchedComb = ForestryItem.beeComb.getItemStack(1, 7); hiveRegistry.addDrops(HiveRegistry.desert, - new HiveDrop(80, BeeTemplates.getModestTemplate(), parchedComb).setIgnobleShare(0.7f), - new HiveDrop(3, BeeTemplates.getValiantTemplate(), parchedComb) + new HiveDrop(80, BeeDefinition.MODEST, parchedComb).setIgnobleShare(0.7f), + new HiveDrop(3, BeeDefinition.VALIANT, parchedComb) ); ItemStack silkyComb = ForestryItem.beeComb.getItemStack(1, 6); hiveRegistry.addDrops(HiveRegistry.jungle, - new HiveDrop(80, BeeTemplates.getTropicalTemplate(), silkyComb).setIgnobleShare(0.7f), - new HiveDrop(3, BeeTemplates.getValiantTemplate(), silkyComb) + new HiveDrop(80, BeeDefinition.TROPICAL, silkyComb).setIgnobleShare(0.7f), + new HiveDrop(3, BeeDefinition.VALIANT, silkyComb) ); ItemStack mysteriousComb = ForestryItem.beeComb.getItemStack(1, 8); hiveRegistry.addDrops(HiveRegistry.end, - new HiveDrop(90, BeeTemplates.getEnderTemplate(), mysteriousComb) + new HiveDrop(90, BeeDefinition.ENDED, mysteriousComb) ); ItemStack frozenComb = ForestryItem.beeComb.getItemStack(1, 4); hiveRegistry.addDrops(HiveRegistry.snow, - new HiveDrop(80, BeeTemplates.getWintryTemplate(), frozenComb).setIgnobleShare(0.5f), - new HiveDrop(3, BeeTemplates.getValiantTemplate(), frozenComb) + new HiveDrop(80, BeeDefinition.WINTRY, frozenComb).setIgnobleShare(0.5f), + new HiveDrop(3, BeeDefinition.VALIANT, frozenComb) ); ItemStack mossyComb = ForestryItem.beeComb.getItemStack(1, 15); hiveRegistry.addDrops(HiveRegistry.swamp, - new HiveDrop(80, BeeTemplates.getMarshyTemplate(), mossyComb).setIgnobleShare(0.4f), - new HiveDrop(3, BeeTemplates.getValiantTemplate(), mossyComb) + new HiveDrop(80, BeeDefinition.MARSHY, mossyComb).setIgnobleShare(0.4f), + new HiveDrop(3, BeeDefinition.VALIANT, mossyComb) ); } @@ -756,7 +743,7 @@ public class PluginApiculture extends ForestryPlugin { rarity = 10; } - ChestGenHooks.addItem(ChestGenHooks.DUNGEON_CHEST, new WeightedRandomChestContent(getBeeItemFromTemplate(BeeTemplates.getSteadfastTemplate(), EnumBeeType.DRONE), 1, 1, rarity)); + ChestGenHooks.addItem(ChestGenHooks.DUNGEON_CHEST, new WeightedRandomChestContent(BeeDefinition.STEADFAST.getMemberStack(EnumBeeType.DRONE), 1, 1, rarity)); ItemStack stack = ForestryBlock.candle.getItemStack(); NBTTagCompound tag = new NBTTagCompound(); @@ -770,28 +757,9 @@ public class PluginApiculture extends ForestryPlugin { ChestGenHooks.addItem(Defaults.CHEST_GEN_HOOK_NATURALIST_CHEST, new WeightedRandomChestContent(ForestryItem.beeComb.getItemStack(1, 4), 2, 10, 7)); ChestGenHooks.addItem(Defaults.CHEST_GEN_HOOK_NATURALIST_CHEST, new WeightedRandomChestContent(ForestryItem.beeComb.getItemStack(1, 6), 1, 6, 7)); - ChestGenHooks.addItem(Defaults.CHEST_GEN_HOOK_NATURALIST_CHEST, new WeightedRandomChestContent(getBeeItemFromTemplate(BeeTemplates.getForestRainResistTemplate(), EnumBeeType.PRINCESS), 1, 1, 5)); - ChestGenHooks.addItem(Defaults.CHEST_GEN_HOOK_NATURALIST_CHEST, new WeightedRandomChestContent(getBeeItemFromTemplate(BeeTemplates.getCommonTemplate(), EnumBeeType.DRONE), 1, 2, 8)); - ChestGenHooks.addItem(Defaults.CHEST_GEN_HOOK_NATURALIST_CHEST, new WeightedRandomChestContent(getBeeItemFromTemplate(BeeTemplates.getMeadowsTemplate(), EnumBeeType.PRINCESS), 1, 1, 5)); - } - - private static ItemStack getBeeItemFromTemplate(IAllele[] template, EnumBeeType beeType) { - IBee bee = new Bee(PluginApiculture.beeInterface.templateAsGenome(template)); - ItemStack beeItem; - switch (beeType) { - default: - case DRONE: - beeItem = ForestryItem.beeDroneGE.getItemStack(); - break; - case PRINCESS: - beeItem = ForestryItem.beePrincessGE.getItemStack(); - break; - } - NBTTagCompound nbtTagCompound = new NBTTagCompound(); - bee.writeToNBT(nbtTagCompound); - beeItem.setTagCompound(nbtTagCompound); - - return beeItem; + ChestGenHooks.addItem(Defaults.CHEST_GEN_HOOK_NATURALIST_CHEST, new WeightedRandomChestContent(BeeDefinition.FOREST.getRainResist().getMemberStack(EnumBeeType.PRINCESS), 1, 1, 5)); + ChestGenHooks.addItem(Defaults.CHEST_GEN_HOOK_NATURALIST_CHEST, new WeightedRandomChestContent(BeeDefinition.COMMON.getMemberStack(EnumBeeType.DRONE), 1, 2, 8)); + ChestGenHooks.addItem(Defaults.CHEST_GEN_HOOK_NATURALIST_CHEST, new WeightedRandomChestContent(BeeDefinition.MEADOWS.getMemberStack(EnumBeeType.PRINCESS), 1, 1, 5)); } private static void createHives() { @@ -812,183 +780,9 @@ public class PluginApiculture extends ForestryPlugin { IClassification apidae = AlleleManager.alleleRegistry.createAndRegisterClassification(EnumClassLevel.FAMILY, "apidae", "Apidae"); hymnoptera.addMemberGroup(apidae); - IClassification honey = new BranchBees("honey", "Apis"); - apidae.addMemberGroup(honey); - IClassification noble = new BranchBees("noble", "Probapis"); - apidae.addMemberGroup(noble); - IClassification industrious = new BranchBees("industrious", "Industrapis"); - apidae.addMemberGroup(industrious); - IClassification heroic = new BranchBees("heroic", "Herapis"); - apidae.addMemberGroup(heroic); - IClassification infernal = new BranchBees("infernal", "Diapis"); - apidae.addMemberGroup(infernal); - IClassification austere = new BranchBees("austere", "Modapis"); - apidae.addMemberGroup(austere); - IClassification end = new BranchBees("end", "Finapis"); - apidae.addMemberGroup(end); - IClassification vengeful = new BranchBees("vengeful", "Punapis"); - apidae.addMemberGroup(vengeful); - IClassification tropical = new BranchBees("tropical", "Caldapis"); - apidae.addMemberGroup(tropical); - IClassification frozen = new BranchBees("frozen", "Coagapis"); - apidae.addMemberGroup(frozen); - IClassification reddened = new BranchBees("reddened", "Rubapis"); - apidae.addMemberGroup(reddened); - IClassification festive = new BranchBees("festive", "Festapis"); - apidae.addMemberGroup(festive); - IClassification agrarian = new BranchBees("agrarian", "Rustapis"); - apidae.addMemberGroup(agrarian); - IClassification boggy = new BranchBees("boggy", "Paludapis"); - apidae.addMemberGroup(boggy); - IClassification monastic = new BranchBees("monastic", "Monapis"); - apidae.addMemberGroup(monastic); - - // / BEES // SPECIES - // Common Branch - Allele.speciesForest = new AlleleBeeSpecies("speciesForest", true, "bees.species.forest", honey, "nigrocincta", 0x19d0ec, 0xffdc16).addProduct( - ForestryItem.beeComb.getItemStack(1, 0), 30); - Allele.speciesMeadows = new AlleleBeeSpecies("speciesMeadows", true, "bees.species.meadows", honey, "florea", 0xef131e, 0xffdc16).addProduct( - ForestryItem.beeComb.getItemStack(1, 0), 30); - Allele.speciesCommon = new AlleleBeeSpecies("speciesCommon", true, "bees.species.common", honey, "cerana", 0xb2b2b2, 0xffdc16).addProduct( - ForestryItem.beeComb.getItemStack(1, 0), 35).setIsSecret(); - Allele.speciesCultivated = new AlleleBeeSpecies("speciesCultivated", true, "bees.species.cultivated", honey, "mellifera", 0x5734ec, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 0), 40).setIsSecret(); - - // Noble Branch - Allele.speciesNoble = new AlleleBeeSpecies("speciesNoble", false, "bees.species.noble", noble, "nobilis", 0xec9a19, 0xffdc16).addProduct( - ForestryItem.beeComb.getItemStack(1, 5), 20).setIsSecret(); - Allele.speciesMajestic = new AlleleBeeSpecies("speciesMajestic", true, "bees.species.majestic", noble, "regalis", 0x7f0000, 0xffdc16).addProduct( - ForestryItem.beeComb.getItemStack(1, 5), 30).setIsSecret(); - Allele.speciesImperial = new AlleleBeeSpecies("speciesImperial", false, "bees.species.imperial", noble, "imperatorius", 0xa3e02f, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 5), 20).addProduct(ForestryItem.royalJelly.getItemStack(), 15).setHasEffect().setIsSecret(); - - // Industrious Branch - Allele.speciesDiligent = new AlleleBeeSpecies("speciesDiligent", false, "bees.species.diligent", industrious, "sedulus", 0xc219ec, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 3), 20).setIsSecret(); - Allele.speciesUnweary = new AlleleBeeSpecies("speciesUnweary", true, "bees.species.unweary", industrious, "assiduus", 0x19ec5a, 0xffdc16).addProduct( - ForestryItem.beeComb.getItemStack(1, 3), 30).setIsSecret(); - Allele.speciesIndustrious = new AlleleBeeSpecies("speciesIndustrious", false, "bees.species.industrious", industrious, "industria", 0xffffff, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 3), 20).addProduct(ForestryItem.pollenCluster.getItemStack(), 15).setHasEffect().setIsSecret(); - - // Heroic Branch - Allele.speciesSteadfast = new AlleleBeeSpecies("speciesSteadfast", false, "bees.species.steadfast", heroic, "legio", 0x4d2b15, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 1), 20).setIsSecret().setHasEffect(); - Allele.speciesValiant = new AlleleBeeSpecies("speciesValiant", true, "bees.species.valiant", heroic, "centurio", 0x626bdd, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 1), 30).addSpecialty(new ItemStack(Items.sugar), 15).setIsSecret(); - Allele.speciesHeroic = new AlleleBeeSpecies("speciesHeroic", false, "bees.species.heroic", heroic, "kraphti", 0xb3d5e4, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 1), 40).setIsSecret().setHasEffect(); - - // Infernal Branch - Allele.speciesSinister = new AlleleBeeSpecies("speciesSinister", false, "bees.species.sinister", infernal, "caecus", 0xb3d5e4, 0x9a2323) - .addProduct(ForestryItem.beeComb.getItemStack(1, 2), 45).setEntityTexture("sinisterBee").setIsSecret().setTemperature(EnumTemperature.HELLISH).setHumidity(EnumHumidity.ARID); - Allele.speciesFiendish = new AlleleBeeSpecies("speciesFiendish", true, "bees.species.fiendish", infernal, "diabolus", 0xd7bee5, 0x9a2323) - .addProduct(ForestryItem.beeComb.getItemStack(1, 2), 55).addProduct(ForestryItem.ash.getItemStack(), 15).setEntityTexture("sinisterBee").setIsSecret() - .setTemperature(EnumTemperature.HELLISH).setHumidity(EnumHumidity.ARID); - Allele.speciesDemonic = new AlleleBeeSpecies("speciesDemonic", false, "bees.species.demonic", infernal, "draco", 0xf4e400, 0x9a2323) - .addProduct(ForestryItem.beeComb.getItemStack(1, 2), 45).addProduct(new ItemStack(Items.glowstone_dust), 15).setEntityTexture("sinisterBee").setHasEffect().setIsSecret() - .setTemperature(EnumTemperature.HELLISH).setHumidity(EnumHumidity.ARID); - - // Austere Branch - Allele.speciesModest = new AlleleBeeSpecies("speciesModest", false, "bees.species.modest", austere, "modicus", 0xc5be86, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 7), 20).setTemperature(EnumTemperature.HOT).setHumidity(EnumHumidity.ARID); - Allele.speciesFrugal = new AlleleBeeSpecies("speciesFrugal", true, "bees.species.frugal", austere, "permodestus", 0xe8dcb1, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 7), 30).setIsSecret().setTemperature(EnumTemperature.HOT).setHumidity(EnumHumidity.ARID); - Allele.speciesAustere = new AlleleBeeSpecies("speciesAustere", false, "bees.species.austere", austere, "correpere", 0xfffac2, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 7), 20).addSpecialty(ForestryItem.beeComb.getItemStack(1, 10), 50).setHasEffect() - .setIsSecret().setTemperature(EnumTemperature.HOT).setHumidity(EnumHumidity.ARID); - - // / Tropical Branch - Allele.speciesTropical = new AlleleBeeSpecies("speciesTropical", false, "bees.species.tropical", tropical, "mendelia", 0x378020, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 6), 20).setEntityTexture("tropicalBee").setTemperature(EnumTemperature.WARM).setHumidity(EnumHumidity.DAMP); - Allele.speciesExotic = new AlleleBeeSpecies("speciesExotic", true, "bees.species.exotic", tropical, "darwini", 0x304903, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 6), 30).setEntityTexture("tropicalBee").setIsSecret().setTemperature(EnumTemperature.WARM).setHumidity(EnumHumidity.DAMP); - Allele.speciesEdenic = new AlleleBeeSpecies("speciesEdenic", false, "bees.species.edenic", tropical, "humboldti", 0x393d0d, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 6), 20).setEntityTexture("tropicalBee").setHasEffect().setIsSecret().setTemperature(EnumTemperature.WARM) - .setHumidity(EnumHumidity.DAMP); - - // End Branch - Allele.speciesEnded = new AlleleBeeSpecies("speciesEnded", false, "bees.species.ender", end, "notchi", 0xe079fa, 0xd9de9e) - .addProduct(ForestryItem.beeComb.getItemStack(1, 8), 30).setEntityTexture("endBee").setIsSecret().setTemperature(EnumTemperature.COLD); - Allele.speciesSpectral = new AlleleBeeSpecies("speciesSpectral", true, "bees.species.spectral", end, "idolum", 0xa98bed, 0xd9de9e) // 0xa98bed - .addProduct(ForestryItem.beeComb.getItemStack(1, 8), 50).setEntityTexture("endBee").setIsSecret().setTemperature(EnumTemperature.COLD); - Allele.speciesPhantasmal = new AlleleBeeSpecies("speciesPhantasmal", false, "bees.species.phantasmal", end, "lemur", 0xcc00fa, 0xd9de9e) // 0x31023a // - // 0x8bc3ed - .addProduct(ForestryItem.beeComb.getItemStack(1, 8), 40).setEntityTexture("endBee").setIsSecret().setHasEffect().setTemperature(EnumTemperature.COLD); - - // Frozen Branch - Allele.speciesWintry = new AlleleBeeSpecies("speciesWintry", false, "bees.species.wintry", frozen, "brumalis", 0xa0ffc8, 0xdaf5f3).addProduct( - ForestryItem.beeComb.getItemStack(1, 4), 30).setEntityTexture("icyBee").setTemperature(EnumTemperature.ICY); - Allele.speciesIcy = new AlleleBeeSpecies("speciesIcy", true, "bees.species.icy", frozen, "coagulis", 0xa0ffff, 0xdaf5f3) - .addProduct(ForestryItem.beeComb.getItemStack(1, 4), 20).setEntityTexture("icyBee").addProduct(ForestryItem.craftingMaterial.getItemStack(1, 5), 20) - .setTemperature(EnumTemperature.ICY).setIsSecret(); - Allele.speciesGlacial = new AlleleBeeSpecies("speciesGlacial", false, "bees.species.glacial", frozen, "glacialis", 0xefffff, 0xdaf5f3) - .addProduct(ForestryItem.beeComb.getItemStack(1, 4), 20).setEntityTexture("icyBee").addProduct(ForestryItem.craftingMaterial.getItemStack(1, 5), 40) - .setTemperature(EnumTemperature.ICY).setHasEffect().setIsSecret(); - - // Vengeful Branch - Allele.speciesVindictive = new AlleleBeeSpecies("speciesVindictive", false, "bees.species.vindictive", vengeful, "ultio", 0xeafff3, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 9), 25).setIsSecret().setIsNotCounted(); - Allele.speciesVengeful = new AlleleBeeSpecies("speciesVengeful", false, "bees.species.vengeful", vengeful, "punire", 0xc2de00, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 9), 40).setIsSecret().setIsNotCounted(); - Allele.speciesAvenging = new AlleleBeeSpecies("speciesAvenging", false, "bees.species.avenging", vengeful, "hostimentum", 0xddff00, 0xffdc16) - .addProduct(ForestryItem.beeComb.getItemStack(1, 9), 40).setIsSecret().setHasEffect().setIsNotCounted(); - - // Reddened Branch (EE) - Allele.speciesDarkened = new AlleleBeeSpecies("speciesDarkened", false, "bees.species.darkened", reddened, "pahimas", 0xd7bee5, 0x260f29) - .addProduct(ForestryItem.beeComb.getItemStack(1, 0), 100).addSpecialty(ForestryItem.beeComb.getItemStack(1, 12), 100) - .setJubilanceProvider(new JubilanceNone()).setIsSecret().setIsNotCounted(); - AlleleManager.alleleRegistry.blacklistAllele(Allele.speciesDarkened.getUID()); - Allele.speciesReddened = new AlleleBeeSpecies("speciesReddened", false, "bees.species.reddened", reddened, "xenophos", 0xf8c1c1, 0x260f29) - .addProduct(ForestryItem.beeComb.getItemStack(1, 0), 100).addSpecialty(ForestryItem.beeComb.getItemStack(1, 11), 100) - .setJubilanceProvider(new JubilanceNone()).setIsSecret().setIsNotCounted(); - AlleleManager.alleleRegistry.blacklistAllele(Allele.speciesReddened.getUID()); - Allele.speciesOmega = new AlleleBeeSpecies("speciesOmega", false, "bees.species.omega", reddened, "slopokis", 0xfeff8f, 0x260f29) - .addProduct(ForestryItem.beeComb.getItemStack(1, 0), 100).addSpecialty(ForestryItem.beeComb.getItemStack(1, 13), 100) - .setJubilanceProvider(new JubilanceNone()).setIsSecret().setIsNotCounted(); - AlleleManager.alleleRegistry.blacklistAllele(Allele.speciesOmega.getUID()); - - // Festive branch - Allele.speciesLeporine = new AlleleBeeSpecies("speciesLeporine", false, "bees.species.leporine", festive, "lepus", 0xfeff8f, 0x3cd757) - .addProduct(ForestryItem.beeComb.getItemStack(1, 6), 30).addProduct(new ItemStack(Items.egg), 10).setIsSecret().setIsNotCounted() - .setHasEffect(); - Allele.speciesMerry = new AlleleBeeSpecies("speciesMerry", false, "bees.species.merry", festive, "feliciter", 0xffffff, 0xd40000) - .addProduct(ForestryItem.beeComb.getItemStack(1, 4), 30).addProduct(ForestryItem.craftingMaterial.getItemStack(1, 5), 20) - .setTemperature(EnumTemperature.ICY).setIsSecret().setIsNotCounted().setHasEffect(); - Allele.speciesTipsy = new AlleleBeeSpecies("speciesTipsy", false, "bees.species.tipsy", festive, "ebrius", 0xffffff, 0xc219ec) - .addProduct(ForestryItem.beeComb.getItemStack(1, 4), 30).addProduct(ForestryItem.craftingMaterial.getItemStack(1, 5), 20) - .setTemperature(EnumTemperature.ICY).setIsSecret().setIsNotCounted().setHasEffect(); - // 35 Solstice - Allele.speciesTricky = new AlleleBeeSpecies("speciesTricky", false, "bees.species.tricky", festive, "libita", 0x49413B, 0xFF6A00) - .addProduct(ForestryItem.beeComb.getItemStack(1, 0), 40).addProduct(new ItemStack(Items.cookie), 15) - .addSpecialty(new ItemStack(Items.skull, 1, 0), 2).addSpecialty(new ItemStack(Items.skull, 1, 2), 2) - .addSpecialty(new ItemStack(Items.skull, 1, 3), 2).addSpecialty(new ItemStack(Items.skull, 1, 4), 2) - .setIsSecret().setIsNotCounted().setHasEffect(); - // 37 Thanksgiving - - // Agrarian branch - Allele.speciesRural = new AlleleBeeSpecies("speciesRural", false, "bees.species.rural", agrarian, "rustico", 0xfeff8f, 0xffdc16).addProduct( - ForestryItem.beeComb.getItemStack(1, 14), 20).setIsSecret(); - Allele.speciesFarmerly = new AlleleBeeSpecies("speciesFarmerly", true, "bees.species.farmerly", agrarian, "arator", 0xD39728, 0xffdc16).addProduct( - ForestryItem.beeComb.getItemStack(1, 14), 27).setIsSecret(); - Allele.speciesArgrarian = new AlleleBeeSpecies("speciesArgrarian", true, "bees.species.agrarian", agrarian, "arator", 0xFFCA75, 0xFFE047).addProduct( - ForestryItem.beeComb.getItemStack(1, 14), 35).setIsSecret().setHasEffect(); - - // Boggy branch - Allele.speciesMarshy = new AlleleBeeSpecies("speciesMarshy", true, "bees.species.marshy", boggy, "adorasti", 0x546626, 0xffdc16).addProduct( - ForestryItem.beeComb.getItemStack(1, 15), 30).setHumidity(EnumHumidity.DAMP); - Allele.speciesMiry = new AlleleBeeSpecies("speciesMiry", true, "bees.species.miry", boggy, "humidium", 0x92AF42, 0xffdc16).addProduct( - ForestryItem.beeComb.getItemStack(1, 15), 36).setHumidity(EnumHumidity.DAMP).setIsSecret(); - Allele.speciesBoggy = new AlleleBeeSpecies("speciesBoggy", true, "bees.species.boggy", boggy, "paluster", 0x698948, 0xffdc16).addProduct( - ForestryItem.beeComb.getItemStack(1, 15), 39).addSpecialty(ForestryItem.peat.getItemStack(1), 8).setHumidity(EnumHumidity.DAMP).setIsSecret(); - - // Monastic branch - Allele.speciesMonastic = new AlleleBeeSpecies("speciesMonastic", false, "bees.species.monastic", monastic, "monachus", 0x42371c, 0xfff7b6) - .addProduct(ForestryItem.beeComb.getItemStack(1, 14), 30).addSpecialty(ForestryItem.beeComb.getItemStack(1, 16), 10) - .setJubilanceProvider(new JubilanceProviderHermit()).setIsSecret(); - Allele.speciesSecluded = new AlleleBeeSpecies("speciesSecluded", true, "bees.species.secluded", monastic, "contractus", 0x7b6634, 0xfff7b6) - .addSpecialty(ForestryItem.beeComb.getItemStack(1, 16), 20).setJubilanceProvider(new JubilanceProviderHermit()).setIsSecret(); - Allele.speciesHermitic = new AlleleBeeSpecies("speciesHermitic", false, "bees.species.hermitic", monastic, "anachoreta", 0xffd46c, 0xfff7b6) - .addSpecialty(ForestryItem.beeComb.getItemStack(1, 16), 20).setJubilanceProvider(new JubilanceProviderHermit()).setHasEffect().setIsSecret(); + for (EnumBeeBranch beeBranch : EnumBeeBranch.values()) { + apidae.addMemberGroup(beeBranch.getBranch()); + } // / BEES // FLOWER PROVIDERS 1500 - 1599 Allele.flowersVanilla = new AlleleFlowers("flowersVanilla", new FlowerProvider(FlowerManager.FlowerTypeVanilla, "flowers.vanilla"), true); @@ -1001,8 +795,6 @@ public class PluginApiculture extends ForestryPlugin { Allele.flowersWheat = new AlleleFlowers("flowersWheat", new FlowerProvider(FlowerManager.FlowerTypeWheat, "flowers.wheat"), true); Allele.flowersGourd = new AlleleFlowers("flowersGourd", new FlowerProvider(FlowerManager.FlowerTypeGourd, "flowers.gourd"), true); - // REgiste - // / BEES // EFFECTS 1800 - 1899 Allele.effectNone = new AlleleEffectNone("effectNone"); Allele.effectAggressive = new AlleleEffectAggressive("effectAggressive"); @@ -1023,166 +815,6 @@ public class PluginApiculture extends ForestryPlugin { Allele.effectRepulsion = new AlleleEffectRepulsion("effectRepulsion"); Allele.effectFertile = new AlleleEffectFertile("effectFertile"); Allele.effectMycophilic = new AlleleEffectFungification("effectMycophilic"); - - } - - private void createMutations() { - // / MUTATIONS - BeeTemplates.commonA = new BeeMutation(Allele.speciesForest, Allele.speciesMeadows, BeeTemplates.getCommonTemplate(), 15); - - BeeTemplates.commonB = new BeeMutation(Allele.speciesModest, Allele.speciesForest, BeeTemplates.getCommonTemplate(), 15); - BeeTemplates.commonC = new BeeMutation(Allele.speciesModest, Allele.speciesMeadows, BeeTemplates.getCommonTemplate(), 15); - - BeeTemplates.commonD = new BeeMutation(Allele.speciesWintry, Allele.speciesForest, BeeTemplates.getCommonTemplate(), 15); - BeeTemplates.commonE = new BeeMutation(Allele.speciesWintry, Allele.speciesMeadows, BeeTemplates.getCommonTemplate(), 15); - BeeTemplates.commonF = new BeeMutation(Allele.speciesWintry, Allele.speciesModest, BeeTemplates.getCommonTemplate(), 15); - - BeeTemplates.commonG = new BeeMutation(Allele.speciesTropical, Allele.speciesForest, BeeTemplates.getCommonTemplate(), 15); - BeeTemplates.commonH = new BeeMutation(Allele.speciesTropical, Allele.speciesMeadows, BeeTemplates.getCommonTemplate(), 15); - BeeTemplates.commonI = new BeeMutation(Allele.speciesTropical, Allele.speciesModest, BeeTemplates.getCommonTemplate(), 15); - BeeTemplates.commonJ = new BeeMutation(Allele.speciesTropical, Allele.speciesWintry, BeeTemplates.getCommonTemplate(), 15); - - BeeTemplates.commonK = new BeeMutation(Allele.speciesMarshy, Allele.speciesForest, BeeTemplates.getCommonTemplate(), 15); - BeeTemplates.commonL = new BeeMutation(Allele.speciesMarshy, Allele.speciesMeadows, BeeTemplates.getCommonTemplate(), 15); - BeeTemplates.commonM = new BeeMutation(Allele.speciesMarshy, Allele.speciesModest, BeeTemplates.getCommonTemplate(), 15); - BeeTemplates.commonN = new BeeMutation(Allele.speciesMarshy, Allele.speciesWintry, BeeTemplates.getCommonTemplate(), 15); - BeeTemplates.commonO = new BeeMutation(Allele.speciesMarshy, Allele.speciesTropical, BeeTemplates.getCommonTemplate(), 15); - - BeeTemplates.cultivatedA = new BeeMutation(Allele.speciesCommon, Allele.speciesForest, BeeTemplates.getCultivatedTemplate(), 12); - BeeTemplates.cultivatedB = new BeeMutation(Allele.speciesCommon, Allele.speciesMeadows, BeeTemplates.getCultivatedTemplate(), 12); - BeeTemplates.cultivatedC = new BeeMutation(Allele.speciesCommon, Allele.speciesModest, BeeTemplates.getCultivatedTemplate(), 12); - BeeTemplates.cultivatedD = new BeeMutation(Allele.speciesCommon, Allele.speciesWintry, BeeTemplates.getCultivatedTemplate(), 12); - BeeTemplates.cultivatedE = new BeeMutation(Allele.speciesCommon, Allele.speciesTropical, BeeTemplates.getCultivatedTemplate(), 12); - BeeTemplates.cultivatedF = new BeeMutation(Allele.speciesCommon, Allele.speciesMarshy, BeeTemplates.getCultivatedTemplate(), 12); - - BeeTemplates.nobleA = new BeeMutation(Allele.speciesCommon, Allele.speciesCultivated, BeeTemplates.getNobleTemplate(), 10); - BeeTemplates.majesticA = new BeeMutation(Allele.speciesNoble, Allele.speciesCultivated, BeeTemplates.getMajesticTemplate(), 8); - BeeTemplates.imperialA = new BeeMutation(Allele.speciesNoble, Allele.speciesMajestic, BeeTemplates.getImperialTemplate(), 8); - - BeeTemplates.diligentA = new BeeMutation(Allele.speciesCommon, Allele.speciesCultivated, BeeTemplates.getDiligentTemplate(), 10); - BeeTemplates.unwearyA = new BeeMutation(Allele.speciesDiligent, Allele.speciesCultivated, BeeTemplates.getUnwearyTemplate(), 8); - BeeTemplates.industriousA = new BeeMutation(Allele.speciesDiligent, Allele.speciesUnweary, BeeTemplates.getIndustriousTemplate(), 8); - - BeeTemplates.heroicA = new BeeMutation(Allele.speciesSteadfast, Allele.speciesValiant, BeeTemplates.getHeroicTemplate(), 6) - .restrictBiomeType(BiomeDictionary.Type.FOREST).enableStrictBiomeCheck(); - - BeeTemplates.sinisterA = new BeeMutation(Allele.speciesModest, Allele.speciesCultivated, BeeTemplates.getSinisterTemplate(), 60) - .restrictBiomeType(BiomeDictionary.Type.NETHER); - BeeTemplates.sinisterB = new BeeMutation(Allele.speciesTropical, Allele.speciesCultivated, BeeTemplates.getSinisterTemplate(), 60) - .restrictBiomeType(BiomeDictionary.Type.NETHER); - BeeTemplates.fiendishA = new BeeMutation(Allele.speciesSinister, Allele.speciesCultivated, BeeTemplates.getFiendishTemplate(), 40) - .restrictBiomeType(BiomeDictionary.Type.NETHER); - BeeTemplates.fiendishB = new BeeMutation(Allele.speciesSinister, Allele.speciesModest, BeeTemplates.getFiendishTemplate(), 40) - .restrictBiomeType(BiomeDictionary.Type.NETHER); - BeeTemplates.fiendishC = new BeeMutation(Allele.speciesSinister, Allele.speciesTropical, BeeTemplates.getFiendishTemplate(), 40) - .restrictBiomeType(BiomeDictionary.Type.NETHER); - BeeTemplates.demonicA = new BeeMutation(Allele.speciesSinister, Allele.speciesFiendish, BeeTemplates.getDemonicTemplate(), 25) - .restrictBiomeType(BiomeDictionary.Type.NETHER); - - // Austere branch - BeeTemplates.frugalA = new BeeMutation(Allele.speciesModest, Allele.speciesSinister, BeeTemplates.getFrugalTemplate(), 16).setTemperatureRainfall(1.9f, - 2.0f, 0.0f, 0.1f); - BeeTemplates.frugalB = new BeeMutation(Allele.speciesModest, Allele.speciesFiendish, BeeTemplates.getFrugalTemplate(), 10).setTemperatureRainfall(1.9f, - 2.0f, 0.0f, 0.1f); - BeeTemplates.austereA = new BeeMutation(Allele.speciesModest, Allele.speciesFrugal, BeeTemplates.getAustereTemplate(), 8).setTemperatureRainfall(1.9f, - 2.0f, 0.0f, 0.1f); - - // Tropical branch - BeeTemplates.exoticA = new BeeMutation(Allele.speciesAustere, Allele.speciesTropical, BeeTemplates.getExoticTemplate(), 12); - BeeTemplates.edenicA = new BeeMutation(Allele.speciesExotic, Allele.speciesTropical, BeeTemplates.getEdenicTemplate(), 8); - - // Wintry branch - BeeTemplates.icyA = new BeeMutation(Allele.speciesIndustrious, Allele.speciesWintry, BeeTemplates.getIcyTemplate(), 12).setTemperature(0f, 0.15f); - BeeTemplates.glacialA = new BeeMutation(Allele.speciesIcy, Allele.speciesWintry, BeeTemplates.getGlacialTemplate(), 8).setTemperature(0f, 0.15f); - - // Festive branch - BeeTemplates.leporineA = new MutationTimeLimited(Allele.speciesMeadows, Allele.speciesForest, BeeTemplates.getLeporineTemplate(), 10, - new MutationTimeLimited.DayMonth(29, 3), new MutationTimeLimited.DayMonth(15, 4)).setIsSecret(); - BeeTemplates.merryA = new MutationTimeLimited(Allele.speciesWintry, Allele.speciesForest, BeeTemplates.getMerryTemplate(), 10, - new MutationTimeLimited.DayMonth(21, 12), new MutationTimeLimited.DayMonth(27, 12)).setIsSecret(); - BeeTemplates.tipsyA = new MutationTimeLimited(Allele.speciesWintry, Allele.speciesMeadows, BeeTemplates.getTipsyTemplate(), 10, - new MutationTimeLimited.DayMonth(27, 12), new MutationTimeLimited.DayMonth(2, 1)).setIsSecret(); - BeeTemplates.trickyA = new MutationTimeLimited(Allele.speciesSinister, Allele.speciesCommon, BeeTemplates.getTrickyTemplate(), 10, - new MutationTimeLimited.DayMonth(15, 10), new MutationTimeLimited.DayMonth(3, 11)).setIsSecret(); - - // Agrarian branch - BeeTemplates.ruralA = new BeeMutation(Allele.speciesMeadows, Allele.speciesDiligent, BeeTemplates.getRuralTemplate(), 12) - .restrictBiomeType(BiomeDictionary.Type.PLAINS).enableStrictBiomeCheck(); - new BeeMutation(Allele.speciesRural, Allele.speciesUnweary, BeeTemplates.getFarmerlyTemplate(), 10) - .restrictBiomeType(BiomeDictionary.Type.PLAINS).enableStrictBiomeCheck(); - new BeeMutation(Allele.speciesFarmerly, Allele.speciesIndustrious, BeeTemplates.getAgrarianTemplate(), 6) - .restrictBiomeType(BiomeDictionary.Type.PLAINS).enableStrictBiomeCheck(); - - // Boggy branch - new BeeMutation(Allele.speciesMarshy, Allele.speciesNoble, BeeTemplates.getMiryTemplate(), 15) - .setTemperatureRainfall(0.75f, 0.94f, 0.75f, 2.0f); - new BeeMutation(Allele.speciesMarshy, Allele.speciesMiry, BeeTemplates.getBoggyTemplate(), 9) - .setTemperatureRainfall(0.75f, 0.94f, 0.75f, 2.0f); - - // Monastic branch - BeeTemplates.secludedA = new BeeMutation(Allele.speciesMonastic, Allele.speciesAustere, BeeTemplates.getSecludedTemplate(), 12); - BeeTemplates.hermiticA = new BeeMutation(Allele.speciesMonastic, Allele.speciesSecluded, BeeTemplates.getHermiticTemplate(), 8); - - // End branch - BeeTemplates.spectralA = new BeeMutation(Allele.speciesHermitic, Allele.speciesEnded, BeeTemplates.getSpectralTemplate(), 4); - BeeTemplates.phantasmalA = new BeeMutation(Allele.speciesSpectral, Allele.speciesEnded, BeeTemplates.getPhantasmalTemplate(), 2); - - // Vindictive branch - BeeTemplates.vindictiveA = new BeeMutation(Allele.speciesMonastic, Allele.speciesDemonic, BeeTemplates.getVindictiveTemplate(), 4).setIsSecret(); - - BeeTemplates.vengefulA = new BeeMutation(Allele.speciesDemonic, Allele.speciesVindictive, BeeTemplates.getVengefulTemplate(), 8).setIsSecret(); - BeeTemplates.vengefulB = new BeeMutation(Allele.speciesMonastic, Allele.speciesVindictive, BeeTemplates.getVengefulTemplate(), 8).setIsSecret(); - BeeTemplates.avengingA = new BeeMutation(Allele.speciesVengeful, Allele.speciesVindictive, BeeTemplates.getAvengingTemplate(), 4); - } - - private static void registerTemplates() { - beeInterface.registerTemplate(BeeTemplates.getForestTemplate()); - beeInterface.registerTemplate(BeeTemplates.getMeadowsTemplate()); - beeInterface.registerTemplate(BeeTemplates.getCommonTemplate()); - beeInterface.registerTemplate(BeeTemplates.getCultivatedTemplate()); - beeInterface.registerTemplate(BeeTemplates.getNobleTemplate()); - beeInterface.registerTemplate(BeeTemplates.getMajesticTemplate()); - beeInterface.registerTemplate(BeeTemplates.getImperialTemplate()); - beeInterface.registerTemplate(BeeTemplates.getDiligentTemplate()); - beeInterface.registerTemplate(BeeTemplates.getUnwearyTemplate()); - beeInterface.registerTemplate(BeeTemplates.getIndustriousTemplate()); - beeInterface.registerTemplate(BeeTemplates.getSteadfastTemplate()); - beeInterface.registerTemplate(BeeTemplates.getValiantTemplate()); - beeInterface.registerTemplate(BeeTemplates.getHeroicTemplate()); - beeInterface.registerTemplate(BeeTemplates.getSinisterTemplate()); - beeInterface.registerTemplate(BeeTemplates.getFiendishTemplate()); - beeInterface.registerTemplate(BeeTemplates.getDemonicTemplate()); - beeInterface.registerTemplate(BeeTemplates.getModestTemplate()); - beeInterface.registerTemplate(BeeTemplates.getFrugalTemplate()); - beeInterface.registerTemplate(BeeTemplates.getAustereTemplate()); - beeInterface.registerTemplate(BeeTemplates.getTropicalTemplate()); - beeInterface.registerTemplate(BeeTemplates.getExoticTemplate()); - beeInterface.registerTemplate(BeeTemplates.getEdenicTemplate()); - beeInterface.registerTemplate(BeeTemplates.getWintryTemplate()); - beeInterface.registerTemplate(BeeTemplates.getIcyTemplate()); - beeInterface.registerTemplate(BeeTemplates.getGlacialTemplate()); - beeInterface.registerTemplate(BeeTemplates.getVindictiveTemplate()); - beeInterface.registerTemplate(BeeTemplates.getVengefulTemplate()); - beeInterface.registerTemplate(BeeTemplates.getAvengingTemplate()); - beeInterface.registerTemplate(BeeTemplates.getDarkenedTemplate()); - beeInterface.registerTemplate(BeeTemplates.getReddenedTemplate()); - beeInterface.registerTemplate(BeeTemplates.getOmegaTemplate()); - beeInterface.registerTemplate(BeeTemplates.getRuralTemplate()); - beeInterface.registerTemplate(BeeTemplates.getFarmerlyTemplate()); - beeInterface.registerTemplate(BeeTemplates.getAgrarianTemplate()); - beeInterface.registerTemplate(BeeTemplates.getLeporineTemplate()); - beeInterface.registerTemplate(BeeTemplates.getMerryTemplate()); - beeInterface.registerTemplate(BeeTemplates.getTipsyTemplate()); - beeInterface.registerTemplate(BeeTemplates.getTrickyTemplate()); - beeInterface.registerTemplate(BeeTemplates.getMarshyTemplate()); - beeInterface.registerTemplate(BeeTemplates.getMiryTemplate()); - beeInterface.registerTemplate(BeeTemplates.getBoggyTemplate()); - beeInterface.registerTemplate(BeeTemplates.getMonasticTemplate()); - beeInterface.registerTemplate(BeeTemplates.getSecludedTemplate()); - beeInterface.registerTemplate(BeeTemplates.getHermiticTemplate()); - beeInterface.registerTemplate(BeeTemplates.getEnderTemplate()); - beeInterface.registerTemplate(BeeTemplates.getSpectralTemplate()); - beeInterface.registerTemplate(BeeTemplates.getPhantasmalTemplate()); } public static int getSecondPrincessChance() { @@ -1212,11 +844,6 @@ public class PluginApiculture extends ForestryPlugin { return new SaveEventHandlerApiculture(); } - @Override - public IOreDictionaryHandler getDictionaryHandler() { - return null; - } - @Override public void populateChunk(IChunkProvider chunkProvider, World world, Random rand, int chunkX, int chunkZ, boolean hasVillageGenerated) { if (Config.generateBeehives) {