diff --git a/src/main/java/magicbees/bees/Allele.java b/src/main/java/magicbees/bees/Allele.java index 5c5b074..23bdf4a 100644 --- a/src/main/java/magicbees/bees/Allele.java +++ b/src/main/java/magicbees/bees/Allele.java @@ -1,8 +1,12 @@ package magicbees.bees; +import thaumcraft.api.nodes.NodeType; import magicbees.api.MagicBeesAPI; import magicbees.bees.allele.effect.AlleleEffectCrumbling; import magicbees.bees.allele.effect.AlleleEffectCure; +import magicbees.bees.allele.effect.AlleleEffectEmpowering; +import magicbees.bees.allele.effect.AlleleEffectNodeRepair; +import magicbees.bees.allele.effect.AlleleEffectNodeConversion; import magicbees.bees.allele.effect.AlleleEffectPotion; import magicbees.bees.allele.effect.AlleleEffectRecharge; import magicbees.bees.allele.effect.AlleleEffectSpawnMob; @@ -49,6 +53,11 @@ public class Allele implements IAllele { public static IAlleleEffect effectSlowSpeed; public static IAlleleEffect effectWithering; public static IAlleleEffect effectVisRecharge; + public static IAlleleEffect effectNodeEmpower; + public static IAlleleEffect effectNodeRepair; + public static IAlleleEffect effectNodeConversionTaint; + public static IAlleleEffect effectNodeConversionPure; + public static IAlleleEffect effectNodeConversionHungry; public static IAlleleEffect effectTransmuting; public static IAlleleEffect effectCrumbling; public static IAlleleEffect effectInvisibility; @@ -77,6 +86,11 @@ public class Allele implements IAllele { Allele.flowerAuraNode = new AlleleFlower("AuraNode", new FlowerProviderAuraNode(), true); Allele.effectVisRecharge = new AlleleEffectRecharge("VisRecharge", false); + Allele.effectNodeEmpower = new AlleleEffectEmpowering("NodeEmpower", false); + Allele.effectNodeRepair = new AlleleEffectNodeRepair("NodeRepair", false); + Allele.effectNodeConversionTaint = new AlleleEffectNodeConversion("NodeTainting", NodeType.TAINTED, false, 250); + Allele.effectNodeConversionPure = new AlleleEffectNodeConversion("NodePurifying", NodeType.PURE, false, 250); + Allele.effectNodeConversionHungry = new AlleleEffectNodeConversion("NodeRavening", NodeType.HUNGRY, false, 2); Allele.spawnBrainyZombie = new AlleleEffectSpawnMob("Brainy", false, ThaumcraftHelper.Entity.BRAINY_ZOMBIE.entityID) .setAggrosPlayerOnSpawn() @@ -222,7 +236,7 @@ public class Allele implements IAllele { registry.registerDeprecatedAlleleReplacement("thaumicbees.speciesVis", BeeSpecies.TC_VIS); registry.registerDeprecatedAlleleReplacement("thaumicbees.speciesPure", BeeSpecies.TC_PURE); registry.registerDeprecatedAlleleReplacement("thaumicbees.speciesFlux", BeeSpecies.TC_TAINT); - registry.registerDeprecatedAlleleReplacement("thaumicbees.speciesNode", BeeSpecies.TC_ATTRACT); + registry.registerDeprecatedAlleleReplacement("thaumicbees.speciesNode", BeeSpecies.TC_EMPOWERING); registry.registerDeprecatedAlleleReplacement("thaumicbees.speciesRejuvenating", BeeSpecies.TC_REJUVENATING); registry.registerDeprecatedAlleleReplacement("thaumicbees.speciesBrainy", BeeSpecies.TC_BRAINY); registry.registerDeprecatedAlleleReplacement("thaumicbees.speciesGossamer", BeeSpecies.TC_WISPY); @@ -246,6 +260,7 @@ public class Allele implements IAllele { registry.registerDeprecatedAlleleReplacement("thaumicbees.speciesArkanen", BeeSpecies.AM_ARCANE); registry.registerDeprecatedAlleleReplacement("thaumicbees.speciesVortex", BeeSpecies.AM_VORTEX); registry.registerDeprecatedAlleleReplacement("thaumicbees.speciesWight", BeeSpecies.AM_WIGHT); + registry.registerDeprecatedAlleleReplacement("magicbees.speciesTCAttractive", BeeSpecies.TC_EMPOWERING); } public static IAlleleBeeSpecies getBaseSpecies(String name) { diff --git a/src/main/java/magicbees/bees/AlleleEffect.java b/src/main/java/magicbees/bees/AlleleEffect.java index c6e5c59..73d7a6e 100644 --- a/src/main/java/magicbees/bees/AlleleEffect.java +++ b/src/main/java/magicbees/bees/AlleleEffect.java @@ -13,17 +13,24 @@ import forestry.api.genetics.IEffectData; public abstract class AlleleEffect extends Allele implements IAlleleBeeEffect { protected int throttle; + protected boolean combinable; public AlleleEffect(String id, boolean isDominant, int timeout) { super("effect" + id, isDominant); this.throttle = timeout; + combinable = false; } @Override public boolean isCombinable() { - return false; + return combinable; + } + + public AlleleEffect setIsCombinable(boolean canCombine) { + combinable = canCombine; + return this; } @Override diff --git a/src/main/java/magicbees/bees/BeeGenomeManager.java b/src/main/java/magicbees/bees/BeeGenomeManager.java index 623d526..b71dfdf 100644 --- a/src/main/java/magicbees/bees/BeeGenomeManager.java +++ b/src/main/java/magicbees/bees/BeeGenomeManager.java @@ -840,6 +840,7 @@ public class BeeGenomeManager { genome[EnumBeeChromosome.FERTILITY.ordinal()] = Allele.getBaseAllele("fertilityLow"); genome[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.getBaseAllele("toleranceBoth1"); genome[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.getBaseAllele("toleranceBoth1"); + genome[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowerAuraNode; return genome; } @@ -850,29 +851,45 @@ public class BeeGenomeManager { genome[EnumBeeChromosome.SPECIES.ordinal()] = BeeSpecies.TC_VIS; genome[EnumBeeChromosome.SPEED.ordinal()] = Allele.getBaseAllele("speedSlow"); genome[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.getBaseAllele("floweringSlower"); - genome[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowerAuraNode; return genome; } + public static IAllele[] getTemplateTCRejuvinating() { + IAllele[] genome = getTemplateTCBaseVis(); + + genome[EnumBeeChromosome.SPECIES.ordinal()] = BeeSpecies.TC_REJUVENATING; + genome[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectVisRecharge; + genome[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.getBaseAllele("toleranceNone"); + + return genome; + } + + public static IAllele[] getTemplateTCEmpowering() { + IAllele[] genome = getTemplateTCBaseVis(); + + genome[EnumBeeChromosome.SPECIES.ordinal()] = BeeSpecies.TC_EMPOWERING; + genome[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectNodeEmpower; + + return genome; + } + + public static IAllele[] getTemplateTCNexus() { + IAllele[] genome = getTemplateTCBaseVis(); + + genome[EnumBeeChromosome.SPECIES.ordinal()] = BeeSpecies.TC_NEXUS; + genome[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectNodeRepair; + + return genome; + } + public static IAllele[] getTemplateTCTaint() { IAllele[] genome = getTemplateTCBaseVis(); genome[EnumBeeChromosome.SPECIES.ordinal()] = BeeSpecies.TC_TAINT; genome[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.getBaseAllele("toleranceNone"); genome[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.getBaseAllele("toleranceNone"); - genome[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowerAuraNode; - //genome[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectNodeFlux; - - return genome; - } - - public static IAllele[] getTemplateTCAttract() { - IAllele[] genome = getTemplateTCBaseVis(); - - genome[EnumBeeChromosome.SPECIES.ordinal()] = BeeSpecies.TC_ATTRACT; - genome[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowerAuraNode; - //genome[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectNodeAttract; + genome[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectNodeConversionTaint; return genome; } @@ -884,23 +901,24 @@ public class BeeGenomeManager { genome[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.getBaseAllele("toleranceNone"); genome[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.getBaseAllele("toleranceNone"); genome[EnumBeeChromosome.FLOWERING.ordinal()] = Allele.getBaseAllele("floweringAverage"); - genome[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowerAuraNode; - //genome[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectNodePurify; + genome[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectNodeConversionPure; return genome; } - public static IAllele[] getTemplateTCRejuvinating() { + public static IAllele[] getTemplateTCHungry() { IAllele[] genome = getTemplateTCBaseVis(); - genome[EnumBeeChromosome.SPECIES.ordinal()] = BeeSpecies.TC_REJUVENATING; - genome[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectVisRecharge; - genome[EnumBeeChromosome.FLOWER_PROVIDER.ordinal()] = Allele.flowerAuraNode; + genome[EnumBeeChromosome.SPECIES.ordinal()] = BeeSpecies.TC_HUNGRY; + genome[EnumBeeChromosome.TERRITORY.ordinal()] = Allele.getBaseAllele("territoryLargest"); genome[EnumBeeChromosome.HUMIDITY_TOLERANCE.ordinal()] = Allele.getBaseAllele("toleranceNone"); + genome[EnumBeeChromosome.TEMPERATURE_TOLERANCE.ordinal()] = Allele.getBaseAllele("toleranceNone"); + genome[EnumBeeChromosome.EFFECT.ordinal()] = Allele.effectNodeConversionHungry; return genome; } + public static IAllele[] getTemplateTCBrainy() { IAllele[] genome = getTemplateBaseMalevolent(); diff --git a/src/main/java/magicbees/bees/BeeProductHelper.java b/src/main/java/magicbees/bees/BeeProductHelper.java index 95cc89b..ab731db 100644 --- a/src/main/java/magicbees/bees/BeeProductHelper.java +++ b/src/main/java/magicbees/bees/BeeProductHelper.java @@ -247,10 +247,15 @@ public class BeeProductHelper { TC_CHAOS.addProduct(Config.combs.getStackForType(CombType.TC_CHAOS), 0.20f); TC_VIS.addProduct(Config.combs.getStackForType(CombType.INTELLECT), 0.10f); - TC_TAINT.addProduct(Config.combs.getStackForType(CombType.INTELLECT), 0.18f); - TC_ATTRACT.addProduct(Config.combs.getStackForType(CombType.INTELLECT), 0.14f); - TC_PURE.addProduct(Config.combs.getStackForType(CombType.INTELLECT), 0.16f); TC_REJUVENATING.addProduct(Config.combs.getStackForType(CombType.INTELLECT), 0.18f); + TC_EMPOWERING.addProduct(Config.combs.getStackForType(CombType.INTELLECT), 0.14f); + TC_EMPOWERING.addSpecialty(new ItemStack(Config.fPollen, 1, ForestryHelper.Pollen.CRYSTALLINE.ordinal()), 0.2f); + TC_NEXUS.addProduct(Config.combs.getStackForType(CombType.INTELLECT), 0.25f); + TC_NEXUS.addProduct(Config.combs.getStackForType(CombType.TEMPORAL), 0.12f); + TC_NEXUS.addSpecialty(new ItemStack(Config.fPollen, 1, ForestryHelper.Pollen.CRYSTALLINE.ordinal()), 0.2f); + TC_TAINT.addProduct(Config.combs.getStackForType(CombType.INTELLECT), 0.18f); + TC_PURE.addProduct(Config.combs.getStackForType(CombType.INTELLECT), 0.16f); + TC_HUNGRY.addProduct(Config.combs.getStackForType(CombType.INTELLECT), 0.28f); TC_BRAINY.addProduct(Config.combs.getStackForType(CombType.FURTIVE), 0.10f) .addProduct(new ItemStack(Items.rotten_flesh), 0.6f); diff --git a/src/main/java/magicbees/bees/BeeSpecies.java b/src/main/java/magicbees/bees/BeeSpecies.java index a7fbd79..062a26d 100644 --- a/src/main/java/magicbees/bees/BeeSpecies.java +++ b/src/main/java/magicbees/bees/BeeSpecies.java @@ -186,28 +186,32 @@ public enum BeeSpecies implements IAlleleBeeSpecies, IIconProvider // --------- Thaumcraft Bees --------------------------------------------------------------------------------------- TC_AIR("TCAir", "aether", BeeClassification.THAUMIC, - 0xD9D636, BodyColours.THAUMCRAFT, EnumTemperature.NORMAL, EnumHumidity.NORMAL, true, true), + 0xD9D636, BodyColours.THAUMCRAFT_SHARD, EnumTemperature.NORMAL, EnumHumidity.NORMAL, true, true), TC_FIRE("TCFire", "praefervidus", BeeClassification.THAUMIC, - 0xE50B0B, BodyColours.THAUMCRAFT, EnumTemperature.HOT, EnumHumidity.ARID, true, true), + 0xE50B0B, BodyColours.THAUMCRAFT_SHARD, EnumTemperature.HOT, EnumHumidity.ARID, true, true), TC_WATER("TCWater", "umidus", BeeClassification.THAUMIC, - 0x36CFD9, BodyColours.THAUMCRAFT, EnumTemperature.NORMAL, EnumHumidity.DAMP, true, true), + 0x36CFD9, BodyColours.THAUMCRAFT_SHARD, EnumTemperature.NORMAL, EnumHumidity.DAMP, true, true), TC_EARTH("TCEarth", "sordida", BeeClassification.THAUMIC, - 0x005100, BodyColours.THAUMCRAFT, EnumTemperature.NORMAL, EnumHumidity.NORMAL, true, true), + 0x005100, BodyColours.THAUMCRAFT_SHARD, EnumTemperature.NORMAL, EnumHumidity.NORMAL, true, true), TC_ORDER("TCOrder", "ordinatus", BeeClassification.THAUMIC, - 0xaa32fc, BodyColours.THAUMCRAFT, EnumTemperature.NORMAL, EnumHumidity.NORMAL, true, true), + 0xaa32fc, BodyColours.THAUMCRAFT_SHARD, EnumTemperature.NORMAL, EnumHumidity.NORMAL, true, true), TC_CHAOS("TCChaos", "tenebrarum", BeeClassification.THAUMIC, - 0xCCCCCC, BodyColours.THAUMCRAFT, EnumTemperature.NORMAL, EnumHumidity.NORMAL, true, false), + 0xCCCCCC, BodyColours.THAUMCRAFT_SHARD, EnumTemperature.NORMAL, EnumHumidity.NORMAL, true, false), TC_VIS("TCVis", "arcanus saecula", BeeClassification.THAUMIC, - 0x004c99, 0x675ED1, EnumTemperature.NORMAL, EnumHumidity.NORMAL, false, false), - TC_TAINT("TCFlux", "arcanus labe", BeeClassification.THAUMIC, - 0x91376A, 0x675ED1, EnumTemperature.NORMAL, EnumHumidity.NORMAL, false, false), - TC_ATTRACT("TCAttractive", "tractus", BeeClassification.THAUMIC, - 0x96FFBC, 0x675ED1, EnumTemperature.NORMAL, EnumHumidity.NORMAL, false, true), + 0x004c99, BodyColours.THAUMCRAFT_NODE, EnumTemperature.NORMAL, EnumHumidity.NORMAL, false, false), TC_REJUVENATING("TCRejuvenating", "arcanus vitae", BeeClassification.THAUMIC, - 0x91D0D9, 0x675ED1, EnumTemperature.NORMAL, EnumHumidity.NORMAL, false, false), + 0x91D0D9, BodyColours.THAUMCRAFT_NODE, EnumTemperature.NORMAL, EnumHumidity.NORMAL, false, false), + TC_EMPOWERING("TCEmpowering", "tractus", BeeClassification.THAUMIC, + 0x96FFBC, BodyColours.THAUMCRAFT_NODE, EnumTemperature.NORMAL, EnumHumidity.NORMAL, false, true), + TC_NEXUS("TCNexus", "nexi", BeeClassification.THAUMIC, + 0x15AFAF, BodyColours.THAUMCRAFT_NODE, EnumTemperature.NORMAL, EnumHumidity.NORMAL, true, false), + TC_TAINT("TCFlux", "arcanus labe", BeeClassification.THAUMIC, + 0x91376A, BodyColours.THAUMCRAFT_NODE, EnumTemperature.NORMAL, EnumHumidity.NORMAL, false, false), TC_PURE("TCPure", "arcanus puritatem", BeeClassification.THAUMIC, - 0xb0092e, 0x675ED1, EnumTemperature.NORMAL, EnumHumidity.NORMAL, false, false), + 0xE23F65, BodyColours.THAUMCRAFT_NODE, EnumTemperature.NORMAL, EnumHumidity.NORMAL, false, false), + TC_HUNGRY("TCHungry", "omnique", BeeClassification.THAUMIC, + 0xDCA5E2, BodyColours.THAUMCRAFT_NODE, EnumTemperature.NORMAL, EnumHumidity.NORMAL, false, false), TC_BRAINY("TCBrainy", "cerebrum", BeeClassification.THAUMIC, 0x83FF70, BodyColours.SKULKING, EnumTemperature.NORMAL, EnumHumidity.NORMAL, false, true), @@ -327,12 +331,13 @@ public enum BeeSpecies implements IAlleleBeeSpecies, IIconProvider // For body colours used by more than one bee. private class BodyColours { - final static int DEFAULT = 0xFF7C26; + static final int DEFAULT = 0xFF7C26; static final int ARCANE = 0xFF9D60; static final int ABOMINABLE = 0x960F00; static final int EXTRINSIC = 0xF696FF; static final int SKULKING = 0xe15236; - static final int THAUMCRAFT = 0x999999; + static final int THAUMCRAFT_SHARD = 0x999999; + static final int THAUMCRAFT_NODE = 0x675ED1; static final int ARSMAGICA = 0xE3A55B; static final int BOTANIA = 0xFFB2BB; } @@ -405,10 +410,12 @@ public enum BeeSpecies implements IAlleleBeeSpecies, IIconProvider TC_ORDER.registerGenomeTemplate(BeeGenomeManager.getTemplateTCOrder()); TC_CHAOS.registerGenomeTemplate(BeeGenomeManager.getTemplateTCChaos()); TC_VIS.registerGenomeTemplate(BeeGenomeManager.getTemplateTCVis()); - TC_TAINT.registerGenomeTemplate(BeeGenomeManager.getTemplateTCTaint()); - TC_ATTRACT.registerGenomeTemplate(BeeGenomeManager.getTemplateTCAttract()); TC_REJUVENATING.registerGenomeTemplate(BeeGenomeManager.getTemplateTCRejuvinating()); + TC_EMPOWERING.registerGenomeTemplate(BeeGenomeManager.getTemplateTCEmpowering()); + TC_NEXUS.registerGenomeTemplate(BeeGenomeManager.getTemplateTCNexus()); + TC_TAINT.registerGenomeTemplate(BeeGenomeManager.getTemplateTCTaint()); TC_PURE.registerGenomeTemplate(BeeGenomeManager.getTemplateTCPure()); + TC_HUNGRY.registerGenomeTemplate(BeeGenomeManager.getTemplateTCHungry()); TC_BRAINY.registerGenomeTemplate(BeeGenomeManager.getTemplateTCBrainy()); TC_WISPY.registerGenomeTemplate(BeeGenomeManager.getTemplateTCWispy()); TC_BATTY.registerGenomeTemplate(BeeGenomeManager.getTemplateTCBatty()); @@ -477,7 +484,7 @@ public enum BeeSpecies implements IAlleleBeeSpecies, IIconProvider } // These species should be fixed. ¯\_(ツ)_/¯ TC_TAINT.setInactive(); - TC_ATTRACT.setInactive(); + TC_EMPOWERING.setInactive(); //TC_REJUVENATING.setInactive(); BeeProductHelper.initEquivalentExchange3Species(); diff --git a/src/main/java/magicbees/bees/allele/effect/AlleleEffectEmpowering.java b/src/main/java/magicbees/bees/allele/effect/AlleleEffectEmpowering.java new file mode 100644 index 0000000..31fdf81 --- /dev/null +++ b/src/main/java/magicbees/bees/allele/effect/AlleleEffectEmpowering.java @@ -0,0 +1,45 @@ +package magicbees.bees.allele.effect; + +import java.util.List; + +import magicbees.bees.AlleleEffect; +import magicbees.main.utils.BlockUtil; +import magicbees.main.utils.compat.thaumcraft.NodeHelper; +import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; +import forestry.api.apiculture.IBeeGenome; +import forestry.api.apiculture.IBeeHousing; +import forestry.api.genetics.IEffectData; + +public class AlleleEffectEmpowering extends AlleleEffect { + + public AlleleEffectEmpowering(String id, boolean isDominant) { + super(id, isDominant, 200); + combinable = true; + } + + @Override + public IEffectData validateStorage(IEffectData storedData) { + if (storedData == null || !(storedData instanceof magicbees.bees.EffectData)) { + storedData = new magicbees.bees.EffectData(1, 0, 0); + } + return storedData; + } + + @Override + protected IEffectData doEffectThrottled(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) { + World world = housing.getWorld(); + int xCoord = housing.getXCoord(); + int yCoord = housing.getYCoord(); + int zCoord = housing.getZCoord(); + int range = (int)Math.ceil(genome.getTerritory()[0] * housing.getTerritoryModifier(genome, 1f)); + List chunks = BlockUtil.getChunksInSearchRange(world, xCoord, zCoord, range); + + if (NodeHelper.growNodeInRange(chunks, world, xCoord, yCoord, zCoord, range)) { + storedData.setInteger(0, storedData.getInteger(0) - throttle); + } + + return storedData; + } + +} diff --git a/src/main/java/magicbees/bees/allele/effect/AlleleEffectNodeConversion.java b/src/main/java/magicbees/bees/allele/effect/AlleleEffectNodeConversion.java new file mode 100644 index 0000000..85e448d --- /dev/null +++ b/src/main/java/magicbees/bees/allele/effect/AlleleEffectNodeConversion.java @@ -0,0 +1,48 @@ +package magicbees.bees.allele.effect; + +import java.util.List; + +import magicbees.bees.AlleleEffect; +import magicbees.main.utils.BlockUtil; +import magicbees.main.utils.compat.thaumcraft.NodeHelper; +import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; +import thaumcraft.api.nodes.NodeType; +import forestry.api.apiculture.IBeeGenome; +import forestry.api.apiculture.IBeeHousing; +import forestry.api.genetics.IEffectData; + +public class AlleleEffectNodeConversion extends AlleleEffect { + + private NodeType targetType; + + public AlleleEffectNodeConversion(String id, NodeType targetNodeType, boolean isDominant, int timeout) { + super(id, isDominant, timeout); + targetType = targetNodeType; + } + + @Override + public IEffectData validateStorage(IEffectData storedData) { + if (storedData == null || !(storedData instanceof magicbees.bees.EffectData)) { + storedData = new magicbees.bees.EffectData(1, 0, 0); + } + return storedData; + } + + @Override + protected IEffectData doEffectThrottled(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) { + World world = housing.getWorld(); + int xCoord = housing.getXCoord(); + int yCoord = housing.getYCoord(); + int zCoord = housing.getZCoord(); + int range = (int)Math.ceil(genome.getTerritory()[0] * housing.getTerritoryModifier(genome, 1f)); + List chunks = BlockUtil.getChunksInSearchRange(world, xCoord, zCoord, range); + + if (NodeHelper.convertNodeInRangeToType(chunks, world, xCoord, yCoord, zCoord, range, targetType)) { + storedData.setInteger(0, storedData.getInteger(0) - throttle); + } + + return storedData; + } + +} diff --git a/src/main/java/magicbees/bees/allele/effect/AlleleEffectNodeRepair.java b/src/main/java/magicbees/bees/allele/effect/AlleleEffectNodeRepair.java new file mode 100644 index 0000000..952b3e5 --- /dev/null +++ b/src/main/java/magicbees/bees/allele/effect/AlleleEffectNodeRepair.java @@ -0,0 +1,44 @@ +package magicbees.bees.allele.effect; + +import java.util.List; + +import net.minecraft.world.World; +import net.minecraft.world.chunk.Chunk; +import forestry.api.apiculture.IBeeGenome; +import forestry.api.apiculture.IBeeHousing; +import forestry.api.genetics.IEffectData; +import magicbees.bees.AlleleEffect; +import magicbees.main.utils.BlockUtil; +import magicbees.main.utils.compat.thaumcraft.NodeHelper; + +public class AlleleEffectNodeRepair extends AlleleEffect { + + public AlleleEffectNodeRepair(String id, boolean isDominant) { + super(id, isDominant, 2); + } + + @Override + public IEffectData validateStorage(IEffectData storedData) { + if (storedData == null || !(storedData instanceof magicbees.bees.EffectData)) { + storedData = new magicbees.bees.EffectData(1, 0, 0); + } + return storedData; + } + + @Override + protected IEffectData doEffectThrottled(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) { + World world = housing.getWorld(); + int xCoord = housing.getXCoord(); + int yCoord = housing.getYCoord(); + int zCoord = housing.getZCoord(); + int range = (int)Math.ceil(genome.getTerritory()[0] * housing.getTerritoryModifier(genome, 1f)); + List chunks = BlockUtil.getChunksInSearchRange(world, xCoord, zCoord, range); + + if (NodeHelper.repairNodeInRange(chunks, world, xCoord, yCoord, zCoord, range)) { + storedData.setInteger(0, storedData.getInteger(0) - throttle); + } + + return storedData; + } + +} diff --git a/src/main/java/magicbees/bees/allele/effect/AlleleEffectRecharge.java b/src/main/java/magicbees/bees/allele/effect/AlleleEffectRecharge.java index acc48b9..d0fccf1 100644 --- a/src/main/java/magicbees/bees/allele/effect/AlleleEffectRecharge.java +++ b/src/main/java/magicbees/bees/allele/effect/AlleleEffectRecharge.java @@ -12,12 +12,10 @@ import forestry.api.apiculture.IBeeHousing; import forestry.api.genetics.IEffectData; public class AlleleEffectRecharge extends AlleleEffect { - - private int range; public AlleleEffectRecharge(String id, boolean isDominant) { - super(id, isDominant, 10); - range = 20; + super(id, isDominant, 20); + combinable = true; } @Override @@ -34,6 +32,7 @@ public class AlleleEffectRecharge extends AlleleEffect { int xCoord = housing.getXCoord(); int yCoord = housing.getYCoord(); int zCoord = housing.getZCoord(); + int range = (int)Math.ceil(genome.getTerritory()[0] * housing.getTerritoryModifier(genome, 1f)); List chunks = BlockUtil.getChunksInSearchRange(world, xCoord, zCoord, range); if (NodeHelper.rechargeNodeInRange(chunks, world, xCoord, yCoord, zCoord, range)) { diff --git a/src/main/java/magicbees/main/utils/compat/ThaumcraftHelper.java b/src/main/java/magicbees/main/utils/compat/ThaumcraftHelper.java index 1000c4d..28b18ae 100644 --- a/src/main/java/magicbees/main/utils/compat/ThaumcraftHelper.java +++ b/src/main/java/magicbees/main/utils/compat/ThaumcraftHelper.java @@ -224,12 +224,6 @@ public class ThaumcraftHelper { setupItemAspects(); setupCrafting(); setupResearch(); - - try { - nodeClass = (Class) Class.forName("thaumcraft.common.tiles.TileNode"); - } catch (Throwable e) { - e.printStackTrace(); - } } } diff --git a/src/main/java/magicbees/main/utils/compat/thaumcraft/NodeHelper.java b/src/main/java/magicbees/main/utils/compat/thaumcraft/NodeHelper.java index f8fd280..1f7e03d 100644 --- a/src/main/java/magicbees/main/utils/compat/thaumcraft/NodeHelper.java +++ b/src/main/java/magicbees/main/utils/compat/thaumcraft/NodeHelper.java @@ -2,8 +2,10 @@ package magicbees.main.utils.compat.thaumcraft; import java.util.ArrayList; import java.util.Collections; +import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Random; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.Vec3; @@ -13,8 +15,20 @@ import net.minecraft.world.chunk.Chunk; import thaumcraft.api.aspects.Aspect; import thaumcraft.api.aspects.AspectList; import thaumcraft.api.nodes.INode; +import thaumcraft.api.nodes.NodeModifier; +import thaumcraft.api.nodes.NodeType; public class NodeHelper { + + private static Map conversionChances; + + static { + conversionChances = new HashMap(); + conversionChances.put(NodeType.NORMAL, 0.075f); + conversionChances.put(NodeType.TAINTED, 0.057f); + conversionChances.put(NodeType.PURE, 0.035f); + conversionChances.put(NodeType.HUNGRY, 0.0094f); + } @SuppressWarnings("unchecked") public static INode findNode(Chunk chunk, int x, int y, int z, int range) { @@ -33,6 +47,24 @@ public class NodeHelper { return null; } + + @SuppressWarnings("unchecked") + public static List findNodesInChunkWithinRange(Chunk chunk, int x, int y, int z, int range) { + List nodes = new ArrayList(); + Vec3 apiaryPos = Vec3.createVectorHelper(x, y, z); + List tileEntities = new ArrayList(((Map)chunk.chunkTileEntityMap).values()); + for (TileEntity entity : tileEntities) { + if (entity instanceof INode) { + Vec3 tePos = Vec3.createVectorHelper(entity.xCoord, entity.yCoord, entity.zCoord); + Vec3 result = apiaryPos.subtract(tePos); + if (result.lengthVector() <= range) { + nodes.add((INode)entity); + } + } + } + + return nodes; + } public static boolean rechargeNodeInRange(List chunks, World world, int xCoord, int yCoord, int zCoord, int range) { Collections.shuffle(chunks); @@ -64,44 +96,106 @@ public class NodeHelper { public static boolean growNodeInRange(List chunks, World world, int xCoord, int yCoord, int zCoord, int range) { Collections.shuffle(chunks); + int attemptedNodes = 0; for (Chunk chunk : chunks) { - INode nearestNode = findNode(chunk, xCoord, yCoord, zCoord, range); - if (nearestNode != null) { - Aspect aspectToAdd; - if (0.55f <= world.rand.nextFloat()) { - List aspects = new ArrayList(Aspect.aspects.values()); - aspectToAdd = aspects.get(world.rand.nextInt(aspects.size())); + for (INode node : findNodesInChunkWithinRange(chunk, xCoord, yCoord, zCoord, range)) { + if (node != null) { + ++attemptedNodes; + AspectList aspectsBase = node.getAspectsBase(); + if (world.rand.nextInt(aspectsBase.visSize()) < 120) { + Aspect aspectToAdd; + int rollAttempts = 0; + do { + aspectToAdd = getWeightedRandomAspect(world.rand); + ++rollAttempts; + } + while (aspectsBase.getAmount(aspectToAdd) < 255 && 20 < rollAttempts); + + if (20 <= rollAttempts) { + return false; + } + + short amount = (short)(1 + world.rand.nextInt(2)); + aspectsBase.add(aspectToAdd, amount); + node.getAspects().add(aspectToAdd, amount); + updateNode(node, world); + return true; + } + } + } + } + return attemptedNodes < 10; + } + + public static Aspect getWeightedRandomAspect(Random rand) { + Aspect aspectToAdd; + if (0.685f <= rand.nextFloat()) { + List aspects = new ArrayList(Aspect.aspects.values()); + aspectToAdd = aspects.get(rand.nextInt(aspects.size())); + } + else { + switch (rand.nextInt(6)) { + default: + case 0: + aspectToAdd = Aspect.EARTH; + break; + case 1: + aspectToAdd = Aspect.WATER; + break; + case 2: + aspectToAdd = Aspect.FIRE; + break; + case 3: + aspectToAdd = Aspect.AIR; + break; + case 4: + aspectToAdd = Aspect.ORDER; + break; + case 5: + aspectToAdd = Aspect.ENTROPY; + break; + } + } + return aspectToAdd; + } + + public static boolean repairNodeInRange(List chunks, World world, int xCoord, int yCoord, int zCoord, int range) { + Collections.shuffle(chunks); + for (Chunk chunk : chunks) { + INode node = findNode(chunk, xCoord, yCoord, zCoord, range); + if (node != null) { + boolean nodeChanged = false; + if (node.getNodeType() == NodeType.UNSTABLE) { + node.setNodeType(NodeType.NORMAL); + nodeChanged = true; } else { - switch (world.rand.nextInt(6)) { - default: - case 0: - aspectToAdd = Aspect.EARTH; - break; - case 1: - aspectToAdd = Aspect.WATER; - break; - case 2: - aspectToAdd = Aspect.FIRE; - break; - case 3: - aspectToAdd = Aspect.AIR; - break; - case 4: - aspectToAdd = Aspect.ORDER; - break; - case 5: - aspectToAdd = Aspect.ENTROPY; - break; + NodeModifier modifier = node.getNodeModifier(); + if (modifier == NodeModifier.FADING) { + node.setNodeModifier(NodeModifier.PALE); + nodeChanged = true; + } + else if (modifier == NodeModifier.PALE) { + if (world.rand.nextFloat() < 0.65f) { + node.setNodeModifier(null); + nodeChanged = true; + } + } + else if (modifier == null) { + if (world.rand.nextFloat() < 0.15f) { + node.setNodeModifier(NodeModifier.BRIGHT); + nodeChanged = true; + } } } - nearestNode.setNodeVisBase(aspectToAdd, (short)(1 + world.rand.nextInt(2))); - updateNode(nearestNode, world); - return true; + if (nodeChanged) { + updateNode(node, world); + return true; + } } } - return false; + return true; } private static void updateNode(INode nearestNode, World world) { @@ -111,4 +205,38 @@ public class NodeHelper { world.markBlockForUpdate(tile.xCoord, tile.yCoord, tile.zCoord); } } + + public static boolean convertNodeInRangeToType(List chunks, World world, int xCoord, int yCoord, int zCoord, int range, NodeType targetType) { + Collections.shuffle(chunks); + int attemptedNodes = 0; + boolean nodeChanged = false; + for (Chunk chunk : chunks) { + for (INode node : findNodesInChunkWithinRange(chunk, xCoord, yCoord, zCoord, range)) { + ++attemptedNodes; + NodeType nodeType = node.getNodeType(); + if (nodeType != targetType && nodeType != NodeType.NORMAL) { + convertNodeToType(node, world, NodeType.NORMAL); + } + else if (nodeType == NodeType.NORMAL) { + convertNodeToType(node, world, targetType); + } + + if (nodeChanged) { + updateNode(node, world); + return true; + } + } + } + return attemptedNodes < 10; + } + + public static boolean convertNodeToType(INode node, World world, NodeType type) { + if (world.rand.nextFloat() < conversionChances.get(type)) { + node.setNodeType(type); + return true; + } + else { + return false; + } + } } diff --git a/src/main/resources/assets/magicbees/lang/en_US.lang b/src/main/resources/assets/magicbees/lang/en_US.lang index 59fc12f..f755446 100644 --- a/src/main/resources/assets/magicbees/lang/en_US.lang +++ b/src/main/resources/assets/magicbees/lang/en_US.lang @@ -373,14 +373,18 @@ magicbees.speciesTCChaos=Chaotic magicbees.speciesTCChaos.description=The social structure of their hives seems to vary day by day, making it more flexible and resillient than others, but significantly more unpredictable.|Apinomicon magicbees.speciesTCVis=Vis magicbees.speciesTCVis.description="They can feel changes in the aura, but are not yet able to affect it."|Azanor, research notes -magicbees.speciesTCPure=Pure -magicbees.speciesTCPure.description="It's like a bee janitor!"|MysteriousAges, Thaumaturge -magicbees.speciesTCFlux=Flux -magicbees.speciesTCFlux.description="I thought they would help clean up, but it only makes things worse!"|Kreicus, Apprentice Thaumaturge -magicbees.speciesTCAttractive=Attractive -magicbees.speciesTCAttractive.description=Having undergone a freak mutation, these bees now attract magic to them.|Apinomicon magicbees.speciesTCRejuvenating=Rejuvenating magicbees.speciesTCRejuvenating.description=The hum of the hive is magical, and over time is absorbed by nearby nodes.|Apinomicon +magicbees.speciesTCEmpowering=Empowering +magicbees.speciesTCEmpowering.description=So charged with aura are they, that nodes seem to wax in their presence.|Apinomicon +magicbees.speciesTCNexus=Nexus +magicbees.speciesTCNexus.description=Spoken only of in hushed whispers, their abilities to pass through nodes into the other side is scoffed at as imagined and fantasy.|Apinomicon +magicbees.speciesTCFlux=Flux +magicbees.speciesTCFlux.description="I thought they would help clean up, but it only makes things worse!"|Kreicus, Apprentice Thaumaturge +magicbees.speciesTCPure=Pure +magicbees.speciesTCPure.description="It's like a bee janitor!"|MysteriousAges, Thaumaturge +magicbees.speciesTCHungry=Ravening +magicbees.speciesTCHungry.description=It is unknown how the bees take raw essence from the nodes and what they do with it, but the process eventually transforms the node into a terrifying vortex.|Apinomicon magicbees.speciesTCBrainy=Brainy magicbees.speciesTCBrainy.description=Their combs may be fetid and foul-smelling, but their intelligence is well-developed.|Apinomicon magicbees.speciesTCWispy=Wispy @@ -494,10 +498,18 @@ magicbees.effectCrumbling=Crumbling binniecore.allele.magicbees.effectCrumbling.desc=Causes hard materials to become softer ones magicbees.effectInvisiblility=Invisibility binniecore.allele.magicbees.effectInvisiblility.desc=Turns players invisible -magicbees.effectNodeAttract=Aura Attract -magicbees.effectNodePurify=Purify Aura -magicbees.effectNodeFlux=Aura Flux -magicbees.effectNodeCharge=Aura Charge +magicbees.effectVisRecharge=Recharging +binniecore.allele.magicbees.effectVisRecharge.desc=Recharges nearby Aura Nodes +magicbees.effectNodeEmpower=Empowering +binniecore.allele.magicbees.effectNodeEmpower.desc=Overcharges nearby Aura Nodes permanently +magicbees.effectNodeRepair=Magnification +binniecore.allele.magicbees.effectNodeEmpower.desc=Makes Aura Nodes more vibrant +magicbees.effectNodeTainting=Tainting +binniecore.allele.magicbees.effectNodeEmpower.desc=Pollutes Aura Nodes +magicbees.effectNodePurifying=Purifying +binniecore.allele.magicbees.effectNodeEmpower.desc=Purifies Aura Nodes +magicbees.effectNodeRavening=Ravening +binniecore.allele.magicbees.effectNodeEmpower.desc=Starves Aura Nodes, changing their nature in an unusual way magicbees.effectBrainy=Brainy binniecore.allele.magicbees.effectBrainy.desc=Randomly spawns strong zombies magicbees.effectBatty=Batty