Initial Commit

18 files changed, 2392 insertions, 0 deletions

diff --git a/src/Java/binnie/core/genetics/BeeBreedingSystem.java b/src/Java/binnie/core/genetics/BeeBreedingSystem.java
new file mode 100644
index 0000000000..2c3947b5a0
--- /dev/null
+++ b/src/Java/binnie/core/genetics/BeeBreedingSystem.java
@@ -0,0 +1,125 @@
+package binnie.core.genetics;
+
+import binnie.Binnie;
+import binnie.core.BinnieCore;
+import binnie.core.language.ManagerLanguage;
+import binnie.core.resource.ManagerResource;
+import binnie.extrabees.ExtraBees;
+import forestry.api.apiculture.EnumBeeChromosome;
+import forestry.api.apiculture.EnumBeeType;
+import forestry.api.apiculture.IApiaristTracker;
+import forestry.api.apiculture.IBeeMutation;
+import forestry.api.apiculture.IBeeRoot;
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IBreedingTracker;
+import forestry.api.genetics.IChromosomeType;
+import forestry.api.genetics.IMutation;
+import forestry.api.genetics.ISpeciesRoot;
+import java.util.TreeSet;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+class BeeBreedingSystem
+  extends BreedingSystem
+{
+  public BeeBreedingSystem()
+  {
+    this.iconUndiscovered = Binnie.Resource.getItemIcon(ExtraBees.instance, "icon/undiscoveredBee");
+    this.iconDiscovered = Binnie.Resource.getItemIcon(ExtraBees.instance, "icon/discoveredBee");
+  }
+  
+  public float getChance(IMutation mutation, EntityPlayer player, IAllele species1, IAllele species2)
+  {
+    return ((IBeeMutation)mutation).getChance(new VirtualBeeHousing(player), species1, species2, getSpeciesRoot().templateAsGenome(getSpeciesRoot().getTemplate(species1.getUID())), getSpeciesRoot().templateAsGenome(getSpeciesRoot().getTemplate(species2.getUID())));
+  }
+  
+  public ISpeciesRoot getSpeciesRoot()
+  {
+    return Binnie.Genetics.getBeeRoot();
+  }
+  
+  public int getColour()
+  {
+    return 16767232;
+  }
+  
+  public Class<? extends IBreedingTracker> getTrackerClass()
+  {
+    return IApiaristTracker.class;
+  }
+  
+  public String getAlleleName(IChromosomeType chromosome, IAllele allele)
+  {
+    if (chromosome == EnumBeeChromosome.FERTILITY)
+    {
+      if (allele.getUID().contains("Low")) {
+        return Binnie.Language.localise(BinnieCore.instance, "allele.fertility.low");
+      }
+      if (allele.getUID().contains("Normal")) {
+        return Binnie.Language.localise(BinnieCore.instance, "allele.fertility.normal");
+      }
+      if (allele.getUID().contains("High")) {
+        return Binnie.Language.localise(BinnieCore.instance, "allele.fertility.high");
+      }
+      if (allele.getUID().contains("Maximum")) {
+        return Binnie.Language.localise(BinnieCore.instance, "allele.fertility.maximum");
+      }
+    }
+    return super.getAlleleName(chromosome, allele);
+  }
+  
+  public boolean isDNAManipulable(ItemStack member)
+  {
+    return ((IBeeRoot)getSpeciesRoot()).getType(member) == EnumBeeType.LARVAE;
+  }
+  
+  public int[] getActiveTypes()
+  {
+    return new int[] { EnumBeeType.DRONE.ordinal(), EnumBeeType.PRINCESS.ordinal(), EnumBeeType.QUEEN.ordinal(), EnumBeeType.LARVAE.ordinal() };
+  }
+  
+  public void addExtraAlleles(IChromosomeType chromosome, TreeSet<IAllele> alleles)
+  {
+    switch (1.$SwitchMap$forestry$api$apiculture$EnumBeeChromosome[((EnumBeeChromosome)chromosome).ordinal()])
+    {
+    case 1: 
+      for (ForestryAllele.Fertility a : ForestryAllele.Fertility.values()) {
+        alleles.add(a.getAllele());
+      }
+      break;
+    case 2: 
+      for (ForestryAllele.Flowering a : ForestryAllele.Flowering.values()) {
+        alleles.add(a.getAllele());
+      }
+      break;
+    case 3: 
+    case 4: 
+      for (Tolerance a : Tolerance.values()) {
+        alleles.add(a.getAllele());
+      }
+      break;
+    case 5: 
+      for (ForestryAllele.Lifespan a : ForestryAllele.Lifespan.values()) {
+        alleles.add(a.getAllele());
+      }
+      break;
+    case 6: 
+      for (ForestryAllele.Speed a : ForestryAllele.Speed.values()) {
+        alleles.add(a.getAllele());
+      }
+      break;
+    case 7: 
+      for (ForestryAllele.Territory a : ForestryAllele.Territory.values()) {
+        alleles.add(a.getAllele());
+      }
+      break;
+    case 8: 
+    case 9: 
+    case 10: 
+      for (ForestryAllele.Bool a : ForestryAllele.Bool.values()) {
+        alleles.add(a.getAllele());
+      }
+      break;
+    }
+  }
+}
diff --git a/src/Java/binnie/core/genetics/BeeModifierLogic.java b/src/Java/binnie/core/genetics/BeeModifierLogic.java
new file mode 100644
index 0000000000..65a2ab3103
--- /dev/null
+++ b/src/Java/binnie/core/genetics/BeeModifierLogic.java
@@ -0,0 +1,47 @@
+package binnie.core.genetics;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BeeModifierLogic
+{
+  private Map<EnumBeeModifier, Float[]> modifiers = new HashMap();
+  private List<EnumBeeBooleanModifier> booleanModifiers = new ArrayList();
+  
+  public float getModifier(EnumBeeModifier modifier, float currentModifier)
+  {
+    if (!this.modifiers.containsKey(modifier)) {
+      return 1.0F;
+    }
+    float mult = ((Float[])this.modifiers.get(modifier))[0].floatValue();
+    float max = ((Float[])this.modifiers.get(modifier))[1].floatValue();
+    if (max >= 1.0F)
+    {
+      if (max <= currentModifier) {
+        return 1.0F;
+      }
+      return Math.min(max / currentModifier, mult);
+    }
+    if (max >= currentModifier) {
+      return 1.0F;
+    }
+    return Math.max(max / currentModifier, mult);
+  }
+  
+  public boolean getModifier(EnumBeeBooleanModifier modifier)
+  {
+    return this.booleanModifiers.contains(modifier);
+  }
+  
+  public void setModifier(EnumBeeBooleanModifier modifier)
+  {
+    this.booleanModifiers.add(modifier);
+  }
+  
+  public void setModifier(EnumBeeModifier modifier, float mult, float max)
+  {
+    this.modifiers.put(modifier, new Float[] { Float.valueOf(mult), Float.valueOf(max) });
+  }
+}
diff --git a/src/Java/binnie/core/genetics/BreedingSystem.java b/src/Java/binnie/core/genetics/BreedingSystem.java
new file mode 100644
index 0000000000..1bdd5d6376
--- /dev/null
+++ b/src/Java/binnie/core/genetics/BreedingSystem.java
@@ -0,0 +1,558 @@
+package binnie.core.genetics;
+
+import binnie.Binnie;
+import binnie.core.BinnieCore;
+import binnie.core.language.ManagerLanguage;
+import binnie.core.proxy.BinnieProxy;
+import binnie.core.resource.BinnieIcon;
+import binnie.extrabees.genetics.ExtraBeeMutation;
+import com.mojang.authlib.GameProfile;
+import cpw.mods.fml.common.eventhandler.EventBus;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import forestry.api.core.ForestryEvent.SyncedBreedingTracker;
+import forestry.api.genetics.AlleleManager;
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IAlleleBoolean;
+import forestry.api.genetics.IAlleleRegistry;
+import forestry.api.genetics.IAlleleSpecies;
+import forestry.api.genetics.IBreedingTracker;
+import forestry.api.genetics.IChromosomeType;
+import forestry.api.genetics.IClassification;
+import forestry.api.genetics.IGenome;
+import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IMutation;
+import forestry.api.genetics.ISpeciesRoot;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import net.minecraftforge.common.MinecraftForge;
+
+public abstract class BreedingSystem
+  implements IItemStackRepresentitive
+{
+  protected BinnieIcon iconUndiscovered;
+  protected BinnieIcon iconDiscovered;
+  
+  public BreedingSystem()
+  {
+    Binnie.Genetics.registerBreedingSystem(this);
+    MinecraftForge.EVENT_BUS.register(this);
+  }
+  
+  public String getChromosomeName(IChromosomeType chromo)
+  {
+    return BinnieCore.proxy.localise(getSpeciesRoot().getUID() + ".chromosome." + chromo.getName());
+  }
+  
+  public String getChromosomeShortName(IChromosomeType chromo)
+  {
+    return BinnieCore.proxy.localise(getSpeciesRoot().getUID() + ".chromosome." + chromo.getName() + ".short");
+  }
+  
+  public final String getEpitome(float discoveredPercentage)
+  {
+    int i = 0;
+    if (discoveredPercentage == 1.0F) {
+      i = 6;
+    } else if (discoveredPercentage < 0.1F) {
+      i = 0;
+    } else if (discoveredPercentage < 0.3F) {
+      i = 1;
+    } else if (discoveredPercentage < 0.5F) {
+      i = 2;
+    } else if (discoveredPercentage < 0.7F) {
+      i = 3;
+    } else if (discoveredPercentage < 0.9F) {
+      i = 4;
+    } else if (discoveredPercentage < 1.0F) {
+      i = 5;
+    }
+    return BinnieCore.proxy.localise(getSpeciesRoot().getUID() + ".epitome." + i);
+  }
+  
+  private List<IClassification> allBranches = new ArrayList();
+  List<IAlleleSpecies> allActiveSpecies = new ArrayList();
+  private List<IAlleleSpecies> allSpecies = new ArrayList();
+  private List<IMutation> allMutations = new ArrayList();
+  private Map<IAlleleSpecies, List<IMutation>> resultantMutations = new HashMap();
+  private Map<IAlleleSpecies, List<IMutation>> furtherMutations = new HashMap();
+  private Map<IAlleleSpecies, List<IMutation>> allResultantMutations = new HashMap();
+  private Map<IAlleleSpecies, List<IMutation>> allFurtherMutations = new HashMap();
+  public float discoveredSpeciesPercentage;
+  public int totalSpeciesCount;
+  public int discoveredSpeciesCount;
+  public int totalSecretCount;
+  public int discoveredSecretCount;
+  public float discoveredBranchPercentage;
+  public int totalBranchCount;
+  public int discoveredBranchCount;
+  private int totalSecretBranchCount;
+  private int discoveredSecretBranchCount;
+  String currentEpithet;
+  
+  public abstract ISpeciesRoot getSpeciesRoot();
+  
+  public final List<IClassification> getAllBranches()
+  {
+    return this.allBranches;
+  }
+  
+  public final Collection<IAlleleSpecies> getAllSpecies()
+  {
+    return this.allActiveSpecies;
+  }
+  
+  public final Collection<IMutation> getAllMutations()
+  {
+    return this.allMutations;
+  }
+  
+  public void calculateArrays()
+  {
+    Collection<IAllele> allAlleles = AlleleManager.alleleRegistry.getRegisteredAlleles().values();
+    
+
+    this.resultantMutations = new HashMap();
+    this.furtherMutations = new HashMap();
+    this.allResultantMutations = new HashMap();
+    this.allFurtherMutations = new HashMap();
+    
+    this.allActiveSpecies = new ArrayList();
+    this.allSpecies = new ArrayList();
+    for (IAllele species : allAlleles) {
+      if (getSpeciesRoot().getTemplate(species.getUID()) != null)
+      {
+        this.resultantMutations.put((IAlleleSpecies)species, new ArrayList());
+        
+        this.furtherMutations.put((IAlleleSpecies)species, new ArrayList());
+        
+        this.allResultantMutations.put((IAlleleSpecies)species, new ArrayList());
+        
+        this.allFurtherMutations.put((IAlleleSpecies)species, new ArrayList());
+        
+        this.allSpecies.add((IAlleleSpecies)species);
+        if ((!isBlacklisted(species)) && (!species.getUID().contains("speciesBotAlfheim"))) {
+          this.allActiveSpecies.add((IAlleleSpecies)species);
+        }
+      }
+    }
+    this.allMutations = new ArrayList();
+    
+    Collection<IClassification> allRegBranches = AlleleManager.alleleRegistry.getRegisteredClassifications().values();
+    
+
+    this.allBranches = new ArrayList();
+    for (IClassification branch : allRegBranches) {
+      if ((branch.getMemberSpecies().length > 0) && 
+        (getSpeciesRoot().getTemplate(branch.getMemberSpecies()[0].getUID()) != null))
+      {
+        boolean possible = false;
+        for (IAlleleSpecies species : branch.getMemberSpecies()) {
+          if (this.allActiveSpecies.contains(species)) {
+            possible = true;
+          }
+        }
+        if (possible) {
+          this.allBranches.add(branch);
+        }
+      }
+    }
+    if (getSpeciesRoot().getMutations(false) != null)
+    {
+      Set<IMutation> mutations = new LinkedHashSet();
+      mutations.addAll(getSpeciesRoot().getMutations(false));
+      if (this == Binnie.Genetics.beeBreedingSystem) {
+        mutations.addAll(ExtraBeeMutation.mutations);
+      }
+      for (IMutation mutation : mutations)
+      {
+        this.allMutations.add(mutation);
+        
+        Set<IAlleleSpecies> participatingSpecies = new LinkedHashSet();
+        if ((mutation.getAllele0() instanceof IAlleleSpecies)) {
+          participatingSpecies.add((IAlleleSpecies)mutation.getAllele0());
+        }
+        if ((mutation.getAllele1() instanceof IAlleleSpecies)) {
+          participatingSpecies.add((IAlleleSpecies)mutation.getAllele1());
+        }
+        for (IAlleleSpecies species : participatingSpecies)
+        {
+          ((List)this.allFurtherMutations.get(species)).add(mutation);
+          if (this.allActiveSpecies.contains(species)) {
+            ((List)this.furtherMutations.get(species)).add(mutation);
+          }
+        }
+        if (this.resultantMutations.containsKey(mutation.getTemplate()[0]))
+        {
+          ((List)this.allResultantMutations.get(mutation.getTemplate()[0])).add(mutation);
+          ((List)this.resultantMutations.get(mutation.getTemplate()[0])).add(mutation);
+        }
+      }
+    }
+  }
+  
+  public final boolean isBlacklisted(IAllele allele)
+  {
+    return AlleleManager.alleleRegistry.isBlacklisted(allele.getUID());
+  }
+  
+  public final List<IMutation> getResultantMutations(IAlleleSpecies species, boolean includeInactive)
+  {
+    if (this.resultantMutations.isEmpty()) {
+      calculateArrays();
+    }
+    return includeInactive ? (List)this.allResultantMutations.get(species) : (List)this.resultantMutations.get(species);
+  }
+  
+  public final List<IMutation> getResultantMutations(IAlleleSpecies species)
+  {
+    if (this.resultantMutations.isEmpty()) {
+      calculateArrays();
+    }
+    return (List)this.resultantMutations.get(species);
+  }
+  
+  public final List<IMutation> getFurtherMutations(IAlleleSpecies species, boolean includeInactive)
+  {
+    if (this.furtherMutations.isEmpty()) {
+      calculateArrays();
+    }
+    return includeInactive ? (List)this.allFurtherMutations.get(species) : (List)this.furtherMutations.get(species);
+  }
+  
+  public final List<IMutation> getFurtherMutations(IAlleleSpecies species)
+  {
+    if (this.furtherMutations.isEmpty()) {
+      calculateArrays();
+    }
+    return (List)this.furtherMutations.get(species);
+  }
+  
+  public final boolean isMutationDiscovered(IMutation mutation, World world, GameProfile name)
+  {
+    return isMutationDiscovered(mutation, getSpeciesRoot().getBreedingTracker(world, name));
+  }
+  
+  public final boolean isMutationDiscovered(IMutation mutation, IBreedingTracker tracker)
+  {
+    if (tracker == null) {
+      return true;
+    }
+    return tracker.isDiscovered(mutation);
+  }
+  
+  public final boolean isSpeciesDiscovered(IAlleleSpecies species, World world, GameProfile name)
+  {
+    return isSpeciesDiscovered(species, getSpeciesRoot().getBreedingTracker(world, name));
+  }
+  
+  public final boolean isSpeciesDiscovered(IAlleleSpecies species, IBreedingTracker tracker)
+  {
+    if (tracker == null) {
+      return true;
+    }
+    return tracker.isDiscovered(species);
+  }
+  
+  public final boolean isSecret(IAlleleSpecies species)
+  {
+    return !species.isCounted();
+  }
+  
+  public final boolean isSecret(IClassification branch)
+  {
+    for (IAlleleSpecies species : branch.getMemberSpecies()) {
+      if (!isSecret(species)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  
+  public final Collection<IClassification> getDiscoveredBranches(World world, GameProfile player)
+  {
+    List<IClassification> branches = new ArrayList();
+    for (IClassification branch : getAllBranches())
+    {
+      boolean discovered = false;
+      for (IAlleleSpecies species : branch.getMemberSpecies()) {
+        if (isSpeciesDiscovered(species, world, player)) {
+          discovered = true;
+        }
+      }
+      if (discovered) {
+        branches.add(branch);
+      }
+    }
+    return branches;
+  }
+  
+  public final Collection<IClassification> getDiscoveredBranches(IBreedingTracker tracker)
+  {
+    List<IClassification> branches = new ArrayList();
+    for (IClassification branch : getAllBranches())
+    {
+      boolean discovered = false;
+      for (IAlleleSpecies species : branch.getMemberSpecies()) {
+        if (isSpeciesDiscovered(species, tracker)) {
+          discovered = true;
+        }
+      }
+      if (discovered) {
+        branches.add(branch);
+      }
+    }
+    return branches;
+  }
+  
+  public final Collection<IAlleleSpecies> getDiscoveredSpecies(World world, GameProfile player)
+  {
+    List<IAlleleSpecies> speciesList = new ArrayList();
+    for (IAlleleSpecies species : getAllSpecies()) {
+      if (isSpeciesDiscovered(species, world, player)) {
+        speciesList.add(species);
+      }
+    }
+    return speciesList;
+  }
+  
+  public final Collection<IAlleleSpecies> getDiscoveredSpecies(IBreedingTracker tracker)
+  {
+    List<IAlleleSpecies> speciesList = new ArrayList();
+    for (IAlleleSpecies species : getAllSpecies()) {
+      if (isSpeciesDiscovered(species, tracker)) {
+        speciesList.add(species);
+      }
+    }
+    return speciesList;
+  }
+  
+  public final List<IMutation> getDiscoveredMutations(World world, GameProfile player)
+  {
+    List<IMutation> speciesList = new ArrayList();
+    for (IMutation species : getAllMutations()) {
+      if (isMutationDiscovered(species, world, player)) {
+        speciesList.add(species);
+      }
+    }
+    return speciesList;
+  }
+  
+  public final List<IMutation> getDiscoveredMutations(IBreedingTracker tracker)
+  {
+    List<IMutation> speciesList = new ArrayList();
+    for (IMutation species : getAllMutations()) {
+      if (isMutationDiscovered(species, tracker)) {
+        speciesList.add(species);
+      }
+    }
+    return speciesList;
+  }
+  
+  public final int getDiscoveredBranchMembers(IClassification branch, IBreedingTracker tracker)
+  {
+    int discoveredSpecies = 0;
+    for (IAlleleSpecies species : branch.getMemberSpecies()) {
+      if (isSpeciesDiscovered(species, tracker)) {
+        discoveredSpecies++;
+      }
+    }
+    return discoveredSpecies;
+  }
+  
+  public IIcon getUndiscoveredIcon()
+  {
+    return this.iconUndiscovered.getIcon();
+  }
+  
+  public IIcon getDiscoveredIcon()
+  {
+    return this.iconDiscovered.getIcon();
+  }
+  
+  public abstract float getChance(IMutation paramIMutation, EntityPlayer paramEntityPlayer, IAllele paramIAllele1, IAllele paramIAllele2);
+  
+  public abstract Class<? extends IBreedingTracker> getTrackerClass();
+  
+  @SubscribeEvent
+  public final void onSyncBreedingTracker(ForestryEvent.SyncedBreedingTracker event)
+  {
+    IBreedingTracker tracker = event.tracker;
+    if (!getTrackerClass().isInstance(tracker)) {
+      return;
+    }
+    syncTracker(tracker);
+  }
+  
+  public final void syncTracker(IBreedingTracker tracker)
+  {
+    this.discoveredSpeciesPercentage = 0.0F;
+    
+    this.totalSpeciesCount = 0;
+    this.discoveredSpeciesCount = 0;
+    
+    this.totalSecretCount = 0;
+    this.discoveredSecretCount = 0;
+    
+    Collection<IAlleleSpecies> discoveredSpecies = getDiscoveredSpecies(tracker);
+    Collection<IAlleleSpecies> allSpecies = getAllSpecies();
+    for (IAlleleSpecies species : allSpecies) {
+      if (!isSecret(species))
+      {
+        this.totalSpeciesCount += 1;
+        if (isSpeciesDiscovered(species, tracker)) {
+          this.discoveredSpeciesCount += 1;
+        }
+      }
+      else
+      {
+        this.totalSecretCount += 1;
+        if (isSpeciesDiscovered(species, tracker)) {
+          this.discoveredSecretCount += 1;
+        }
+      }
+    }
+    this.discoveredBranchPercentage = 0.0F;
+    
+    this.totalBranchCount = 0;
+    this.discoveredBranchCount = 0;
+    
+    Collection<IClassification> discoveredBranches = getDiscoveredBranches(tracker);
+    Collection<IClassification> allBranches = getAllBranches();
+    for (IClassification branch : allBranches) {
+      if (!isSecret(branch))
+      {
+        this.totalBranchCount += 1;
+        if (discoveredBranches.contains(branch)) {
+          this.discoveredBranchCount += 1;
+        }
+      }
+      else
+      {
+        this.totalSecretBranchCount += 1;
+        if (discoveredBranches.contains(branch)) {
+          this.discoveredSecretBranchCount += 1;
+        }
+      }
+    }
+    this.discoveredSpeciesPercentage = (this.discoveredSpeciesCount / this.totalSpeciesCount);
+    
+    this.discoveredBranchPercentage = (this.discoveredBranchCount / this.totalBranchCount);
+    
+
+    String epithet = getEpitome();
+    
+    onSyncBreedingTracker(tracker);
+  }
+  
+  public void onSyncBreedingTracker(IBreedingTracker tracker) {}
+  
+  public String getEpitome()
+  {
+    return getEpitome(this.discoveredSpeciesPercentage);
+  }
+  
+  public final String getDescriptor()
+  {
+    return BinnieCore.proxy.localise(getSpeciesRoot().getUID() + ".descriptor");
+  }
+  
+  public final String getIdent()
+  {
+    return getSpeciesRoot().getUID();
+  }
+  
+  public final IChromosomeType getChromosome(int i)
+  {
+    for (IChromosomeType chromosome : getSpeciesRoot().getKaryotype()) {
+      if (i == chromosome.ordinal()) {
+        return chromosome;
+      }
+    }
+    return null;
+  }
+  
+  public abstract int getColour();
+  
+  public String getAlleleName(IChromosomeType chromosome, IAllele allele)
+  {
+    if ((allele instanceof IAlleleBoolean)) {
+      return ((IAlleleBoolean)allele).getValue() ? Binnie.Language.localise(BinnieCore.instance, "allele.true") : Binnie.Language.localise(BinnieCore.instance, "allele.false");
+    }
+    if (allele.getName() == "for.gui.maximum") {
+      return Binnie.Language.localise(BinnieCore.instance, "allele.fertility.maximum");
+    }
+    return allele.getName();
+  }
+  
+  public String getName()
+  {
+    return BinnieCore.proxy.localise(getSpeciesRoot().getUID() + ".shortName");
+  }
+  
+  public ItemStack getItemStackRepresentitive()
+  {
+    IIndividual first = (IIndividual)getSpeciesRoot().getIndividualTemplates().get(0);
+    return getSpeciesRoot().getMemberStack(first, getDefaultType());
+  }
+  
+  public String toString()
+  {
+    return getName();
+  }
+  
+  public abstract boolean isDNAManipulable(ItemStack paramItemStack);
+  
+  public IIndividual getConversion(ItemStack stack)
+  {
+    return null;
+  }
+  
+  public final IIndividual getDefaultIndividual()
+  {
+    return getSpeciesRoot().templateAsIndividual(getSpeciesRoot().getDefaultTemplate());
+  }
+  
+  public final int getDefaultType()
+  {
+    return getActiveTypes()[0];
+  }
+  
+  public abstract int[] getActiveTypes();
+  
+  public abstract void addExtraAlleles(IChromosomeType paramIChromosomeType, TreeSet<IAllele> paramTreeSet);
+  
+  public ItemStack getConversionStack(ItemStack stack)
+  {
+    return getSpeciesRoot().getMemberStack(getConversion(stack), getDefaultType());
+  }
+  
+  public final Collection<IChromosomeType> getActiveKaryotype()
+  {
+    return Binnie.Genetics.getActiveChromosomes(getSpeciesRoot());
+  }
+  
+  public ItemStack getDefaultMember(String uid)
+  {
+    return getSpeciesRoot().getMemberStack(getIndividual(uid), getDefaultType());
+  }
+  
+  public IIndividual getIndividual(String uid)
+  {
+    return getSpeciesRoot().templateAsIndividual(getSpeciesRoot().getTemplate(uid));
+  }
+  
+  public IGenome getGenome(String uid)
+  {
+    return getSpeciesRoot().templateAsGenome(getSpeciesRoot().getTemplate(uid));
+  }
+}
diff --git a/src/Java/binnie/core/genetics/EnumBeeBooleanModifier.java b/src/Java/binnie/core/genetics/EnumBeeBooleanModifier.java
new file mode 100644
index 0000000000..58eae12e79
--- /dev/null
+++ b/src/Java/binnie/core/genetics/EnumBeeBooleanModifier.java
@@ -0,0 +1,8 @@
+package binnie.core.genetics;
+
+public enum EnumBeeBooleanModifier
+{
+  Sealed,  SelfLighted,  SunlightStimulated,  Hellish;
+  
+  private EnumBeeBooleanModifier() {}
+}
diff --git a/src/Java/binnie/core/genetics/EnumBeeModifier.java b/src/Java/binnie/core/genetics/EnumBeeModifier.java
new file mode 100644
index 0000000000..92fc30bda0
--- /dev/null
+++ b/src/Java/binnie/core/genetics/EnumBeeModifier.java
@@ -0,0 +1,17 @@
+package binnie.core.genetics;
+
+import binnie.Binnie;
+import binnie.core.BinnieCore;
+import binnie.core.language.ManagerLanguage;
+
+public enum EnumBeeModifier
+{
+  Territory,  Mutation,  Lifespan,  Production,  Flowering,  GeneticDecay;
+  
+  private EnumBeeModifier() {}
+  
+  public String getName()
+  {
+    return Binnie.Language.localise(BinnieCore.instance, "beemodifier." + name().toLowerCase());
+  }
+}
diff --git a/src/Java/binnie/core/genetics/FlowerBreedingSystem.java b/src/Java/binnie/core/genetics/FlowerBreedingSystem.java
new file mode 100644
index 0000000000..bc706976c8
--- /dev/null
+++ b/src/Java/binnie/core/genetics/FlowerBreedingSystem.java
@@ -0,0 +1,129 @@
+package binnie.core.genetics;
+
+import binnie.Binnie;
+import binnie.botany.api.EnumFlowerChromosome;
+import binnie.botany.api.EnumFlowerStage;
+import binnie.botany.api.IBotanistTracker;
+import binnie.botany.api.IFlowerMutation;
+import binnie.botany.api.IFlowerRoot;
+import binnie.botany.core.BotanyCore;
+import binnie.botany.genetics.EnumFlowerColor;
+import binnie.core.BinnieCore;
+import binnie.core.language.ManagerLanguage;
+import binnie.core.resource.ManagerResource;
+import binnie.extrabees.ExtraBees;
+import forestry.api.genetics.IAllele;
+import forestry.api.genetics.IBreedingTracker;
+import forestry.api.genetics.IChromosomeType;
+import forestry.api.genetics.IIndividual;
+import forestry.api.genetics.IMutation;
+import forestry.api.genetics.ISpeciesRoot;
+import java.util.TreeSet;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+
+class FlowerBreedingSystem
+  extends BreedingSystem
+{
+  public FlowerBreedingSystem()
+  {
+    this.iconUndiscovered = Binnie.Resource.getItemIcon(ExtraBees.instance, "icon/undiscoveredBee");
+    this.iconDiscovered = Binnie.Resource.getItemIcon(ExtraBees.instance, "icon/discoveredBee");
+  }
+  
+  public float getChance(IMutation mutation, EntityPlayer player, IAllele species1, IAllele species2)
+  {
+    return ((IFlowerMutation)mutation).getBaseChance();
+  }
+  
+  public ISpeciesRoot getSpeciesRoot()
+  {
+    return Binnie.Genetics.getFlowerRoot();
+  }
+  
+  public int getColour()
+  {
+    return 14563127;
+  }
+  
+  public Class<? extends IBreedingTracker> getTrackerClass()
+  {
+    return IBotanistTracker.class;
+  }
+  
+  public String getAlleleName(IChromosomeType chromosome, IAllele allele)
+  {
+    if (chromosome == EnumFlowerChromosome.FERTILITY)
+    {
+      if (allele.getUID().contains("Low")) {
+        return Binnie.Language.localise(BinnieCore.instance, "allele.fertility.low");
+      }
+      if (allele.getUID().contains("Normal")) {
+        return Binnie.Language.localise(BinnieCore.instance, "allele.fertility.normal");
+      }
+      if (allele.getUID().contains("High")) {
+        return Binnie.Language.localise(BinnieCore.instance, "allele.fertility.high");
+      }
+      if (allele.getUID().contains("Maximum")) {
+        return Binnie.Language.localise(BinnieCore.instance, "allele.fertility.maximum");
+      }
+    }
+    return super.getAlleleName(chromosome, allele);
+  }
+  
+  public boolean isDNAManipulable(ItemStack member)
+  {
+    return ((IFlowerRoot)getSpeciesRoot()).getType(member) == EnumFlowerStage.POLLEN;
+  }
+  
+  public IIndividual getConversion(ItemStack stack)
+  {
+    return BotanyCore.getFlowerRoot().getConversion(stack);
+  }
+  
+  public int[] getActiveTypes()
+  {
+    return new int[] { EnumFlowerStage.FLOWER.ordinal(), EnumFlowerStage.POLLEN.ordinal(), EnumFlowerStage.SEED.ordinal() };
+  }
+  
+  public void addExtraAlleles(IChromosomeType chromosome, TreeSet<IAllele> alleles)
+  {
+    switch (1.$SwitchMap$binnie$botany$api$EnumFlowerChromosome[((EnumFlowerChromosome)chromosome).ordinal()])
+    {
+    case 1: 
+      for (ForestryAllele.Fertility a : ForestryAllele.Fertility.values()) {
+        alleles.add(a.getAllele());
+      }
+      break;
+    case 2: 
+      for (ForestryAllele.Lifespan a : ForestryAllele.Lifespan.values()) {
+        alleles.add(a.getAllele());
+      }
+      break;
+    case 3: 
+    case 4: 
+    case 5: 
+      for (Tolerance a : Tolerance.values()) {
+        alleles.add(a.getAllele());
+      }
+      break;
+    case 6: