diff options
Diffstat (limited to 'src/main/java/gregtech/common/bees')
3 files changed, 406 insertions, 0 deletions
diff --git a/src/main/java/gregtech/common/bees/GT_AlleleBeeSpecies.java b/src/main/java/gregtech/common/bees/GT_AlleleBeeSpecies.java new file mode 100644 index 0000000000..b264737677 --- /dev/null +++ b/src/main/java/gregtech/common/bees/GT_AlleleBeeSpecies.java @@ -0,0 +1,53 @@ +package gregtech.common.bees; + +import java.awt.Color; + +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.apiculture.IAlleleBeeSpeciesCustom; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IClassification; +import forestry.apiculture.genetics.alleles.AlleleBeeSpecies; + +public class GT_AlleleBeeSpecies extends AlleleBeeSpecies { + + public GT_AlleleBeeSpecies(String uid, boolean dominant, String unlocalizedName, String authority, + String unlocalizedDescription, IClassification branch, String binomial, Color primaryColor, + Color secondaryColor) { + super( + uid, + unlocalizedName, + authority, + unlocalizedDescription, + dominant, + branch, + binomial, + primaryColor.getRGB(), + secondaryColor.getRGB()); + AlleleManager.alleleRegistry.registerAllele(this, EnumBeeChromosome.SPECIES); + } + + @Override + public IAlleleBeeSpeciesCustom addProduct(ItemStack product, Float chance) { + if (product == null || product.getItem() == null) { + product = new ItemStack(Items.boat); + } + if (chance <= 0.0f || chance > 1.0f) { + chance = 0.1f; + } + return super.addProduct(product, chance); + } + + @Override + public IAlleleBeeSpeciesCustom addSpecialty(ItemStack specialty, Float chance) { + if (specialty == null || specialty.getItem() == null) { + specialty = new ItemStack(Items.boat); + } + if (chance <= 0.0f || chance > 1.0f) { + chance = 0.1f; + } + return super.addSpecialty(specialty, chance); + } +} 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..496aff29ca --- /dev/null +++ b/src/main/java/gregtech/common/bees/GT_AlleleHelper.java @@ -0,0 +1,268 @@ +package gregtech.common.bees; + +import java.util.EnumMap; +import java.util.HashMap; +import java.util.Locale; +import java.util.Map; + +import org.apache.commons.lang3.reflect.FieldUtils; + +import forestry.api.apiculture.EnumBeeChromosome; +import forestry.api.arboriculture.EnumTreeChromosome; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.EnumTolerance; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IAlleleBoolean; +import forestry.api.genetics.IAlleleInteger; +import forestry.api.genetics.IAlleleTolerance; +import forestry.api.genetics.IChromosomeType; +import forestry.api.lepidopterology.EnumButterflyChromosome; +import forestry.apiculture.flowers.FlowerProvider; +import forestry.core.config.Constants; +import forestry.core.genetics.alleles.AlleleBoolean; +import forestry.core.genetics.alleles.AlleleHelper; +import forestry.core.genetics.alleles.AlleleInteger; +import forestry.core.genetics.alleles.AlleleTolerance; +import forestry.core.genetics.alleles.EnumAllele; +import forestry.core.genetics.alleles.IAlleleValue; +import forestry.core.utils.vect.IVect; +import forestry.plugins.PluginManager; +import gregtech.GT_Mod; + +public class GT_AlleleHelper extends AlleleHelper { + + private static final String modId = Constants.ID; + + private Map<Class<?>, Map<?, ? extends IAllele>> alleleMaps = new HashMap<>(); + + @Override + 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<Integer, IAlleleInteger> 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<Boolean, IAlleleBoolean> 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); + } + + @SuppressWarnings("unchecked") + public static void initialisation() { + GT_AlleleHelper helper = new GT_AlleleHelper(); + + try { + helper.alleleMaps = (Map<Class<?>, Map<?, ? extends IAllele>>) FieldUtils + .readField(FieldUtils.getField(AlleleHelper.class, "alleleMaps", true), AlleleHelper.instance, true); + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + + AlleleHelper.instance = helper; + // AlleleHelper.instance.init(); + } + + @Override + public <T extends Enum<T> & IChromosomeType> void set(IAllele[] alleles, T chromosomeType, IAllele allele) { + + if (allele == null) { + GT_Mod.GT_FML_LOGGER.info("Allele is null!"); + return; + } + + if (!chromosomeType.getAlleleClass() + .isInstance(allele)) { + GT_Mod.GT_FML_LOGGER.info("chromosomeType is not an instance of allele!" + allele.getName()); + return; + } + + // TODO: uncomment this once all addon mods are using the allele registration with IChromosomeType + // Collection<IChromosomeType> validTypes = AlleleManager.alleleRegistry.getChromosomeTypes(allele); + // if (validTypes.size() > 0 && !validTypes.contains(chromosomeType)) { + // throw new IllegalArgumentException("Allele can't be applied to this Chromosome type. Expected: " + validTypes + // + " Got: " + chromosomeType); + // } + + alleles[chromosomeType.ordinal()] = allele; + } + + @Override + public <T extends Enum<T> & IChromosomeType> void set(IAllele[] alleles, T chromosomeType, IAlleleValue value) { + set(alleles, chromosomeType, get(value)); + } + + @Override + public <T extends Enum<T> & IChromosomeType> void set(IAllele[] alleles, T chromosomeType, boolean value) { + set(alleles, chromosomeType, get(value)); + } + + @Override + public <T extends Enum<T> & IChromosomeType> void set(IAllele[] alleles, T chromosomeType, int value) { + set(alleles, chromosomeType, get(value)); + } + + private IAllele get(Object value) { + Class<?> valueClass = value.getClass(); + Map<?, ? extends IAllele> 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 <K extends Enum<K> & IAlleleValue<V>, V> void createAlleles(Class<K> enumClass, IChromosomeType... types) { + String category = enumClass.getSimpleName() + .toLowerCase(Locale.ENGLISH); + EnumMap<K, IAllele> 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 <K extends IAlleleValue<V>, 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); + } +} diff --git a/src/main/java/gregtech/common/bees/GT_Bee_Mutation.java b/src/main/java/gregtech/common/bees/GT_Bee_Mutation.java new file mode 100644 index 0000000000..e8b2d5b8c6 --- /dev/null +++ b/src/main/java/gregtech/common/bees/GT_Bee_Mutation.java @@ -0,0 +1,85 @@ +package gregtech.common.bees; + +import java.lang.reflect.Field; +import java.util.List; + +import net.minecraft.util.ChunkCoordinates; +import net.minecraft.world.World; + +import org.apache.commons.lang3.reflect.FieldUtils; + +import forestry.api.apiculture.BeeManager; +import forestry.api.apiculture.IAlleleBeeSpecies; +import forestry.api.apiculture.IBeeGenome; +import forestry.api.apiculture.IBeeHousing; +import forestry.api.apiculture.IBeeModifier; +import forestry.api.core.IClimateProvider; +import forestry.api.genetics.IAllele; +import forestry.api.genetics.IGenome; +import forestry.api.genetics.IMutationCondition; +import forestry.apiculture.genetics.BeeMutation; +import forestry.core.genetics.mutations.Mutation; + +public class GT_Bee_Mutation extends BeeMutation { + + private final float split; + + public GT_Bee_Mutation(IAlleleBeeSpecies bee0, IAlleleBeeSpecies bee1, IAllele[] result, int chance, float split) { + super(bee0, bee1, result, chance); + this.split = split; + BeeManager.beeRoot.registerMutation(this); + } + + @Override + public float getBaseChance() { + return super.getBaseChance() / split; + } + + @Override + public float getChance(IBeeHousing housing, IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, + IBeeGenome genome0, IBeeGenome genome1) { + World world = housing != null ? housing.getWorld() : null; + ChunkCoordinates housingCoordinates = housing != null ? housing.getCoordinates() : null; + int x = housingCoordinates != null ? housingCoordinates.posX : 0; + int y = housingCoordinates != null ? housingCoordinates.posY : 0; + int z = housingCoordinates != null ? housingCoordinates.posZ : 0; + + float processedChance = getBasicChance(world, x, y, z, allele0, allele1, genome0, genome1, housing); + + if (processedChance <= 0f) { + return 0f; + } + + IBeeModifier beeHousingModifier = BeeManager.beeRoot.createBeeHousingModifier(housing); + IBeeModifier beeModeModifier = BeeManager.beeRoot.getBeekeepingMode(world) + .getBeeModifier(); + + processedChance *= beeHousingModifier.getMutationModifier(genome0, genome1, processedChance); + processedChance *= beeModeModifier.getMutationModifier(genome0, genome1, processedChance); + + return processedChance; + } + + @SuppressWarnings("unchecked") + private float getBasicChance(World world, int x, int y, int z, IAllele allele0, IAllele allele1, IGenome genome0, + IGenome genome1, IClimateProvider climate) { + float mutationChance = this.getBaseChance(); + List<IMutationCondition> mutationConditions = null; + Field f = FieldUtils.getDeclaredField(Mutation.class, "mutationConditions", true); + if (f == null) f = FieldUtils.getField(Mutation.class, "mutationConditions", true); + if (f == null) return mutationChance; + try { + mutationConditions = f.get(this) instanceof List ? (List<IMutationCondition>) f.get(this) : null; + } catch (IllegalAccessException e) { + e.printStackTrace(); + } + + if (mutationConditions != null) for (IMutationCondition mutationCondition : mutationConditions) { + mutationChance *= mutationCondition.getChance(world, x, y, z, allele0, allele1, genome0, genome1, climate); + if (mutationChance == 0) { + return 0; + } + } + return mutationChance; + } +} |