From 7871a490b84e8bd35f4e8f2671c5f5ea85c7728d Mon Sep 17 00:00:00 2001 From: bartimaeusnek <33183715+bartimaeusnek@users.noreply.github.com> Date: Sat, 22 Sep 2018 01:43:19 +0200 Subject: +added <1% bee mutation rate +fixed crashing w/o mods for bees --- .../java/gregtech/common/bees/GT_AlleleHelper.java | 224 +++++++++++++++++++++ 1 file changed, 224 insertions(+) create mode 100644 src/main/java/gregtech/common/bees/GT_AlleleHelper.java (limited to 'src/main/java/gregtech/common/bees/GT_AlleleHelper.java') diff --git a/src/main/java/gregtech/common/bees/GT_AlleleHelper.java b/src/main/java/gregtech/common/bees/GT_AlleleHelper.java new file mode 100644 index 0000000000..3431f96eb4 --- /dev/null +++ b/src/main/java/gregtech/common/bees/GT_AlleleHelper.java @@ -0,0 +1,224 @@ +package gregtech.common.bees; + +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.arboriculture.EnumTreeChromosome; +import forestry.api.genetics.*; +import forestry.api.lepidopterology.EnumButterflyChromosome; +import forestry.apiculture.flowers.FlowerProvider; +import forestry.core.config.Constants; +import forestry.core.genetics.alleles.*; +import forestry.core.utils.vect.IVect; +import forestry.plugins.PluginManager; + +import java.util.EnumMap; +import java.util.HashMap; +import java.util.Locale; +import java.util.Map; + +public class GT_AlleleHelper extends AlleleHelper { + + private static final String modId = Constants.ID; + + private final Map> alleleMaps = new HashMap<>(); + + public void init() { + if (PluginManager.Module.APICULTURE.isEnabled()) { + createAlleles(EnumAllele.Fertility.class, EnumBeeChromosome.FERTILITY); + createAlleles(EnumAllele.Flowering.class, EnumBeeChromosome.FLOWERING); + } + + if (PluginManager.Module.APICULTURE.isEnabled() || PluginManager.Module.ARBORICULTURE.isEnabled()) { + createAlleles(EnumAllele.Territory.class, + EnumBeeChromosome.TERRITORY, + EnumTreeChromosome.TERRITORY + ); + + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.territoryDefault", get(EnumAllele.Territory.AVERAGE)); + } + + if (PluginManager.Module.APICULTURE.isEnabled() || PluginManager.Module.LEPIDOPTEROLOGY.isEnabled()) { + createAlleles(EnumAllele.Speed.class, + EnumBeeChromosome.SPEED, + EnumButterflyChromosome.SPEED + ); + createAlleles(EnumAllele.Lifespan.class, + EnumBeeChromosome.LIFESPAN, + EnumButterflyChromosome.LIFESPAN + ); + createAlleles(EnumAllele.Tolerance.class, + EnumBeeChromosome.TEMPERATURE_TOLERANCE, + EnumBeeChromosome.HUMIDITY_TOLERANCE, + EnumButterflyChromosome.TEMPERATURE_TOLERANCE, + EnumButterflyChromosome.HUMIDITY_TOLERANCE + ); + createAlleles(EnumAllele.Flowers.class, + EnumBeeChromosome.FLOWER_PROVIDER, + EnumButterflyChromosome.FLOWER_PROVIDER + ); + + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.speedNorm", get(EnumAllele.Speed.NORMAL)); + } + + if (PluginManager.Module.ARBORICULTURE.isEnabled()) { + createAlleles(EnumAllele.Height.class, EnumTreeChromosome.HEIGHT); + createAlleles(EnumAllele.Saplings.class, EnumTreeChromosome.FERTILITY); + createAlleles(EnumAllele.Yield.class, EnumTreeChromosome.YIELD); + createAlleles(EnumAllele.Fireproof.class, EnumTreeChromosome.FIREPROOF); + createAlleles(EnumAllele.Maturation.class, EnumTreeChromosome.MATURATION); + createAlleles(EnumAllele.Sappiness.class, EnumTreeChromosome.SAPPINESS); + + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.heightMax10", get(EnumAllele.Height.AVERAGE)); + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.saplingsDefault", get(EnumAllele.Saplings.AVERAGE)); + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.saplingsDouble", get(EnumAllele.Saplings.HIGH)); + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.saplingsTriple", get(EnumAllele.Saplings.HIGHER)); + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.yieldDefault", get(EnumAllele.Yield.AVERAGE)); + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturitySlowest", get(EnumAllele.Maturation.SLOWEST)); + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturitySlower", get(EnumAllele.Maturation.SLOWER)); + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturitySlow", get(EnumAllele.Maturation.SLOW)); + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturityAverage", get(EnumAllele.Maturation.AVERAGE)); + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturityFast", get(EnumAllele.Maturation.FAST)); + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturityFaster", get(EnumAllele.Maturation.FASTER)); + AlleleManager.alleleRegistry.registerDeprecatedAlleleReplacement("forestry.maturityFastest", get(EnumAllele.Maturation.FASTEST)); + } + + if (PluginManager.Module.LEPIDOPTEROLOGY.isEnabled()) { + createAlleles(EnumAllele.Size.class, EnumButterflyChromosome.SIZE); + } + + Map integers = new HashMap<>(); + for (int i = 1; i <= 10; i++) { + IAlleleInteger alleleInteger = new AlleleInteger(modId, "i", i + "d", i, true); + AlleleManager.alleleRegistry.registerAllele(alleleInteger, + EnumTreeChromosome.GIRTH, + EnumButterflyChromosome.METABOLISM, + EnumButterflyChromosome.FERTILITY + ); + integers.put(i, alleleInteger); + } + alleleMaps.put(Integer.class, integers); + + Map booleans = new HashMap<>(); + booleans.put(true, new AlleleBoolean(modId, "bool", true, false)); + booleans.put(false, new AlleleBoolean(modId, "bool", false, false)); + for (IAlleleBoolean alleleBoolean : booleans.values()) { + AlleleManager.alleleRegistry.registerAllele(alleleBoolean, + EnumBeeChromosome.NOCTURNAL, + EnumBeeChromosome.TOLERANT_FLYER, + EnumBeeChromosome.CAVE_DWELLING, + EnumButterflyChromosome.NOCTURNAL, + EnumButterflyChromosome.TOLERANT_FLYER, + EnumButterflyChromosome.FIRE_RESIST + ); + } + alleleMaps.put(Boolean.class, booleans); + } + + public static void initialisation(){ + AlleleHelper.instance = new GT_AlleleHelper(); + AlleleHelper.instance.init(); + } + + + + @Override + public & IChromosomeType> void set(IAllele[] alleles, T chromosomeType, IAllele allele) { + + if (allele == null) { + return; + } + + if (!chromosomeType.getAlleleClass().isInstance(allele)) { + return; + } + + // uncomment this once all addon mods are using the allele registration with IChromosomeType + // Collection validTypes = AlleleManager.alleleRegistry.getChromosomeTypes(allele); + // if (validTypes.size() > 0 && !validTypes.contains(chromosomeType)) { + // throw new IllegalArgumentException("Allele can't applied to this Chromosome type. Expected: " + validTypes + " Got: " + chromosomeType); + // } + + alleles[chromosomeType.ordinal()] = allele; + } + + @Override + public & IChromosomeType> void set(IAllele[] alleles, T chromosomeType, IAlleleValue value) { + set(alleles, chromosomeType, get(value)); + } + + @Override + public & IChromosomeType> void set(IAllele[] alleles, T chromosomeType, boolean value) { + set(alleles, chromosomeType, get(value)); + } + + @Override + public & IChromosomeType> void set(IAllele[] alleles, T chromosomeType, int value) { + set(alleles, chromosomeType, get(value)); + } + + private IAllele get(Object value) { + Class valueClass = value.getClass(); + Map map = alleleMaps.get(valueClass); + if (map == null) { + throw new IllegalArgumentException("There is no IAllele type for: " + valueClass + ' ' + value); + } + IAllele allele = map.get(value); + if (allele == null) { + allele = new IAllele() { + @Override + public String getUID() { + return "NOT_FOUND"; + } + + @Override + public boolean isDominant() { + return false; + } + + @Override + public String getName() { + return "NOT_FOUND"; + } + + @Override + public String getUnlocalizedName() { + return "NOT_FOUND"; + } + }; + } + return allele; + } + + private & IAlleleValue, V> void createAlleles(Class enumClass, IChromosomeType... types) { + String category = enumClass.getSimpleName().toLowerCase(Locale.ENGLISH); + EnumMap map = new EnumMap<>(enumClass); + for (K enumValue : enumClass.getEnumConstants()) { + IAllele allele = createAllele(category, enumValue, types); + map.put(enumValue, allele); + } + alleleMaps.put(enumClass, map); + } + private static , V> IAllele createAllele(String category, K enumValue, IChromosomeType... types) { + V value = enumValue.getValue(); + boolean isDominant = enumValue.isDominant(); + String name = enumValue.toString().toLowerCase(Locale.ENGLISH); + + Class valueClass = value.getClass(); + if (Float.class.isAssignableFrom(valueClass)) { + return AlleleManager.alleleFactory.createFloat(modId, category, name, (Float) value, isDominant, types); + } else if (Integer.class.isAssignableFrom(valueClass)) { + return AlleleManager.alleleFactory.createInteger(modId, category, name, (Integer) value, isDominant, types); + } else if (IVect.class.isAssignableFrom(valueClass)) { + IVect area = (IVect) value; + return AlleleManager.alleleFactory.createArea(modId, category, name, area.getX(), area.getY(), area.getZ(), isDominant, types); + } else if (Boolean.class.isAssignableFrom(valueClass)) { + return AlleleManager.alleleFactory.createBoolean(modId, category, (Boolean) value, isDominant, types); + } else if (EnumTolerance.class.isAssignableFrom(valueClass)) { + IAlleleTolerance alleleTolerance = new AlleleTolerance(modId, category, name, (EnumTolerance) value, isDominant); + AlleleManager.alleleRegistry.registerAllele(alleleTolerance, types); + return alleleTolerance; + } else if (FlowerProvider.class.isAssignableFrom(valueClass)) { + return AlleleManager.alleleFactory.createFlowers(modId, category, name, (FlowerProvider) value, isDominant, types); + } + throw new RuntimeException("could not create allele for category: " + category + " and value " + valueClass); + } +} -- cgit