diff options
Diffstat (limited to 'src/Java/binnie/core/genetics/BreedingSystem.java')
| -rw-r--r-- | src/Java/binnie/core/genetics/BreedingSystem.java | 558 |
1 files changed, 558 insertions, 0 deletions
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)); + } +} |