From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: YouHaveTrouble Date: Fri, 5 Feb 2021 01:11:22 +0100 Subject: [PATCH] Toggle for water sensitive mob damage diff --git a/net/minecraft/world/entity/GlowSquid.java b/net/minecraft/world/entity/GlowSquid.java index d556642fd07492aa52bfc0a2432ab3d16fe4f866..781f0adde9194162af57523aad4b73a358f622a7 100644 --- a/net/minecraft/world/entity/GlowSquid.java +++ b/net/minecraft/world/entity/GlowSquid.java @@ -44,6 +44,12 @@ public class GlowSquid extends Squid { this.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.glowSquidMaxHealth); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.glowSquidTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override public boolean canFly() { return this.level().purpurConfig.glowSquidsCanFly; diff --git a/net/minecraft/world/entity/ambient/Bat.java b/net/minecraft/world/entity/ambient/Bat.java index 5f11c687df87015261d1d39c957e241fbeb5476a..79175bd42f37f10fae812e101dd5b09b209ebe30 100644 --- a/net/minecraft/world/entity/ambient/Bat.java +++ b/net/minecraft/world/entity/ambient/Bat.java @@ -114,6 +114,12 @@ public class Bat extends AmbientCreature { this.getAttribute(Attributes.ATTACK_KNOCKBACK).setBaseValue(this.level().purpurConfig.batAttackKnockback); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.batTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override public boolean isFlapping() { return !this.isResting() && (float) this.tickCount % 10.0F == 0.0F; diff --git a/net/minecraft/world/entity/animal/Bee.java b/net/minecraft/world/entity/animal/Bee.java index 121a4c58d4052eb0880f540e87beaf12a74eecd7..40137a98174cd0238d06c894373984a403f96fbc 100644 --- a/net/minecraft/world/entity/animal/Bee.java +++ b/net/minecraft/world/entity/animal/Bee.java @@ -186,7 +186,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal { // Paper end - Fix MC-167279 this.lookControl = new Bee.BeeLookControl(this); this.setPathfindingMalus(PathType.DANGER_FIRE, -1.0F); - this.setPathfindingMalus(PathType.WATER, -1.0F); + if (isSensitiveToWater()) this.setPathfindingMalus(PathType.WATER, -1.0F); // Purpur - Toggle for water sensitive mob damage this.setPathfindingMalus(PathType.WATER_BORDER, 16.0F); this.setPathfindingMalus(PathType.COCOA, -1.0F); this.setPathfindingMalus(PathType.FENCE, -1.0F); @@ -502,6 +502,11 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal { return this.level().purpurConfig.beeBreedingTicks; } // Purpur end - Make entity breeding times configurable + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.beeTakeDamageFromWater; + } + @Override public int getRemainingPersistentAngerTime() { return (Integer) this.entityData.get(Bee.DATA_REMAINING_ANGER_TIME); diff --git a/net/minecraft/world/entity/animal/Cat.java b/net/minecraft/world/entity/animal/Cat.java index 8d20b19b65616d8470542cc7337c8ddd7418be0b..75a961906658ff271bc0acf849648ce877c9e1be 100644 --- a/net/minecraft/world/entity/animal/Cat.java +++ b/net/minecraft/world/entity/animal/Cat.java @@ -138,6 +138,12 @@ public class Cat extends TamableAnimal implements VariantHolder { diff --git a/net/minecraft/world/entity/animal/Chicken.java b/net/minecraft/world/entity/animal/Chicken.java index d06fb7d714efc88af13e6357536d4c58a7ec3bb5..09ad3ca4fd5aaebb1f394e73bc030ffa798346ba 100644 --- a/net/minecraft/world/entity/animal/Chicken.java +++ b/net/minecraft/world/entity/animal/Chicken.java @@ -88,6 +88,12 @@ public class Chicken extends Animal { return this.level().purpurConfig.chickenBreedingTicks; } // Purpur end - Make entity breeding times configurable + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.chickenTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { this.goalSelector.addGoal(0, new FloatGoal(this)); diff --git a/net/minecraft/world/entity/animal/Cod.java b/net/minecraft/world/entity/animal/Cod.java index dad2dc77afead53e0fa7f2f797ac3850279d5d40..478fb13b84609a545713371f903e4d6042747e94 100644 --- a/net/minecraft/world/entity/animal/Cod.java +++ b/net/minecraft/world/entity/animal/Cod.java @@ -31,6 +31,12 @@ public class Cod extends AbstractSchoolingFish { this.getAttribute(net.minecraft.world.entity.ai.attributes.Attributes.MAX_HEALTH).setBaseValue(this.level().purpurConfig.codMaxHealth); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.codTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override public ItemStack getBucketItemStack() { return new ItemStack(Items.COD_BUCKET); diff --git a/net/minecraft/world/entity/animal/Cow.java b/net/minecraft/world/entity/animal/Cow.java index 4b27440624deda151f63f7ce4670fd805d24eaba..4d5d4f7bb24aded2933daa003b4c4bc38601e12d 100644 --- a/net/minecraft/world/entity/animal/Cow.java +++ b/net/minecraft/world/entity/animal/Cow.java @@ -74,6 +74,12 @@ public class Cow extends Animal { return this.level().purpurConfig.cowBreedingTicks; } // Purpur end - Make entity breeding times configurable + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.cowTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { this.goalSelector.addGoal(0, new FloatGoal(this)); diff --git a/net/minecraft/world/entity/animal/Dolphin.java b/net/minecraft/world/entity/animal/Dolphin.java index 5dfaed8ecf9438e8ea11cadd6c5638e0cc25cbb1..46862ebf302454a077a837da001abdceeffa1026 100644 --- a/net/minecraft/world/entity/animal/Dolphin.java +++ b/net/minecraft/world/entity/animal/Dolphin.java @@ -168,6 +168,12 @@ public class Dolphin extends AgeableWaterCreature { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.dolphinScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.dolphinTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Nullable @Override public SpawnGroupData finalizeSpawn(ServerLevelAccessor world, DifficultyInstance difficulty, EntitySpawnReason spawnReason, @Nullable SpawnGroupData entityData) { diff --git a/net/minecraft/world/entity/animal/Fox.java b/net/minecraft/world/entity/animal/Fox.java index 7770288abae40de80954ce47a15e609ee1b3a8bc..a758f312ae4ed4a0404ca7cedbd8c7b88aef58f4 100644 --- a/net/minecraft/world/entity/animal/Fox.java +++ b/net/minecraft/world/entity/animal/Fox.java @@ -195,6 +195,12 @@ public class Fox extends Animal implements VariantHolder { return this.level().purpurConfig.foxBreedingTicks; } // Purpur end - Make entity breeding times configurable + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.foxTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void defineSynchedData(SynchedEntityData.Builder builder) { super.defineSynchedData(builder); diff --git a/net/minecraft/world/entity/animal/IronGolem.java b/net/minecraft/world/entity/animal/IronGolem.java index 124b7d6881964039829313c52427e332e1ac526b..74971f19a646b78bff66d2543d80d9358fdd29c5 100644 --- a/net/minecraft/world/entity/animal/IronGolem.java +++ b/net/minecraft/world/entity/animal/IronGolem.java @@ -86,6 +86,12 @@ public class IronGolem extends AbstractGolem implements NeutralMob { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.ironGolemScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.ironGolemTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { if (level().purpurConfig.ironGolemCanSwim) this.goalSelector.addGoal(0, new net.minecraft.world.entity.ai.goal.FloatGoal(this)); // Purpur - Ridables diff --git a/net/minecraft/world/entity/animal/MushroomCow.java b/net/minecraft/world/entity/animal/MushroomCow.java index 28b544f4f2e0f30d831b57167fc3ea3ce28e2191..a8694e39954db18840e7c066ef6bcb58e3399c0b 100644 --- a/net/minecraft/world/entity/animal/MushroomCow.java +++ b/net/minecraft/world/entity/animal/MushroomCow.java @@ -93,6 +93,12 @@ public class MushroomCow extends Cow implements Shearable, VariantHolder { return this.level().purpurConfig.rabbitBreedingTicks; } // Purpur end - Make entity breeding times configurable + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.rabbitTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override public void registerGoals() { this.goalSelector.addGoal(1, new FloatGoal(this)); diff --git a/net/minecraft/world/entity/animal/Salmon.java b/net/minecraft/world/entity/animal/Salmon.java index 88f0f9074db9a9afff55aa6bd17c38fa2e1e1f81..053c2773b52bd3399c3812452dbee2d1882d32a2 100644 --- a/net/minecraft/world/entity/animal/Salmon.java +++ b/net/minecraft/world/entity/animal/Salmon.java @@ -53,6 +53,12 @@ public class Salmon extends AbstractSchoolingFish implements VariantHolder, B return this.level().purpurConfig.axolotlBreedingTicks; } // Purpur end - Make entity breeding times configurable + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.axolotlTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override public float getWalkTargetValue(BlockPos pos, LevelReader world) { return 0.0F; diff --git a/net/minecraft/world/entity/animal/goat/Goat.java b/net/minecraft/world/entity/animal/goat/Goat.java index c9d7be823a040e7de407537d247062821dca643a..4a8ac3d75a3c75eea8e361d7eb729f27ea807347 100644 --- a/net/minecraft/world/entity/animal/goat/Goat.java +++ b/net/minecraft/world/entity/animal/goat/Goat.java @@ -116,6 +116,12 @@ public class Goat extends Animal { return this.level().purpurConfig.goatBreedingTicks; } // Purpur end - Make entity breeding times configurable + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.goatTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected Brain.Provider brainProvider() { return Brain.provider(Goat.MEMORY_TYPES, Goat.SENSOR_TYPES); diff --git a/net/minecraft/world/entity/animal/horse/Donkey.java b/net/minecraft/world/entity/animal/horse/Donkey.java index 4cff4fcedc75a99ca71ae6a7c34d6f407665bf1b..6a511e01f8805451ce89d697568c23803b5985a8 100644 --- a/net/minecraft/world/entity/animal/horse/Donkey.java +++ b/net/minecraft/world/entity/animal/horse/Donkey.java @@ -45,6 +45,12 @@ public class Donkey extends AbstractChestedHorse { return this.level().purpurConfig.donkeyBreedingTicks; } // Purpur end - Make entity breeding times configurable + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.donkeyTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected SoundEvent getAmbientSound() { return SoundEvents.DONKEY_AMBIENT; diff --git a/net/minecraft/world/entity/animal/horse/Horse.java b/net/minecraft/world/entity/animal/horse/Horse.java index cbeb7d1e834a4f0f120248bec619e34ca46f8069..c5ba0669b7e184ac42243a65a230fe325c3f84cc 100644 --- a/net/minecraft/world/entity/animal/horse/Horse.java +++ b/net/minecraft/world/entity/animal/horse/Horse.java @@ -72,6 +72,12 @@ public class Horse extends AbstractHorse implements VariantHolder { return this.level().purpurConfig.horseBreedingTicks; } // Purpur end - Make entity breeding times configurable + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.horseTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void randomizeAttributes(RandomSource random) { this.getAttribute(Attributes.MAX_HEALTH).setBaseValue((double)generateMaxHealth(random::nextInt)); diff --git a/net/minecraft/world/entity/animal/horse/Llama.java b/net/minecraft/world/entity/animal/horse/Llama.java index ea396b5740ae1e7b2cf5356607835467b412d379..fa1bf3e2e11564b9528e056369a610cb5bbd25d0 100644 --- a/net/minecraft/world/entity/animal/horse/Llama.java +++ b/net/minecraft/world/entity/animal/horse/Llama.java @@ -146,6 +146,12 @@ public class Llama extends AbstractChestedHorse implements VariantHolder type, Level world) { super(type, world); this.moveControl = new org.purpurmc.purpur.controller.FlyingWithSpacebarMoveControllerWASD(this, 0.3F); // Purpur - Ridables - this.setPathfindingMalus(PathType.WATER, -1.0F); + if (isSensitiveToWater()) this.setPathfindingMalus(PathType.WATER, -1.0F); // Purpur - Toggle for water sensitive mob damage this.setPathfindingMalus(PathType.LAVA, 8.0F); this.setPathfindingMalus(PathType.DANGER_FIRE, 0.0F); this.setPathfindingMalus(PathType.DAMAGE_FIRE, 0.0F); @@ -156,7 +156,7 @@ public class Blaze extends Monster { @Override public boolean isSensitiveToWater() { - return true; + return this.level().purpurConfig.blazeTakeDamageFromWater; // Purpur - Toggle for water sensitive mob damage } @Override diff --git a/net/minecraft/world/entity/monster/CaveSpider.java b/net/minecraft/world/entity/monster/CaveSpider.java index 9d8d836c93635f133a2ad6911cac9b8ac24f1f57..6de7a8cf41af2a4d2988f86341ba4329f9c45361 100644 --- a/net/minecraft/world/entity/monster/CaveSpider.java +++ b/net/minecraft/world/entity/monster/CaveSpider.java @@ -51,6 +51,12 @@ public class CaveSpider extends Spider { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.caveSpiderScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.caveSpiderTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override public boolean doHurtTarget(ServerLevel world, Entity target) { if (super.doHurtTarget(world, target)) { diff --git a/net/minecraft/world/entity/monster/Creeper.java b/net/minecraft/world/entity/monster/Creeper.java index 4711f5e5d9f1738d739be68f586f744eba8621c9..76e0dcedc72576c0e0a85e09a762aa5e2b63c7ef 100644 --- a/net/minecraft/world/entity/monster/Creeper.java +++ b/net/minecraft/world/entity/monster/Creeper.java @@ -267,6 +267,12 @@ public class Creeper extends Monster { return super.finalizeSpawn(world, difficulty, spawnReason, entityData); } // Purpur end - Charged creeper naturally spawn + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.creeperTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected SoundEvent getHurtSound(DamageSource source) { diff --git a/net/minecraft/world/entity/monster/Drowned.java b/net/minecraft/world/entity/monster/Drowned.java index 3f02cb4924817ed132d2b17b97a67f7d7bf57cb8..7651c29a6468e93bd10d58f76a86a68912509bd3 100644 --- a/net/minecraft/world/entity/monster/Drowned.java +++ b/net/minecraft/world/entity/monster/Drowned.java @@ -120,6 +120,12 @@ public class Drowned extends Zombie implements RangedAttackMob { return level().purpurConfig.drownedJockeyTryExistingChickens; } // Purpur end - Configurable jockey options + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.drownedTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void addBehaviourGoals() { this.goalSelector.addGoal(1, new Drowned.DrownedGoToWaterGoal(this, 1.0)); diff --git a/net/minecraft/world/entity/monster/ElderGuardian.java b/net/minecraft/world/entity/monster/ElderGuardian.java index 011327ea9bf9ef3497f2183ef149f8ec9bb29fab..d69716edb777155d0b52db25af64107e4657e03c 100644 --- a/net/minecraft/world/entity/monster/ElderGuardian.java +++ b/net/minecraft/world/entity/monster/ElderGuardian.java @@ -52,6 +52,12 @@ public class ElderGuardian extends Guardian { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.elderGuardianScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.elderGuardianTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage public static AttributeSupplier.Builder createAttributes() { return Guardian.createAttributes().add(Attributes.MOVEMENT_SPEED, 0.30000001192092896D).add(Attributes.ATTACK_DAMAGE, 8.0D).add(Attributes.MAX_HEALTH, 80.0D); } diff --git a/net/minecraft/world/entity/monster/EnderMan.java b/net/minecraft/world/entity/monster/EnderMan.java index 61a113074a6839d6dcb59019eefe9f532fb9cb2b..a92c30b5d3079ce58e00b9824ec3a60e6b41f104 100644 --- a/net/minecraft/world/entity/monster/EnderMan.java +++ b/net/minecraft/world/entity/monster/EnderMan.java @@ -91,7 +91,7 @@ public class EnderMan extends Monster implements NeutralMob { public EnderMan(EntityType type, Level world) { super(type, world); - this.setPathfindingMalus(PathType.WATER, -1.0F); + if (isSensitiveToWater()) this.setPathfindingMalus(PathType.WATER, -1.0F); // Purpur - Toggle for water sensitive mob damage } // Purpur start - Ridables @@ -288,7 +288,7 @@ public class EnderMan extends Monster implements NeutralMob { @Override public boolean isSensitiveToWater() { - return true; + return this.level().purpurConfig.endermanTakeDamageFromWater; // Purpur - Toggle for water sensitive mob damage } @Override diff --git a/net/minecraft/world/entity/monster/Endermite.java b/net/minecraft/world/entity/monster/Endermite.java index aeeb003cc43d6cff87a634099299ff30db7ed10b..fa4f25c7aece94a7468da1d7ed3cbd1abbce9640 100644 --- a/net/minecraft/world/entity/monster/Endermite.java +++ b/net/minecraft/world/entity/monster/Endermite.java @@ -62,6 +62,12 @@ public class Endermite extends Monster { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.endermiteScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.endermiteTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { this.goalSelector.addGoal(1, new FloatGoal(this)); diff --git a/net/minecraft/world/entity/monster/Evoker.java b/net/minecraft/world/entity/monster/Evoker.java index 05f859c3062c34f1fdb74c43423c1f5767180c1f..8cc90983c0e4781b4cc73040ceba069e302f7664 100644 --- a/net/minecraft/world/entity/monster/Evoker.java +++ b/net/minecraft/world/entity/monster/Evoker.java @@ -77,6 +77,12 @@ public class Evoker extends SpellcasterIllager { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.evokerScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.evokerTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { super.registerGoals(); diff --git a/net/minecraft/world/entity/monster/Ghast.java b/net/minecraft/world/entity/monster/Ghast.java index b0d7bbca3c3a34f329698ee70ec0bea60c76b12e..67bc0ec362929099e741486e3424770478a046d9 100644 --- a/net/minecraft/world/entity/monster/Ghast.java +++ b/net/minecraft/world/entity/monster/Ghast.java @@ -85,6 +85,12 @@ public class Ghast extends FlyingMob implements Enemy { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.ghastScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.ghastTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur - Ridables diff --git a/net/minecraft/world/entity/monster/Giant.java b/net/minecraft/world/entity/monster/Giant.java index adc90a306fc9023f4a1cdfe9f58c39726086c849..4bf1414569685e9e8704216c9dcf585def88b2e5 100644 --- a/net/minecraft/world/entity/monster/Giant.java +++ b/net/minecraft/world/entity/monster/Giant.java @@ -59,6 +59,12 @@ public class Giant extends Monster { this.getAttribute(Attributes.ATTACK_DAMAGE).setBaseValue(this.level().purpurConfig.giantAttackDamage); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.giantTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage public static AttributeSupplier.Builder createAttributes() { return Monster.createMonsterAttributes().add(Attributes.MAX_HEALTH, 100.0).add(Attributes.MOVEMENT_SPEED, 0.5).add(Attributes.ATTACK_DAMAGE, 50.0); } diff --git a/net/minecraft/world/entity/monster/Guardian.java b/net/minecraft/world/entity/monster/Guardian.java index 210e9dacd001e2e0c1a95d41c6a31aea6eab893b..01917ec09069be5d8b1051969367df1e53ff38ca 100644 --- a/net/minecraft/world/entity/monster/Guardian.java +++ b/net/minecraft/world/entity/monster/Guardian.java @@ -98,6 +98,12 @@ public class Guardian extends Monster { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.guardianScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.guardianTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { MoveTowardsRestrictionGoal pathfindergoalmovetowardsrestriction = new MoveTowardsRestrictionGoal(this, 1.0D); diff --git a/net/minecraft/world/entity/monster/Husk.java b/net/minecraft/world/entity/monster/Husk.java index cd155b47369318f58ec55289a345f1bf28e2af14..43887b5aa533d456de5e66da2a3bef82aed58084 100644 --- a/net/minecraft/world/entity/monster/Husk.java +++ b/net/minecraft/world/entity/monster/Husk.java @@ -67,6 +67,12 @@ public class Husk extends Zombie { return level().purpurConfig.huskJockeyTryExistingChickens; } // Purpur end - Configurable jockey options + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.huskTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage public static boolean checkHuskSpawnRules(EntityType type, ServerLevelAccessor world, EntitySpawnReason spawnReason, BlockPos pos, RandomSource random) { return checkMonsterSpawnRules(type, world, spawnReason, pos, random) && (EntitySpawnReason.isSpawner(spawnReason) || world.canSeeSky(pos)); } diff --git a/net/minecraft/world/entity/monster/Illusioner.java b/net/minecraft/world/entity/monster/Illusioner.java index 6e3362324c81afacaaa0f9766e2d23a0a4f53ac3..d0fe85e7c44b78a078e6c2d6220849a336b079d3 100644 --- a/net/minecraft/world/entity/monster/Illusioner.java +++ b/net/minecraft/world/entity/monster/Illusioner.java @@ -85,6 +85,12 @@ public class Illusioner extends SpellcasterIllager implements RangedAttackMob { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.illusionerScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.illusionerTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { super.registerGoals(); diff --git a/net/minecraft/world/entity/monster/MagmaCube.java b/net/minecraft/world/entity/monster/MagmaCube.java index 5ba64f9c653345b742624f18c4cf692d1e7880e1..8f0e9f854c4032c43cc1c9a8b087a5fa286326d8 100644 --- a/net/minecraft/world/entity/monster/MagmaCube.java +++ b/net/minecraft/world/entity/monster/MagmaCube.java @@ -67,6 +67,12 @@ public class MagmaCube extends Slime { return level().purpurConfig.magmaCubeAttackDamageCache; } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.magmaCubeTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage public static AttributeSupplier.Builder createAttributes() { return Monster.createMonsterAttributes().add(Attributes.MOVEMENT_SPEED, 0.2F); } diff --git a/net/minecraft/world/entity/monster/Phantom.java b/net/minecraft/world/entity/monster/Phantom.java index 7926c11714b0f50fd02f2da4817c822fd5f60115..f09830c1c88f4b28f05e1647706a3c96a596ad1e 100644 --- a/net/minecraft/world/entity/monster/Phantom.java +++ b/net/minecraft/world/entity/monster/Phantom.java @@ -120,6 +120,12 @@ public class Phantom extends FlyingMob implements Enemy { } // Purpur end - Ridables + // Purpur start + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.phantomTakeDamageFromWater; + } + // Purpur end // Purpur start - Phantoms attracted to crystals and crystals shoot phantoms @Override protected void dropFromLootTable(ServerLevel world, DamageSource damageSource, boolean causedByPlayer) { diff --git a/net/minecraft/world/entity/monster/Pillager.java b/net/minecraft/world/entity/monster/Pillager.java index 78c01f0be0cc6689f68e2fcf3111d79abb5a59fb..0bc9ee0de4f30d4d57164e02992856a0bfa92041 100644 --- a/net/minecraft/world/entity/monster/Pillager.java +++ b/net/minecraft/world/entity/monster/Pillager.java @@ -91,6 +91,12 @@ public class Pillager extends AbstractIllager implements CrossbowAttackMob, Inve this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.pillagerScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.pillagerTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { super.registerGoals(); diff --git a/net/minecraft/world/entity/monster/Ravager.java b/net/minecraft/world/entity/monster/Ravager.java index b71aec7588a2a812cca71d89810ed765fcc33b9f..39081629685e3c7cd109626d1d61ce24b6afb860 100644 --- a/net/minecraft/world/entity/monster/Ravager.java +++ b/net/minecraft/world/entity/monster/Ravager.java @@ -105,6 +105,12 @@ public class Ravager extends Raider { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.ravagerScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.ravagerTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { super.registerGoals(); diff --git a/net/minecraft/world/entity/monster/Shulker.java b/net/minecraft/world/entity/monster/Shulker.java index c04d6a5190f3db06601c3a0ab0ddaede3a9f88ac..2b2e68e1449606ecfe5c414834ce3e2c6912d820 100644 --- a/net/minecraft/world/entity/monster/Shulker.java +++ b/net/minecraft/world/entity/monster/Shulker.java @@ -120,7 +120,12 @@ public class Shulker extends AbstractGolem implements VariantHolder type, ServerLevelAccessor world, EntitySpawnReason spawnReason, BlockPos pos, RandomSource random ) { diff --git a/net/minecraft/world/entity/monster/Strider.java b/net/minecraft/world/entity/monster/Strider.java index b5bc19ea93058374ce3a01ed650b0396b5e4176d..420118b1df271377f69e8e2bab8a62623382c819 100644 --- a/net/minecraft/world/entity/monster/Strider.java +++ b/net/minecraft/world/entity/monster/Strider.java @@ -91,7 +91,7 @@ public class Strider extends Animal implements ItemSteerable, Saddleable { super(type, world); this.steering = new ItemBasedSteering(this.entityData, Strider.DATA_BOOST_TIME, Strider.DATA_SADDLE_ID); this.blocksBuilding = true; - this.setPathfindingMalus(PathType.WATER, -1.0F); + if (isSensitiveToWater()) this.setPathfindingMalus(PathType.WATER, -1.0F); // Purpur - Toggle for water sensitive mob damage this.setPathfindingMalus(PathType.LAVA, 0.0F); this.setPathfindingMalus(PathType.DANGER_FIRE, 0.0F); this.setPathfindingMalus(PathType.DAMAGE_FIRE, 0.0F); @@ -443,7 +443,7 @@ public class Strider extends Animal implements ItemSteerable, Saddleable { @Override public boolean isSensitiveToWater() { - return true; + return this.level().purpurConfig.striderTakeDamageFromWater; // Purpur - Toggle for water sensitive mob damage } @Override diff --git a/net/minecraft/world/entity/monster/Vex.java b/net/minecraft/world/entity/monster/Vex.java index 906934076dd721a39f8ee960fc7c0d1058b66ae2..1630074bf8065a7ecf49d426f8d5fe5e109b1d2c 100644 --- a/net/minecraft/world/entity/monster/Vex.java +++ b/net/minecraft/world/entity/monster/Vex.java @@ -110,6 +110,12 @@ public class Vex extends Monster implements TraceableEntity { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.vexScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.vexTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override public boolean isFlapping() { return this.tickCount % Vex.TICKS_PER_FLAP == 0; diff --git a/net/minecraft/world/entity/monster/Vindicator.java b/net/minecraft/world/entity/monster/Vindicator.java index 7f414f74c315db67a8e8a3d3636811abe733f62a..5693081f061dcefbfda374c26a6ab5be0c2e2fcc 100644 --- a/net/minecraft/world/entity/monster/Vindicator.java +++ b/net/minecraft/world/entity/monster/Vindicator.java @@ -79,6 +79,12 @@ public class Vindicator extends AbstractIllager { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.vindicatorScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.vindicatorTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { super.registerGoals(); diff --git a/net/minecraft/world/entity/monster/Witch.java b/net/minecraft/world/entity/monster/Witch.java index 9b2d76722385ccf9d0ace747339ca7705ca41f4f..f77ce3de847ea5c7f40bfa6bd4bba254dc863bd0 100644 --- a/net/minecraft/world/entity/monster/Witch.java +++ b/net/minecraft/world/entity/monster/Witch.java @@ -81,6 +81,12 @@ public class Witch extends Raider implements RangedAttackMob { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.witchScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.witchTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { super.registerGoals(); diff --git a/net/minecraft/world/entity/monster/WitherSkeleton.java b/net/minecraft/world/entity/monster/WitherSkeleton.java index feb1b516c7ac7200e7cebeea739369426e87bf27..1a864ebb6257f34e8fb7a543d6da19cfa96bb7d0 100644 --- a/net/minecraft/world/entity/monster/WitherSkeleton.java +++ b/net/minecraft/world/entity/monster/WitherSkeleton.java @@ -60,6 +60,12 @@ public class WitherSkeleton extends AbstractSkeleton { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.witherSkeletonScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.witherSkeletonTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { this.targetSelector.addGoal(3, new NearestAttackableTargetGoal<>(this, AbstractPiglin.class, true)); diff --git a/net/minecraft/world/entity/monster/Zoglin.java b/net/minecraft/world/entity/monster/Zoglin.java index b5c4e127298795567ea4f35aa5a209ee6e1629b3..1c2c0f94811f934804cfb0be15fa55c0281ad0ba 100644 --- a/net/minecraft/world/entity/monster/Zoglin.java +++ b/net/minecraft/world/entity/monster/Zoglin.java @@ -109,6 +109,12 @@ public class Zoglin extends Monster implements HoglinBase { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.zoglinScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.zoglinTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected Brain.Provider brainProvider() { return Brain.provider(MEMORY_TYPES, SENSOR_TYPES); diff --git a/net/minecraft/world/entity/monster/Zombie.java b/net/minecraft/world/entity/monster/Zombie.java index 473ab54ac90f00bf5baf6b53190fa0f4f762700b..09b21cf02a07e1eb6a0aa2c6880d4106fe9e0d77 100644 --- a/net/minecraft/world/entity/monster/Zombie.java +++ b/net/minecraft/world/entity/monster/Zombie.java @@ -147,6 +147,12 @@ public class Zombie extends Monster { return level().purpurConfig.zombieJockeyTryExistingChickens; } // Purpur end - Configurable jockey options + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.zombieTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur - Ridables diff --git a/net/minecraft/world/entity/monster/ZombieVillager.java b/net/minecraft/world/entity/monster/ZombieVillager.java index 36a074627a95886d38bd5a262dddcebfe32d1ba6..3f3e0dd479afad1ca73ad9f76ed673fa399955c6 100644 --- a/net/minecraft/world/entity/monster/ZombieVillager.java +++ b/net/minecraft/world/entity/monster/ZombieVillager.java @@ -129,6 +129,12 @@ public class ZombieVillager extends Zombie implements VillagerDataHolder { return level().purpurConfig.zombieVillagerJockeyTryExistingChickens; } // Purpur end - Configurable jockey options + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.zombieVillagerTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void defineSynchedData(SynchedEntityData.Builder builder) { super.defineSynchedData(builder); diff --git a/net/minecraft/world/entity/monster/ZombifiedPiglin.java b/net/minecraft/world/entity/monster/ZombifiedPiglin.java index c4bf422557fe6abbe882f575f19a9334c7a94fe5..3070f4484276f8ea6b95134abda6409e58f1161a 100644 --- a/net/minecraft/world/entity/monster/ZombifiedPiglin.java +++ b/net/minecraft/world/entity/monster/ZombifiedPiglin.java @@ -103,6 +103,12 @@ public class ZombifiedPiglin extends Zombie implements NeutralMob { return level().purpurConfig.zombifiedPiglinJockeyTryExistingChickens; } // Purpur end - Configurable jockey options + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.zombifiedPiglinTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override public void setPersistentAngerTarget(@Nullable UUID angryAt) { this.persistentAngerTarget = angryAt; diff --git a/net/minecraft/world/entity/monster/hoglin/Hoglin.java b/net/minecraft/world/entity/monster/hoglin/Hoglin.java index d7bef344f1d18aa6037b3805da07353c54c82142..534626336e45da2c67cb023f4e5feea59daa8b5d 100644 --- a/net/minecraft/world/entity/monster/hoglin/Hoglin.java +++ b/net/minecraft/world/entity/monster/hoglin/Hoglin.java @@ -106,6 +106,12 @@ public class Hoglin extends Animal implements Enemy, HoglinBase { return this.level().purpurConfig.hoglinBreedingTicks; } // Purpur end - Make entity breeding times configurable + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.hoglinTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override public boolean canBeLeashed() { return true; diff --git a/net/minecraft/world/entity/monster/piglin/Piglin.java b/net/minecraft/world/entity/monster/piglin/Piglin.java index e1ae622ec56f1e011f8007c5b5b8a7032cd28102..f0b0642571a242f9c22febbafba587f1ca6caaaa 100644 --- a/net/minecraft/world/entity/monster/piglin/Piglin.java +++ b/net/minecraft/world/entity/monster/piglin/Piglin.java @@ -123,6 +123,12 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.piglinScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.piglinTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override public void addAdditionalSaveData(CompoundTag nbt) { super.addAdditionalSaveData(nbt); diff --git a/net/minecraft/world/entity/monster/piglin/PiglinBrute.java b/net/minecraft/world/entity/monster/piglin/PiglinBrute.java index a0fa32a1217bbdae2c91e5a51598d7bd555ca1eb..0e77e9e4a4fd14b5cecc377a03f0d6b2c9df039f 100644 --- a/net/minecraft/world/entity/monster/piglin/PiglinBrute.java +++ b/net/minecraft/world/entity/monster/piglin/PiglinBrute.java @@ -89,6 +89,12 @@ public class PiglinBrute extends AbstractPiglin { this.getAttribute(Attributes.SCALE).setBaseValue(this.level().purpurConfig.piglinBruteScale); } // Purpur end - Configurable entity base attributes + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.piglinBruteTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage public static AttributeSupplier.Builder createAttributes() { return Monster.createMonsterAttributes() .add(Attributes.MAX_HEALTH, 50.0) diff --git a/net/minecraft/world/entity/npc/Villager.java b/net/minecraft/world/entity/npc/Villager.java index 66a8beddde806e04ca4d0e943734d6116b107bcc..e33a29c486d50c5f22888bcb1979830143c8b06d 100644 --- a/net/minecraft/world/entity/npc/Villager.java +++ b/net/minecraft/world/entity/npc/Villager.java @@ -193,6 +193,12 @@ public class Villager extends AbstractVillager implements ReputationEventHandler return level().purpurConfig.villagerCanBeLeashed; } // Purpur end - Allow leashing villagers + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.villagerTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override public Brain getBrain() { return (Brain) super.getBrain(); // CraftBukkit - decompile error diff --git a/net/minecraft/world/entity/npc/WanderingTrader.java b/net/minecraft/world/entity/npc/WanderingTrader.java index 0066e413d1fa92ecd5573c00195aa2f1412e665e..455390bd5350282d1a6c9b25e9cdbd4a620b136c 100644 --- a/net/minecraft/world/entity/npc/WanderingTrader.java +++ b/net/minecraft/world/entity/npc/WanderingTrader.java @@ -107,6 +107,12 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill return level().purpurConfig.wanderingTraderCanBeLeashed; } // Purpur end - Allow leashing villagers + // Purpur start - Toggle for water sensitive mob damage + @Override + public boolean isSensitiveToWater() { + return this.level().purpurConfig.wanderingTraderTakeDamageFromWater; + } + // Purpur end - Toggle for water sensitive mob damage @Override protected void registerGoals() { this.goalSelector.addGoal(0, new FloatGoal(this)); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java index 126d2689166579785735cf250ddf0838512ce81b..9ab4dfe8cccbb8e4cc200930059acde1fb0341a6 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -549,12 +549,14 @@ public class PurpurWorldConfig { public double axolotlMaxHealth = 14.0D; public double axolotlScale = 1.0D; public int axolotlBreedingTicks = 6000; + public boolean axolotlTakeDamageFromWater = false; private void axolotlSettings() { axolotlRidable = getBoolean("mobs.axolotl.ridable", axolotlRidable); axolotlControllable = getBoolean("mobs.axolotl.controllable", axolotlControllable); axolotlMaxHealth = getDouble("mobs.axolotl.attributes.max_health", axolotlMaxHealth); axolotlScale = Mth.clamp(getDouble("mobs.axolotl.attributes.scale", axolotlScale), 0.0625D, 16.0D); axolotlBreedingTicks = getInt("mobs.axolotl.breeding-delay-ticks", axolotlBreedingTicks); + axolotlTakeDamageFromWater = getBoolean("mobs.axolotl.takes-damage-from-water", axolotlTakeDamageFromWater); } public boolean batRidable = false; @@ -570,6 +572,7 @@ public class PurpurWorldConfig { public double batArmor = 0.0D; public double batArmorToughness = 0.0D; public double batAttackKnockback = 0.0D; + public boolean batTakeDamageFromWater = false; private void batSettings() { batRidable = getBoolean("mobs.bat.ridable", batRidable); batRidableInWater = getBoolean("mobs.bat.ridable-in-water", batRidableInWater); @@ -589,6 +592,7 @@ public class PurpurWorldConfig { batArmor = getDouble("mobs.bat.attributes.armor", batArmor); batArmorToughness = getDouble("mobs.bat.attributes.armor_toughness", batArmorToughness); batAttackKnockback = getDouble("mobs.bat.attributes.attack_knockback", batAttackKnockback); + batTakeDamageFromWater = getBoolean("mobs.bat.takes-damage-from-water", batTakeDamageFromWater); } public boolean beeRidable = false; @@ -598,6 +602,7 @@ public class PurpurWorldConfig { public double beeMaxHealth = 10.0D; public double beeScale = 1.0D; public int beeBreedingTicks = 6000; + public boolean beeTakeDamageFromWater = true; private void beeSettings() { beeRidable = getBoolean("mobs.bee.ridable", beeRidable); beeRidableInWater = getBoolean("mobs.bee.ridable-in-water", beeRidableInWater); @@ -611,6 +616,7 @@ public class PurpurWorldConfig { beeMaxHealth = getDouble("mobs.bee.attributes.max_health", beeMaxHealth); beeScale = Mth.clamp(getDouble("mobs.bee.attributes.scale", beeScale), 0.0625D, 16.0D); beeBreedingTicks = getInt("mobs.bee.breeding-delay-ticks", beeBreedingTicks); + beeTakeDamageFromWater = getBoolean("mobs.bee.takes-damage-from-water", beeTakeDamageFromWater); } public boolean blazeRidable = false; @@ -619,6 +625,7 @@ public class PurpurWorldConfig { public double blazeMaxY = 320D; public double blazeMaxHealth = 20.0D; public double blazeScale = 1.0D; + public boolean blazeTakeDamageFromWater = true; private void blazeSettings() { blazeRidable = getBoolean("mobs.blaze.ridable", blazeRidable); blazeRidableInWater = getBoolean("mobs.blaze.ridable-in-water", blazeRidableInWater); @@ -631,6 +638,7 @@ public class PurpurWorldConfig { } blazeMaxHealth = getDouble("mobs.blaze.attributes.max_health", blazeMaxHealth); blazeScale = Mth.clamp(getDouble("mobs.blaze.attributes.scale", blazeScale), 0.0625D, 16.0D); + blazeTakeDamageFromWater = getBoolean("mobs.blaze.takes-damage-from-water", blazeTakeDamageFromWater); } public boolean boggedRidable = false; @@ -675,6 +683,7 @@ public class PurpurWorldConfig { public int catSpawnVillageScanRange = 48; public int catBreedingTicks = 6000; public DyeColor catDefaultCollarColor = DyeColor.RED; + public boolean catTakeDamageFromWater = false; private void catSettings() { catRidable = getBoolean("mobs.cat.ridable", catRidable); catRidableInWater = getBoolean("mobs.cat.ridable-in-water", catRidableInWater); @@ -695,6 +704,7 @@ public class PurpurWorldConfig { } catch (IllegalArgumentException ignore) { catDefaultCollarColor = DyeColor.RED; } + catTakeDamageFromWater = getBoolean("mobs.cat.takes-damage-from-water", catTakeDamageFromWater); } public boolean caveSpiderRidable = false; @@ -702,6 +712,7 @@ public class PurpurWorldConfig { public boolean caveSpiderControllable = true; public double caveSpiderMaxHealth = 12.0D; public double caveSpiderScale = 1.0D; + public boolean caveSpiderTakeDamageFromWater = false; private void caveSpiderSettings() { caveSpiderRidable = getBoolean("mobs.cave_spider.ridable", caveSpiderRidable); caveSpiderRidableInWater = getBoolean("mobs.cave_spider.ridable-in-water", caveSpiderRidableInWater); @@ -713,6 +724,7 @@ public class PurpurWorldConfig { } caveSpiderMaxHealth = getDouble("mobs.cave_spider.attributes.max_health", caveSpiderMaxHealth); caveSpiderScale = Mth.clamp(getDouble("mobs.cave_spider.attributes.scale", caveSpiderScale), 0.0625D, 16.0D); + caveSpiderTakeDamageFromWater = getBoolean("mobs.cave_spider.takes-damage-from-water", caveSpiderTakeDamageFromWater); } public boolean chickenRidable = false; @@ -722,6 +734,7 @@ public class PurpurWorldConfig { public double chickenScale = 1.0D; public boolean chickenRetaliate = false; public int chickenBreedingTicks = 6000; + public boolean chickenTakeDamageFromWater = false; private void chickenSettings() { chickenRidable = getBoolean("mobs.chicken.ridable", chickenRidable); chickenRidableInWater = getBoolean("mobs.chicken.ridable-in-water", chickenRidableInWater); @@ -735,12 +748,14 @@ public class PurpurWorldConfig { chickenScale = Mth.clamp(getDouble("mobs.chicken.attributes.scale", chickenScale), 0.0625D, 16.0D); chickenRetaliate = getBoolean("mobs.chicken.retaliate", chickenRetaliate); chickenBreedingTicks = getInt("mobs.chicken.breeding-delay-ticks", chickenBreedingTicks); + chickenTakeDamageFromWater = getBoolean("mobs.chicken.takes-damage-from-water", chickenTakeDamageFromWater); } public boolean codRidable = false; public boolean codControllable = true; public double codMaxHealth = 3.0D; public double codScale = 1.0D; + public boolean codTakeDamageFromWater = false; private void codSettings() { codRidable = getBoolean("mobs.cod.ridable", codRidable); codControllable = getBoolean("mobs.cod.controllable", codControllable); @@ -751,6 +766,7 @@ public class PurpurWorldConfig { } codMaxHealth = getDouble("mobs.cod.attributes.max_health", codMaxHealth); codScale = Mth.clamp(getDouble("mobs.cod.attributes.scale", codScale), 0.0625D, 16.0D); + codTakeDamageFromWater = getBoolean("mobs.cod.takes-damage-from-water", codTakeDamageFromWater); } public boolean cowRidable = false; @@ -760,6 +776,7 @@ public class PurpurWorldConfig { public double cowScale = 1.0D; public int cowFeedMushrooms = 0; public int cowBreedingTicks = 6000; + public boolean cowTakeDamageFromWater = false; private void cowSettings() { cowRidable = getBoolean("mobs.cow.ridable", cowRidable); cowRidableInWater = getBoolean("mobs.cow.ridable-in-water", cowRidableInWater); @@ -773,6 +790,7 @@ public class PurpurWorldConfig { cowScale = Mth.clamp(getDouble("mobs.cow.attributes.scale", cowScale), 0.0625D, 16.0D); cowFeedMushrooms = getInt("mobs.cow.feed-mushrooms-for-mooshroom", cowFeedMushrooms); cowBreedingTicks = getInt("mobs.cow.breeding-delay-ticks", cowBreedingTicks); + cowTakeDamageFromWater = getBoolean("mobs.cow.takes-damage-from-water", cowTakeDamageFromWater); } public boolean creakingRidable = false; @@ -796,6 +814,7 @@ public class PurpurWorldConfig { public double creeperChargedChance = 0.0D; public boolean creeperAllowGriefing = true; public boolean creeperBypassMobGriefing = false; + public boolean creeperTakeDamageFromWater = false; private void creeperSettings() { creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable); creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater); @@ -810,6 +829,7 @@ public class PurpurWorldConfig { creeperChargedChance = getDouble("mobs.creeper.naturally-charged-chance", creeperChargedChance); creeperAllowGriefing = getBoolean("mobs.creeper.allow-griefing", creeperAllowGriefing); creeperBypassMobGriefing = getBoolean("mobs.creeper.bypass-mob-griefing", creeperBypassMobGriefing); + creeperTakeDamageFromWater = getBoolean("mobs.creeper.takes-damage-from-water", creeperTakeDamageFromWater); } public boolean dolphinRidable = false; @@ -820,6 +840,7 @@ public class PurpurWorldConfig { public double dolphinMaxHealth = 10.0D; public double dolphinScale = 1.0D; public boolean dolphinDisableTreasureSearching = false; + public boolean dolphinTakeDamageFromWater = false; private void dolphinSettings() { dolphinRidable = getBoolean("mobs.dolphin.ridable", dolphinRidable); dolphinControllable = getBoolean("mobs.dolphin.controllable", dolphinControllable); @@ -834,6 +855,7 @@ public class PurpurWorldConfig { dolphinMaxHealth = getDouble("mobs.dolphin.attributes.max_health", dolphinMaxHealth); dolphinScale = Mth.clamp(getDouble("mobs.dolphin.attributes.scale", dolphinScale), 0.0625D, 16.0D); dolphinDisableTreasureSearching = getBoolean("mobs.dolphin.disable-treasure-searching", dolphinDisableTreasureSearching); + dolphinTakeDamageFromWater = getBoolean("mobs.dolphin.takes-damage-from-water", dolphinTakeDamageFromWater); } public boolean donkeyRidableInWater = false; @@ -844,6 +866,7 @@ public class PurpurWorldConfig { public double donkeyMovementSpeedMin = 0.175D; public double donkeyMovementSpeedMax = 0.175D; public int donkeyBreedingTicks = 6000; + public boolean donkeyTakeDamageFromWater = false; private void donkeySettings() { donkeyRidableInWater = getBoolean("mobs.donkey.ridable-in-water", donkeyRidableInWater); if (PurpurConfig.version < 10) { @@ -860,6 +883,7 @@ public class PurpurWorldConfig { donkeyMovementSpeedMin = getDouble("mobs.donkey.attributes.movement_speed.min", donkeyMovementSpeedMin); donkeyMovementSpeedMax = getDouble("mobs.donkey.attributes.movement_speed.max", donkeyMovementSpeedMax); donkeyBreedingTicks = getInt("mobs.donkey.breeding-delay-ticks", donkeyBreedingTicks); + donkeyTakeDamageFromWater = getBoolean("mobs.donkey.takes-damage-from-water", donkeyTakeDamageFromWater); } public boolean drownedRidable = false; @@ -871,6 +895,7 @@ public class PurpurWorldConfig { public boolean drownedJockeyOnlyBaby = true; public double drownedJockeyChance = 0.05D; public boolean drownedJockeyTryExistingChickens = true; + public boolean drownedTakeDamageFromWater = false; private void drownedSettings() { drownedRidable = getBoolean("mobs.drowned.ridable", drownedRidable); drownedRidableInWater = getBoolean("mobs.drowned.ridable-in-water", drownedRidableInWater); @@ -886,12 +911,14 @@ public class PurpurWorldConfig { drownedJockeyOnlyBaby = getBoolean("mobs.drowned.jockey.only-babies", drownedJockeyOnlyBaby); drownedJockeyChance = getDouble("mobs.drowned.jockey.chance", drownedJockeyChance); drownedJockeyTryExistingChickens = getBoolean("mobs.drowned.jockey.try-existing-chickens", drownedJockeyTryExistingChickens); + drownedTakeDamageFromWater = getBoolean("mobs.drowned.takes-damage-from-water", drownedTakeDamageFromWater); } public boolean elderGuardianRidable = false; public boolean elderGuardianControllable = true; public double elderGuardianMaxHealth = 80.0D; public double elderGuardianScale = 1.0D; + public boolean elderGuardianTakeDamageFromWater = false; private void elderGuardianSettings() { elderGuardianRidable = getBoolean("mobs.elder_guardian.ridable", elderGuardianRidable); elderGuardianControllable = getBoolean("mobs.elder_guardian.controllable", elderGuardianControllable); @@ -902,6 +929,7 @@ public class PurpurWorldConfig { } elderGuardianMaxHealth = getDouble("mobs.elder_guardian.attributes.max_health", elderGuardianMaxHealth); elderGuardianScale = Mth.clamp(getDouble("mobs.elder_guardian.attributes.scale", elderGuardianScale), 0.0625D, 16.0D); + elderGuardianTakeDamageFromWater = getBoolean("mobs.elder_guardian.takes-damage-from-water", elderGuardianTakeDamageFromWater); } public boolean enderDragonRidable = false; @@ -911,6 +939,7 @@ public class PurpurWorldConfig { public double enderDragonMaxHealth = 200.0D; public boolean enderDragonAlwaysDropsFullExp = false; public boolean enderDragonBypassMobGriefing = false; + public boolean enderDragonTakeDamageFromWater = false; private void enderDragonSettings() { enderDragonRidable = getBoolean("mobs.ender_dragon.ridable", enderDragonRidable); enderDragonRidableInWater = getBoolean("mobs.ender_dragon.ridable-in-water", enderDragonRidableInWater); @@ -928,6 +957,7 @@ public class PurpurWorldConfig { enderDragonMaxHealth = getDouble("mobs.ender_dragon.attributes.max_health", enderDragonMaxHealth); enderDragonAlwaysDropsFullExp = getBoolean("mobs.ender_dragon.always-drop-full-exp", enderDragonAlwaysDropsFullExp); enderDragonBypassMobGriefing = getBoolean("mobs.ender_dragon.bypass-mob-griefing", enderDragonBypassMobGriefing); + enderDragonTakeDamageFromWater = getBoolean("mobs.ender_dragon.takes-damage-from-water", enderDragonTakeDamageFromWater); } public boolean endermanRidable = false; @@ -938,6 +968,7 @@ public class PurpurWorldConfig { public boolean endermanAllowGriefing = true; public boolean endermanDespawnEvenWithBlock = false; public boolean endermanBypassMobGriefing = false; + public boolean endermanTakeDamageFromWater = true; private void endermanSettings() { endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable); endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater); @@ -952,6 +983,7 @@ public class PurpurWorldConfig { endermanAllowGriefing = getBoolean("mobs.enderman.allow-griefing", endermanAllowGriefing); endermanDespawnEvenWithBlock = getBoolean("mobs.enderman.can-despawn-with-held-block", endermanDespawnEvenWithBlock); endermanBypassMobGriefing = getBoolean("mobs.enderman.bypass-mob-griefing", endermanBypassMobGriefing); + endermanTakeDamageFromWater = getBoolean("mobs.enderman.takes-damage-from-water", endermanTakeDamageFromWater); } public boolean endermiteRidable = false; @@ -959,6 +991,7 @@ public class PurpurWorldConfig { public boolean endermiteControllable = true; public double endermiteMaxHealth = 8.0D; public double endermiteScale = 1.0D; + public boolean endermiteTakeDamageFromWater = false; private void endermiteSettings() { endermiteRidable = getBoolean("mobs.endermite.ridable", endermiteRidable); endermiteRidableInWater = getBoolean("mobs.endermite.ridable-in-water", endermiteRidableInWater); @@ -970,6 +1003,7 @@ public class PurpurWorldConfig { } endermiteMaxHealth = getDouble("mobs.endermite.attributes.max_health", endermiteMaxHealth); endermiteScale = Mth.clamp(getDouble("mobs.endermite.attributes.scale", endermiteScale), 0.0625D, 16.0D); + endermiteTakeDamageFromWater = getBoolean("mobs.endermite.takes-damage-from-water", endermiteTakeDamageFromWater); } public boolean evokerRidable = false; @@ -978,6 +1012,7 @@ public class PurpurWorldConfig { public double evokerMaxHealth = 24.0D; public double evokerScale = 1.0D; public boolean evokerBypassMobGriefing = false; + public boolean evokerTakeDamageFromWater = false; private void evokerSettings() { evokerRidable = getBoolean("mobs.evoker.ridable", evokerRidable); evokerRidableInWater = getBoolean("mobs.evoker.ridable-in-water", evokerRidableInWater); @@ -990,6 +1025,7 @@ public class PurpurWorldConfig { evokerMaxHealth = getDouble("mobs.evoker.attributes.max_health", evokerMaxHealth); evokerScale = Mth.clamp(getDouble("mobs.evoker.attributes.scale", evokerScale), 0.0625D, 16.0D); evokerBypassMobGriefing = getBoolean("mobs.evoker.bypass-mob-griefing", evokerBypassMobGriefing); + evokerTakeDamageFromWater = getBoolean("mobs.evoker.takes-damage-from-water", evokerTakeDamageFromWater); } public boolean foxRidable = false; @@ -1000,6 +1036,7 @@ public class PurpurWorldConfig { public boolean foxTypeChangesWithTulips = false; public int foxBreedingTicks = 6000; public boolean foxBypassMobGriefing = false; + public boolean foxTakeDamageFromWater = false; private void foxSettings() { foxRidable = getBoolean("mobs.fox.ridable", foxRidable); foxRidableInWater = getBoolean("mobs.fox.ridable-in-water", foxRidableInWater); @@ -1014,6 +1051,7 @@ public class PurpurWorldConfig { foxTypeChangesWithTulips = getBoolean("mobs.fox.tulips-change-type", foxTypeChangesWithTulips); foxBreedingTicks = getInt("mobs.fox.breeding-delay-ticks", foxBreedingTicks); foxBypassMobGriefing = getBoolean("mobs.fox.bypass-mob-griefing", foxBypassMobGriefing); + foxTakeDamageFromWater = getBoolean("mobs.fox.takes-damage-from-water", foxTakeDamageFromWater); } public boolean frogRidable = false; @@ -1035,6 +1073,7 @@ public class PurpurWorldConfig { public double ghastMaxY = 320D; public double ghastMaxHealth = 10.0D; public double ghastScale = 1.0D; + public boolean ghastTakeDamageFromWater = false; private void ghastSettings() { ghastRidable = getBoolean("mobs.ghast.ridable", ghastRidable); ghastRidableInWater = getBoolean("mobs.ghast.ridable-in-water", ghastRidableInWater); @@ -1047,6 +1086,7 @@ public class PurpurWorldConfig { } ghastMaxHealth = getDouble("mobs.ghast.attributes.max_health", ghastMaxHealth); ghastScale = Mth.clamp(getDouble("mobs.ghast.attributes.scale", ghastScale), 0.0625D, 16.0D); + ghastTakeDamageFromWater = getBoolean("mobs.ghast.takes-damage-from-water", ghastTakeDamageFromWater); } public boolean giantRidable = false; @@ -1060,6 +1100,7 @@ public class PurpurWorldConfig { public float giantJumpHeight = 1.0F; public boolean giantHaveAI = false; public boolean giantHaveHostileAI = false; + public boolean giantTakeDamageFromWater = false; private void giantSettings() { giantRidable = getBoolean("mobs.giant.ridable", giantRidable); giantRidableInWater = getBoolean("mobs.giant.ridable-in-water", giantRidableInWater); @@ -1081,6 +1122,7 @@ public class PurpurWorldConfig { giantJumpHeight = (float) getDouble("mobs.giant.jump-height", giantJumpHeight); giantHaveAI = getBoolean("mobs.giant.have-ai", giantHaveAI); giantHaveHostileAI = getBoolean("mobs.giant.have-hostile-ai", giantHaveHostileAI); + giantTakeDamageFromWater = getBoolean("mobs.giant.takes-damage-from-water", giantTakeDamageFromWater); } public boolean glowSquidRidable = false; @@ -1088,12 +1130,14 @@ public class PurpurWorldConfig { public double glowSquidMaxHealth = 10.0D; public double glowSquidScale = 1.0D; public boolean glowSquidsCanFly = false; + public boolean glowSquidTakeDamageFromWater = false; private void glowSquidSettings() { glowSquidRidable = getBoolean("mobs.glow_squid.ridable", glowSquidRidable); glowSquidControllable = getBoolean("mobs.glow_squid.controllable", glowSquidControllable); glowSquidMaxHealth = getDouble("mobs.glow_squid.attributes.max_health", glowSquidMaxHealth); glowSquidScale = Mth.clamp(getDouble("mobs.glow_squid.attributes.scale", glowSquidScale), 0.0625D, 16.0D); glowSquidsCanFly = getBoolean("mobs.glow_squid.can-fly", glowSquidsCanFly); + glowSquidTakeDamageFromWater = getBoolean("mobs.glow_squid.takes-damage-from-water", glowSquidTakeDamageFromWater); } public boolean goatRidable = false; @@ -1102,6 +1146,7 @@ public class PurpurWorldConfig { public double goatMaxHealth = 10.0D; public double goatScale = 1.0D; public int goatBreedingTicks = 6000; + public boolean goatTakeDamageFromWater = false; private void goatSettings() { goatRidable = getBoolean("mobs.goat.ridable", goatRidable); goatRidableInWater = getBoolean("mobs.goat.ridable-in-water", goatRidableInWater); @@ -1109,12 +1154,14 @@ public class PurpurWorldConfig { goatMaxHealth = getDouble("mobs.goat.attributes.max_health", goatMaxHealth); goatScale = Mth.clamp(getDouble("mobs.goat.attributes.scale", goatScale), 0.0625D, 16.0D); goatBreedingTicks = getInt("mobs.goat.breeding-delay-ticks", goatBreedingTicks); + goatTakeDamageFromWater = getBoolean("mobs.goat.takes-damage-from-water", goatTakeDamageFromWater); } public boolean guardianRidable = false; public boolean guardianControllable = true; public double guardianMaxHealth = 30.0D; public double guardianScale = 1.0D; + public boolean guardianTakeDamageFromWater = false; private void guardianSettings() { guardianRidable = getBoolean("mobs.guardian.ridable", guardianRidable); guardianControllable = getBoolean("mobs.guardian.controllable", guardianControllable); @@ -1125,6 +1172,7 @@ public class PurpurWorldConfig { } guardianMaxHealth = getDouble("mobs.guardian.attributes.max_health", guardianMaxHealth); guardianScale = Mth.clamp(getDouble("mobs.guardian.attributes.scale", guardianScale), 0.0625D, 16.0D); + guardianTakeDamageFromWater = getBoolean("mobs.guardian.takes-damage-from-water", guardianTakeDamageFromWater); } public boolean hoglinRidable = false; @@ -1133,6 +1181,7 @@ public class PurpurWorldConfig { public double hoglinMaxHealth = 40.0D; public double hoglinScale = 1.0D; public int hoglinBreedingTicks = 6000; + public boolean hoglinTakeDamageFromWater = false; private void hoglinSettings() { hoglinRidable = getBoolean("mobs.hoglin.ridable", hoglinRidable); hoglinRidableInWater = getBoolean("mobs.hoglin.ridable-in-water", hoglinRidableInWater); @@ -1145,6 +1194,7 @@ public class PurpurWorldConfig { hoglinMaxHealth = getDouble("mobs.hoglin.attributes.max_health", hoglinMaxHealth); hoglinScale = Mth.clamp(getDouble("mobs.hoglin.attributes.scale", hoglinScale), 0.0625D, 16.0D); hoglinBreedingTicks = getInt("mobs.hoglin.breeding-delay-ticks", hoglinBreedingTicks); + hoglinTakeDamageFromWater = getBoolean("mobs.hoglin.takes-damage-from-water", hoglinTakeDamageFromWater); } public boolean horseRidableInWater = false; @@ -1155,6 +1205,7 @@ public class PurpurWorldConfig { public double horseMovementSpeedMin = 0.1125D; public double horseMovementSpeedMax = 0.3375D; public int horseBreedingTicks = 6000; + public boolean horseTakeDamageFromWater = false; private void horseSettings() { horseRidableInWater = getBoolean("mobs.horse.ridable-in-water", horseRidableInWater); if (PurpurConfig.version < 10) { @@ -1171,6 +1222,7 @@ public class PurpurWorldConfig { horseMovementSpeedMin = getDouble("mobs.horse.attributes.movement_speed.min", horseMovementSpeedMin); horseMovementSpeedMax = getDouble("mobs.horse.attributes.movement_speed.max", horseMovementSpeedMax); horseBreedingTicks = getInt("mobs.horse.breeding-delay-ticks", horseBreedingTicks); + horseTakeDamageFromWater = getBoolean("mobs.horse.takes-damage-from-water", horseTakeDamageFromWater); } public boolean huskRidable = false; @@ -1182,6 +1234,7 @@ public class PurpurWorldConfig { public boolean huskJockeyOnlyBaby = true; public double huskJockeyChance = 0.05D; public boolean huskJockeyTryExistingChickens = true; + public boolean huskTakeDamageFromWater = false; private void huskSettings() { huskRidable = getBoolean("mobs.husk.ridable", huskRidable); huskRidableInWater = getBoolean("mobs.husk.ridable-in-water", huskRidableInWater); @@ -1197,6 +1250,7 @@ public class PurpurWorldConfig { huskJockeyOnlyBaby = getBoolean("mobs.husk.jockey.only-babies", huskJockeyOnlyBaby); huskJockeyChance = getDouble("mobs.husk.jockey.chance", huskJockeyChance); huskJockeyTryExistingChickens = getBoolean("mobs.husk.jockey.try-existing-chickens", huskJockeyTryExistingChickens); + huskTakeDamageFromWater = getBoolean("mobs.husk.takes-damage-from-water", huskTakeDamageFromWater); } public boolean illusionerRidable = false; @@ -1206,6 +1260,7 @@ public class PurpurWorldConfig { public double illusionerFollowRange = 18.0D; public double illusionerMaxHealth = 32.0D; public double illusionerScale = 1.0D; + public boolean illusionerTakeDamageFromWater = false; private void illusionerSettings() { illusionerRidable = getBoolean("mobs.illusioner.ridable", illusionerRidable); illusionerRidableInWater = getBoolean("mobs.illusioner.ridable-in-water", illusionerRidableInWater); @@ -1223,6 +1278,7 @@ public class PurpurWorldConfig { } illusionerMaxHealth = getDouble("mobs.illusioner.attributes.max_health", illusionerMaxHealth); illusionerScale = Mth.clamp(getDouble("mobs.illusioner.attributes.scale", illusionerScale), 0.0625D, 16.0D); + illusionerTakeDamageFromWater = getBoolean("mobs.illusioner.takes-damage-from-water", illusionerTakeDamageFromWater); } public boolean ironGolemRidable = false; @@ -1231,6 +1287,7 @@ public class PurpurWorldConfig { public boolean ironGolemCanSwim = false; public double ironGolemMaxHealth = 100.0D; public double ironGolemScale = 1.0D; + public boolean ironGolemTakeDamageFromWater = false; private void ironGolemSettings() { ironGolemRidable = getBoolean("mobs.iron_golem.ridable", ironGolemRidable); ironGolemRidableInWater = getBoolean("mobs.iron_golem.ridable-in-water", ironGolemRidableInWater); @@ -1243,6 +1300,7 @@ public class PurpurWorldConfig { } ironGolemMaxHealth = getDouble("mobs.iron_golem.attributes.max_health", ironGolemMaxHealth); ironGolemScale = Mth.clamp(getDouble("mobs.iron_golem.attributes.scale", ironGolemScale), 0.0625D, 16.0D); + ironGolemTakeDamageFromWater = getBoolean("mobs.iron_golem.takes-damage-from-water", ironGolemTakeDamageFromWater); } public boolean llamaRidable = false; @@ -1255,6 +1313,7 @@ public class PurpurWorldConfig { public double llamaMovementSpeedMin = 0.175D; public double llamaMovementSpeedMax = 0.175D; public int llamaBreedingTicks = 6000; + public boolean llamaTakeDamageFromWater = false; private void llamaSettings() { llamaRidable = getBoolean("mobs.llama.ridable", llamaRidable); llamaRidableInWater = getBoolean("mobs.llama.ridable-in-water", llamaRidableInWater); @@ -1273,6 +1332,7 @@ public class PurpurWorldConfig { llamaMovementSpeedMin = getDouble("mobs.llama.attributes.movement_speed.min", llamaMovementSpeedMin); llamaMovementSpeedMax = getDouble("mobs.llama.attributes.movement_speed.max", llamaMovementSpeedMax); llamaBreedingTicks = getInt("mobs.llama.breeding-delay-ticks", llamaBreedingTicks); + llamaTakeDamageFromWater = getBoolean("mobs.llama.takes-damage-from-water", llamaTakeDamageFromWater); } public boolean magmaCubeRidable = false; @@ -1282,6 +1342,7 @@ public class PurpurWorldConfig { public String magmaCubeAttackDamage = "size"; public Map magmaCubeMaxHealthCache = new HashMap<>(); public Map magmaCubeAttackDamageCache = new HashMap<>(); + public boolean magmaCubeTakeDamageFromWater = false; private void magmaCubeSettings() { magmaCubeRidable = getBoolean("mobs.magma_cube.ridable", magmaCubeRidable); magmaCubeRidableInWater = getBoolean("mobs.magma_cube.ridable-in-water", magmaCubeRidableInWater); @@ -1295,6 +1356,7 @@ public class PurpurWorldConfig { magmaCubeAttackDamage = getString("mobs.magma_cube.attributes.attack_damage", magmaCubeAttackDamage); magmaCubeMaxHealthCache.clear(); magmaCubeAttackDamageCache.clear(); + magmaCubeTakeDamageFromWater = getBoolean("mobs.magma_cube.takes-damage-from-water", magmaCubeTakeDamageFromWater); } public boolean mooshroomRidable = false; @@ -1303,6 +1365,7 @@ public class PurpurWorldConfig { public double mooshroomMaxHealth = 10.0D; public double mooshroomScale = 1.0D; public int mooshroomBreedingTicks = 6000; + public boolean mooshroomTakeDamageFromWater = false; private void mooshroomSettings() { mooshroomRidable = getBoolean("mobs.mooshroom.ridable", mooshroomRidable); mooshroomRidableInWater = getBoolean("mobs.mooshroom.ridable-in-water", mooshroomRidableInWater); @@ -1315,6 +1378,7 @@ public class PurpurWorldConfig { mooshroomMaxHealth = getDouble("mobs.mooshroom.attributes.max_health", mooshroomMaxHealth); mooshroomScale = Mth.clamp(getDouble("mobs.mooshroom.attributes.scale", mooshroomScale), 0.0625D, 16.0D); mooshroomBreedingTicks = getInt("mobs.mooshroom.breeding-delay-ticks", mooshroomBreedingTicks); + mooshroomTakeDamageFromWater = getBoolean("mobs.mooshroom.takes-damage-from-water", mooshroomTakeDamageFromWater); } public boolean muleRidableInWater = false; @@ -1325,6 +1389,7 @@ public class PurpurWorldConfig { public double muleMovementSpeedMin = 0.175D; public double muleMovementSpeedMax = 0.175D; public int muleBreedingTicks = 6000; + public boolean muleTakeDamageFromWater = false; private void muleSettings() { muleRidableInWater = getBoolean("mobs.mule.ridable-in-water", muleRidableInWater); if (PurpurConfig.version < 10) { @@ -1341,6 +1406,7 @@ public class PurpurWorldConfig { muleMovementSpeedMin = getDouble("mobs.mule.attributes.movement_speed.min", muleMovementSpeedMin); muleMovementSpeedMax = getDouble("mobs.mule.attributes.movement_speed.max", muleMovementSpeedMax); muleBreedingTicks = getInt("mobs.mule.breeding-delay-ticks", muleBreedingTicks); + muleTakeDamageFromWater = getBoolean("mobs.mule.takes-damage-from-water", muleTakeDamageFromWater); } public boolean ocelotRidable = false; @@ -1349,6 +1415,7 @@ public class PurpurWorldConfig { public double ocelotMaxHealth = 10.0D; public double ocelotScale = 1.0D; public int ocelotBreedingTicks = 6000; + public boolean ocelotTakeDamageFromWater = false; private void ocelotSettings() { ocelotRidable = getBoolean("mobs.ocelot.ridable", ocelotRidable); ocelotRidableInWater = getBoolean("mobs.ocelot.ridable-in-water", ocelotRidableInWater); @@ -1361,6 +1428,7 @@ public class PurpurWorldConfig { ocelotMaxHealth = getDouble("mobs.ocelot.attributes.max_health", ocelotMaxHealth); ocelotScale = Mth.clamp(getDouble("mobs.ocelot.attributes.scale", ocelotScale), 0.0625D, 16.0D); ocelotBreedingTicks = getInt("mobs.ocelot.breeding-delay-ticks", ocelotBreedingTicks); + ocelotTakeDamageFromWater = getBoolean("mobs.ocelot.takes-damage-from-water", ocelotTakeDamageFromWater); } public boolean pandaRidable = false; @@ -1369,6 +1437,7 @@ public class PurpurWorldConfig { public double pandaMaxHealth = 20.0D; public double pandaScale = 1.0D; public int pandaBreedingTicks = 6000; + public boolean pandaTakeDamageFromWater = false; private void pandaSettings() { pandaRidable = getBoolean("mobs.panda.ridable", pandaRidable); pandaRidableInWater = getBoolean("mobs.panda.ridable-in-water", pandaRidableInWater); @@ -1381,6 +1450,7 @@ public class PurpurWorldConfig { pandaMaxHealth = getDouble("mobs.panda.attributes.max_health", pandaMaxHealth); pandaScale = Mth.clamp(getDouble("mobs.panda.attributes.scale", pandaScale), 0.0625D, 16.0D); pandaBreedingTicks = getInt("mobs.panda.breeding-delay-ticks", pandaBreedingTicks); + pandaTakeDamageFromWater = getBoolean("mobs.panda.takes-damage-from-water", pandaTakeDamageFromWater); } public boolean parrotRidable = false; @@ -1389,6 +1459,7 @@ public class PurpurWorldConfig { public double parrotMaxY = 320D; public double parrotMaxHealth = 6.0D; public double parrotScale = 1.0D; + public boolean parrotTakeDamageFromWater = false; private void parrotSettings() { parrotRidable = getBoolean("mobs.parrot.ridable", parrotRidable); parrotRidableInWater = getBoolean("mobs.parrot.ridable-in-water", parrotRidableInWater); @@ -1401,6 +1472,7 @@ public class PurpurWorldConfig { } parrotMaxHealth = getDouble("mobs.parrot.attributes.max_health", parrotMaxHealth); parrotScale = Mth.clamp(getDouble("mobs.parrot.attributes.scale", parrotScale), 0.0625D, 16.0D); + parrotTakeDamageFromWater = getBoolean("mobs.parrot.takes-damage-from-water", parrotTakeDamageFromWater); } public boolean phantomRidable = false; @@ -1427,6 +1499,7 @@ public class PurpurWorldConfig { public boolean phantomIgnorePlayersWithTorch = false; public boolean phantomBurnInDaylight = true; public boolean phantomFlamesOnSwoop = false; + public boolean phantomTakeDamageFromWater = false; private void phantomSettings() { phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable); phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater); @@ -1461,6 +1534,7 @@ public class PurpurWorldConfig { phantomBurnInDaylight = getBoolean("mobs.phantom.burn-in-daylight", phantomBurnInDaylight); phantomIgnorePlayersWithTorch = getBoolean("mobs.phantom.ignore-players-with-torch", phantomIgnorePlayersWithTorch); phantomFlamesOnSwoop = getBoolean("mobs.phantom.flames-on-swoop", phantomFlamesOnSwoop); + phantomTakeDamageFromWater = getBoolean("mobs.phantom.takes-damage-from-water", phantomTakeDamageFromWater); } public boolean pigRidable = false; @@ -1470,6 +1544,7 @@ public class PurpurWorldConfig { public double pigScale = 1.0D; public boolean pigGiveSaddleBack = false; public int pigBreedingTicks = 6000; + public boolean pigTakeDamageFromWater = false; private void pigSettings() { pigRidable = getBoolean("mobs.pig.ridable", pigRidable); pigRidableInWater = getBoolean("mobs.pig.ridable-in-water", pigRidableInWater); @@ -1483,6 +1558,7 @@ public class PurpurWorldConfig { pigScale = Mth.clamp(getDouble("mobs.pig.attributes.scale", pigScale), 0.0625D, 16.0D); pigGiveSaddleBack = getBoolean("mobs.pig.give-saddle-back", pigGiveSaddleBack); pigBreedingTicks = getInt("mobs.pig.breeding-delay-ticks", pigBreedingTicks); + pigTakeDamageFromWater = getBoolean("mobs.pig.takes-damage-from-water", pigTakeDamageFromWater); } public boolean piglinRidable = false; @@ -1491,6 +1567,7 @@ public class PurpurWorldConfig { public double piglinMaxHealth = 16.0D; public double piglinScale = 1.0D; public boolean piglinBypassMobGriefing = false; + public boolean piglinTakeDamageFromWater = false; private void piglinSettings() { piglinRidable = getBoolean("mobs.piglin.ridable", piglinRidable); piglinRidableInWater = getBoolean("mobs.piglin.ridable-in-water", piglinRidableInWater); @@ -1503,6 +1580,7 @@ public class PurpurWorldConfig { piglinMaxHealth = getDouble("mobs.piglin.attributes.max_health", piglinMaxHealth); piglinScale = Mth.clamp(getDouble("mobs.piglin.attributes.scale", piglinScale), 0.0625D, 16.0D); piglinBypassMobGriefing = getBoolean("mobs.piglin.bypass-mob-griefing", piglinBypassMobGriefing); + piglinTakeDamageFromWater = getBoolean("mobs.piglin.takes-damage-from-water", piglinTakeDamageFromWater); } public boolean piglinBruteRidable = false; @@ -1510,6 +1588,7 @@ public class PurpurWorldConfig { public boolean piglinBruteControllable = true; public double piglinBruteMaxHealth = 50.0D; public double piglinBruteScale = 1.0D; + public boolean piglinBruteTakeDamageFromWater = false; private void piglinBruteSettings() { piglinBruteRidable = getBoolean("mobs.piglin_brute.ridable", piglinBruteRidable); piglinBruteRidableInWater = getBoolean("mobs.piglin_brute.ridable-in-water", piglinBruteRidableInWater); @@ -1521,6 +1600,7 @@ public class PurpurWorldConfig { } piglinBruteMaxHealth = getDouble("mobs.piglin_brute.attributes.max_health", piglinBruteMaxHealth); piglinBruteScale = Mth.clamp(getDouble("mobs.piglin_brute.attributes.scale", piglinBruteScale), 0.0625D, 16.0D); + piglinBruteTakeDamageFromWater = getBoolean("mobs.piglin_brute.takes-damage-from-water", piglinBruteTakeDamageFromWater); } public boolean pillagerRidable = false; @@ -1529,6 +1609,7 @@ public class PurpurWorldConfig { public double pillagerMaxHealth = 24.0D; public double pillagerScale = 1.0D; public boolean pillagerBypassMobGriefing = false; + public boolean pillagerTakeDamageFromWater = false; private void pillagerSettings() { pillagerRidable = getBoolean("mobs.pillager.ridable", pillagerRidable); pillagerRidableInWater = getBoolean("mobs.pillager.ridable-in-water", pillagerRidableInWater); @@ -1541,6 +1622,7 @@ public class PurpurWorldConfig { pillagerMaxHealth = getDouble("mobs.pillager.attributes.max_health", pillagerMaxHealth); pillagerScale = Mth.clamp(getDouble("mobs.pillager.attributes.scale", pillagerScale), 0.0625D, 16.0D); pillagerBypassMobGriefing = getBoolean("mobs.pillager.bypass-mob-griefing", pillagerBypassMobGriefing); + pillagerTakeDamageFromWater = getBoolean("mobs.pillager.takes-damage-from-water", pillagerTakeDamageFromWater); } public boolean polarBearRidable = false; @@ -1551,6 +1633,7 @@ public class PurpurWorldConfig { public String polarBearBreedableItemString = ""; public Item polarBearBreedableItem = null; public int polarBearBreedingTicks = 6000; + public boolean polarBearTakeDamageFromWater = false; private void polarBearSettings() { polarBearRidable = getBoolean("mobs.polar_bear.ridable", polarBearRidable); polarBearRidableInWater = getBoolean("mobs.polar_bear.ridable-in-water", polarBearRidableInWater); @@ -1566,12 +1649,14 @@ public class PurpurWorldConfig { Item item = BuiltInRegistries.ITEM.getValue(ResourceLocation.parse(polarBearBreedableItemString)); if (item != Items.AIR) polarBearBreedableItem = item; polarBearBreedingTicks = getInt("mobs.polar_bear.breeding-delay-ticks", polarBearBreedingTicks); + polarBearTakeDamageFromWater = getBoolean("mobs.polar_bear.takes-damage-from-water", polarBearTakeDamageFromWater); } public boolean pufferfishRidable = false; public boolean pufferfishControllable = true; public double pufferfishMaxHealth = 3.0D; public double pufferfishScale = 1.0D; + public boolean pufferfishTakeDamageFromWater = false; private void pufferfishSettings() { pufferfishRidable = getBoolean("mobs.pufferfish.ridable", pufferfishRidable); pufferfishControllable = getBoolean("mobs.pufferfish.controllable", pufferfishControllable); @@ -1582,6 +1667,7 @@ public class PurpurWorldConfig { } pufferfishMaxHealth = getDouble("mobs.pufferfish.attributes.max_health", pufferfishMaxHealth); pufferfishScale = Mth.clamp(getDouble("mobs.pufferfish.attributes.scale", pufferfishScale), 0.0625D, 16.0D); + pufferfishTakeDamageFromWater = getBoolean("mobs.pufferfish.takes-damage-from-water", pufferfishTakeDamageFromWater); } public boolean rabbitRidable = false; @@ -1593,6 +1679,7 @@ public class PurpurWorldConfig { public double rabbitNaturalKiller = 0.0D; public int rabbitBreedingTicks = 6000; public boolean rabbitBypassMobGriefing = false; + public boolean rabbitTakeDamageFromWater = false; private void rabbitSettings() { rabbitRidable = getBoolean("mobs.rabbit.ridable", rabbitRidable); rabbitRidableInWater = getBoolean("mobs.rabbit.ridable-in-water", rabbitRidableInWater); @@ -1608,6 +1695,7 @@ public class PurpurWorldConfig { rabbitNaturalKiller = getDouble("mobs.rabbit.spawn-killer-rabbit-chance", rabbitNaturalKiller); rabbitBreedingTicks = getInt("mobs.rabbit.breeding-delay-ticks", rabbitBreedingTicks); rabbitBypassMobGriefing = getBoolean("mobs.rabbit.bypass-mob-griefing", rabbitBypassMobGriefing); + rabbitTakeDamageFromWater = getBoolean("mobs.rabbit.takes-damage-from-water", rabbitTakeDamageFromWater); } public boolean ravagerRidable = false; @@ -1616,6 +1704,7 @@ public class PurpurWorldConfig { public double ravagerMaxHealth = 100.0D; public double ravagerScale = 1.0D; public boolean ravagerBypassMobGriefing = false; + public boolean ravagerTakeDamageFromWater = false; private void ravagerSettings() { ravagerRidable = getBoolean("mobs.ravager.ridable", ravagerRidable); ravagerRidableInWater = getBoolean("mobs.ravager.ridable-in-water", ravagerRidableInWater); @@ -1628,12 +1717,14 @@ public class PurpurWorldConfig { ravagerMaxHealth = getDouble("mobs.ravager.attributes.max_health", ravagerMaxHealth); ravagerScale = Mth.clamp(getDouble("mobs.ravager.attributes.scale", ravagerScale), 0.0625D, 16.0D); ravagerBypassMobGriefing = getBoolean("mobs.ravager.bypass-mob-griefing", ravagerBypassMobGriefing); + ravagerTakeDamageFromWater = getBoolean("mobs.ravager.takes-damage-from-water", ravagerTakeDamageFromWater); } public boolean salmonRidable = false; public boolean salmonControllable = true; public double salmonMaxHealth = 3.0D; public double salmonScale = 1.0D; + public boolean salmonTakeDamageFromWater = false; private void salmonSettings() { salmonRidable = getBoolean("mobs.salmon.ridable", salmonRidable); salmonControllable = getBoolean("mobs.salmon.controllable", salmonControllable); @@ -1644,6 +1735,7 @@ public class PurpurWorldConfig { } salmonMaxHealth = getDouble("mobs.salmon.attributes.max_health", salmonMaxHealth); salmonScale = Mth.clamp(getDouble("mobs.salmon.attributes.scale", salmonScale), 0.0625D, 16.0D); + salmonTakeDamageFromWater = getBoolean("mobs.salmon.takes-damage-from-water", salmonTakeDamageFromWater); } public boolean sheepRidable = false; @@ -1653,6 +1745,7 @@ public class PurpurWorldConfig { public double sheepScale = 1.0D; public int sheepBreedingTicks = 6000; public boolean sheepBypassMobGriefing = false; + public boolean sheepTakeDamageFromWater = false; private void sheepSettings() { sheepRidable = getBoolean("mobs.sheep.ridable", sheepRidable); sheepRidableInWater = getBoolean("mobs.sheep.ridable-in-water", sheepRidableInWater); @@ -1666,6 +1759,7 @@ public class PurpurWorldConfig { sheepScale = Mth.clamp(getDouble("mobs.sheep.attributes.scale", sheepScale), 0.0625D, 16.0D); sheepBreedingTicks = getInt("mobs.sheep.breeding-delay-ticks", sheepBreedingTicks); sheepBypassMobGriefing = getBoolean("mobs.sheep.bypass-mob-griefing", sheepBypassMobGriefing); + sheepTakeDamageFromWater = getBoolean("mobs.sheep.takes-damage-from-water", sheepTakeDamageFromWater); } public boolean shulkerRidable = false; @@ -1673,6 +1767,7 @@ public class PurpurWorldConfig { public boolean shulkerControllable = true; public double shulkerMaxHealth = 30.0D; public double shulkerScale = 1.0D; + public boolean shulkerTakeDamageFromWater = false; private void shulkerSettings() { shulkerRidable = getBoolean("mobs.shulker.ridable", shulkerRidable); shulkerRidableInWater = getBoolean("mobs.shulker.ridable-in-water", shulkerRidableInWater); @@ -1684,6 +1779,7 @@ public class PurpurWorldConfig { } shulkerMaxHealth = getDouble("mobs.shulker.attributes.max_health", shulkerMaxHealth); shulkerScale = Mth.clamp(getDouble("mobs.shulker.attributes.scale", shulkerScale), 0.0625D, Shulker.MAX_SCALE); + shulkerTakeDamageFromWater = getBoolean("mobs.shulker.takes-damage-from-water", shulkerTakeDamageFromWater); } public boolean silverfishRidable = false; @@ -1694,6 +1790,7 @@ public class PurpurWorldConfig { public double silverfishMovementSpeed = 0.25D; public double silverfishAttackDamage = 1.0D; public boolean silverfishBypassMobGriefing = false; + public boolean silverfishTakeDamageFromWater = false; private void silverfishSettings() { silverfishRidable = getBoolean("mobs.silverfish.ridable", silverfishRidable); silverfishRidableInWater = getBoolean("mobs.silverfish.ridable-in-water", silverfishRidableInWater); @@ -1708,6 +1805,7 @@ public class PurpurWorldConfig { silverfishMovementSpeed = getDouble("mobs.silverfish.attributes.movement_speed", silverfishMovementSpeed); silverfishAttackDamage = getDouble("mobs.silverfish.attributes.attack_damage", silverfishAttackDamage); silverfishBypassMobGriefing = getBoolean("mobs.silverfish.bypass-mob-griefing", silverfishBypassMobGriefing); + silverfishTakeDamageFromWater = getBoolean("mobs.silverfish.takes-damage-from-water", silverfishTakeDamageFromWater); } public boolean skeletonRidable = false; @@ -1715,6 +1813,7 @@ public class PurpurWorldConfig { public boolean skeletonControllable = true; public double skeletonMaxHealth = 20.0D; public double skeletonScale = 1.0D; + public boolean skeletonTakeDamageFromWater = false; private void skeletonSettings() { skeletonRidable = getBoolean("mobs.skeleton.ridable", skeletonRidable); skeletonRidableInWater = getBoolean("mobs.skeleton.ridable-in-water", skeletonRidableInWater); @@ -1726,6 +1825,7 @@ public class PurpurWorldConfig { } skeletonMaxHealth = getDouble("mobs.skeleton.attributes.max_health", skeletonMaxHealth); skeletonScale = Mth.clamp(getDouble("mobs.skeleton.attributes.scale", skeletonScale), 0.0625D, 16.0D); + skeletonTakeDamageFromWater = getBoolean("mobs.skeleton.takes-damage-from-water", skeletonTakeDamageFromWater); } public boolean skeletonHorseRidable = false; @@ -1737,6 +1837,7 @@ public class PurpurWorldConfig { public double skeletonHorseJumpStrengthMax = 1.0D; public double skeletonHorseMovementSpeedMin = 0.2D; public double skeletonHorseMovementSpeedMax = 0.2D; + public boolean skeletonHorseTakeDamageFromWater = false; private void skeletonHorseSettings() { skeletonHorseRidable = getBoolean("mobs.skeleton_horse.ridable", skeletonHorseRidable); skeletonHorseRidableInWater = getBoolean("mobs.skeleton_horse.ridable-in-water", skeletonHorseRidableInWater); @@ -1753,6 +1854,7 @@ public class PurpurWorldConfig { skeletonHorseJumpStrengthMax = getDouble("mobs.skeleton_horse.attributes.jump_strength.max", skeletonHorseJumpStrengthMax); skeletonHorseMovementSpeedMin = getDouble("mobs.skeleton_horse.attributes.movement_speed.min", skeletonHorseMovementSpeedMin); skeletonHorseMovementSpeedMax = getDouble("mobs.skeleton_horse.attributes.movement_speed.max", skeletonHorseMovementSpeedMax); + skeletonHorseTakeDamageFromWater = getBoolean("mobs.skeleton_horse.takes-damage-from-water", skeletonHorseTakeDamageFromWater); } public boolean slimeRidable = false; @@ -1762,6 +1864,7 @@ public class PurpurWorldConfig { public String slimeAttackDamage = "size"; public Map slimeMaxHealthCache = new HashMap<>(); public Map slimeAttackDamageCache = new HashMap<>(); + public boolean slimeTakeDamageFromWater = false; private void slimeSettings() { slimeRidable = getBoolean("mobs.slime.ridable", slimeRidable); slimeRidableInWater = getBoolean("mobs.slime.ridable-in-water", slimeRidableInWater); @@ -1775,6 +1878,7 @@ public class PurpurWorldConfig { slimeAttackDamage = getString("mobs.slime.attributes.attack_damage", slimeAttackDamage); slimeMaxHealthCache.clear(); slimeAttackDamageCache.clear(); + slimeTakeDamageFromWater = getBoolean("mobs.slime.takes-damage-from-water", slimeTakeDamageFromWater); } public boolean snowGolemRidable = false; @@ -1789,6 +1893,7 @@ public class PurpurWorldConfig { public float snowGolemSnowBallModifier = 10.0F; public double snowGolemAttackDistance = 1.25D; public boolean snowGolemBypassMobGriefing = false; + public boolean snowGolemTakeDamageFromWater = true; private void snowGolemSettings() { snowGolemRidable = getBoolean("mobs.snow_golem.ridable", snowGolemRidable); snowGolemRidableInWater = getBoolean("mobs.snow_golem.ridable-in-water", snowGolemRidableInWater); @@ -1807,6 +1912,7 @@ public class PurpurWorldConfig { snowGolemSnowBallModifier = (float) getDouble("mobs.snow_golem.snow-ball-modifier", snowGolemSnowBallModifier); snowGolemAttackDistance = getDouble("mobs.snow_golem.attack-distance", snowGolemAttackDistance); snowGolemBypassMobGriefing = getBoolean("mobs.snow_golem.bypass-mob-griefing", snowGolemBypassMobGriefing); + snowGolemTakeDamageFromWater = getBoolean("mobs.snow_golem.takes-damage-from-water", snowGolemTakeDamageFromWater); } public boolean snifferRidable = false; @@ -1831,6 +1937,7 @@ public class PurpurWorldConfig { public boolean squidImmuneToEAR = true; public double squidOffsetWaterCheck = 0.0D; public boolean squidsCanFly = false; + public boolean squidTakeDamageFromWater = false; private void squidSettings() { squidRidable = getBoolean("mobs.squid.ridable", squidRidable); squidControllable = getBoolean("mobs.squid.controllable", squidControllable); @@ -1844,6 +1951,7 @@ public class PurpurWorldConfig { squidImmuneToEAR = getBoolean("mobs.squid.immune-to-EAR", squidImmuneToEAR); squidOffsetWaterCheck = getDouble("mobs.squid.water-offset-check", squidOffsetWaterCheck); squidsCanFly = getBoolean("mobs.squid.can-fly", squidsCanFly); + squidTakeDamageFromWater = getBoolean("mobs.squid.takes-damage-from-water", squidTakeDamageFromWater); } public boolean spiderRidable = false; @@ -1851,6 +1959,7 @@ public class PurpurWorldConfig { public boolean spiderControllable = true; public double spiderMaxHealth = 16.0D; public double spiderScale = 1.0D; + public boolean spiderTakeDamageFromWater = false; private void spiderSettings() { spiderRidable = getBoolean("mobs.spider.ridable", spiderRidable); spiderRidableInWater = getBoolean("mobs.spider.ridable-in-water", spiderRidableInWater); @@ -1862,6 +1971,7 @@ public class PurpurWorldConfig { } spiderMaxHealth = getDouble("mobs.spider.attributes.max_health", spiderMaxHealth); spiderScale = Mth.clamp(getDouble("mobs.spider.attributes.scale", spiderScale), 0.0625D, 16.0D); + spiderTakeDamageFromWater = getBoolean("mobs.spider.takes-damage-from-water", spiderTakeDamageFromWater); } public boolean strayRidable = false; @@ -1869,6 +1979,7 @@ public class PurpurWorldConfig { public boolean strayControllable = true; public double strayMaxHealth = 20.0D; public double strayScale = 1.0D; + public boolean strayTakeDamageFromWater = false; private void straySettings() { strayRidable = getBoolean("mobs.stray.ridable", strayRidable); strayRidableInWater = getBoolean("mobs.stray.ridable-in-water", strayRidableInWater); @@ -1880,6 +1991,7 @@ public class PurpurWorldConfig { } strayMaxHealth = getDouble("mobs.stray.attributes.max_health", strayMaxHealth); strayScale = Mth.clamp(getDouble("mobs.stray.attributes.scale", strayScale), 0.0625D, 16.0D); + strayTakeDamageFromWater = getBoolean("mobs.stray.takes-damage-from-water", strayTakeDamageFromWater); } public boolean striderRidable = false; @@ -1889,6 +2001,7 @@ public class PurpurWorldConfig { public double striderScale = 1.0D; public int striderBreedingTicks = 6000; public boolean striderGiveSaddleBack = false; + public boolean striderTakeDamageFromWater = true; private void striderSettings() { striderRidable = getBoolean("mobs.strider.ridable", striderRidable); striderRidableInWater = getBoolean("mobs.strider.ridable-in-water", striderRidableInWater); @@ -1902,6 +2015,7 @@ public class PurpurWorldConfig { striderScale = Mth.clamp(getDouble("mobs.strider.attributes.scale", striderScale), 0.0625D, 16.0D); striderBreedingTicks = getInt("mobs.strider.breeding-delay-ticks", striderBreedingTicks); striderGiveSaddleBack = getBoolean("mobs.strider.give-saddle-back", striderGiveSaddleBack); + striderTakeDamageFromWater = getBoolean("mobs.strider.takes-damage-from-water", striderTakeDamageFromWater); } public boolean tadpoleRidable = false; @@ -1923,6 +2037,7 @@ public class PurpurWorldConfig { public double traderLlamaMovementSpeedMin = 0.175D; public double traderLlamaMovementSpeedMax = 0.175D; public int traderLlamaBreedingTicks = 6000; + public boolean traderLlamaTakeDamageFromWater = false; private void traderLlamaSettings() { traderLlamaRidable = getBoolean("mobs.trader_llama.ridable", traderLlamaRidable); traderLlamaRidableInWater = getBoolean("mobs.trader_llama.ridable-in-water", traderLlamaRidableInWater); @@ -1941,12 +2056,14 @@ public class PurpurWorldConfig { traderLlamaMovementSpeedMin = getDouble("mobs.trader_llama.attributes.movement_speed.min", traderLlamaMovementSpeedMin); traderLlamaMovementSpeedMax = getDouble("mobs.trader_llama.attributes.movement_speed.max", traderLlamaMovementSpeedMax); traderLlamaBreedingTicks = getInt("mobs.trader_llama.breeding-delay-ticks", traderLlamaBreedingTicks); + traderLlamaTakeDamageFromWater = getBoolean("mobs.trader_llama.takes-damage-from-water", traderLlamaTakeDamageFromWater); } public boolean tropicalFishRidable = false; public boolean tropicalFishControllable = true; public double tropicalFishMaxHealth = 3.0D; public double tropicalFishScale = 1.0D; + public boolean tropicalFishTakeDamageFromWater = false; private void tropicalFishSettings() { tropicalFishRidable = getBoolean("mobs.tropical_fish.ridable", tropicalFishRidable); tropicalFishControllable = getBoolean("mobs.tropical_fish.controllable", tropicalFishControllable); @@ -1957,6 +2074,7 @@ public class PurpurWorldConfig { } tropicalFishMaxHealth = getDouble("mobs.tropical_fish.attributes.max_health", tropicalFishMaxHealth); tropicalFishScale = Mth.clamp(getDouble("mobs.tropical_fish.attributes.scale", tropicalFishScale), 0.0625D, 16.0D); + tropicalFishTakeDamageFromWater = getBoolean("mobs.tropical_fish.takes-damage-from-water", tropicalFishTakeDamageFromWater); } public boolean turtleRidable = false; @@ -1965,6 +2083,7 @@ public class PurpurWorldConfig { public double turtleMaxHealth = 30.0D; public double turtleScale = 1.0D; public int turtleBreedingTicks = 6000; + public boolean turtleTakeDamageFromWater = false; private void turtleSettings() { turtleRidable = getBoolean("mobs.turtle.ridable", turtleRidable); turtleRidableInWater = getBoolean("mobs.turtle.ridable-in-water", turtleRidableInWater); @@ -1977,6 +2096,7 @@ public class PurpurWorldConfig { turtleMaxHealth = getDouble("mobs.turtle.attributes.max_health", turtleMaxHealth); turtleScale = Mth.clamp(getDouble("mobs.turtle.attributes.scale", turtleScale), 0.0625D, 16.0D); turtleBreedingTicks = getInt("mobs.turtle.breeding-delay-ticks", turtleBreedingTicks); + turtleTakeDamageFromWater = getBoolean("mobs.turtle.takes-damage-from-water", turtleTakeDamageFromWater); } public boolean vexRidable = false; @@ -1985,6 +2105,7 @@ public class PurpurWorldConfig { public double vexMaxY = 320D; public double vexMaxHealth = 14.0D; public double vexScale = 1.0D; + public boolean vexTakeDamageFromWater = false; private void vexSettings() { vexRidable = getBoolean("mobs.vex.ridable", vexRidable); vexRidableInWater = getBoolean("mobs.vex.ridable-in-water", vexRidableInWater); @@ -1997,6 +2118,7 @@ public class PurpurWorldConfig { } vexMaxHealth = getDouble("mobs.vex.attributes.max_health", vexMaxHealth); vexScale = Mth.clamp(getDouble("mobs.vex.attributes.scale", vexScale), 0.0625D, 16.0D); + vexTakeDamageFromWater = getBoolean("mobs.vex.takes-damage-from-water", vexTakeDamageFromWater); } public boolean villagerRidable = false; @@ -2012,6 +2134,7 @@ public class PurpurWorldConfig { public boolean villagerClericsFarmWarts = false; public boolean villagerClericFarmersThrowWarts = true; public boolean villagerBypassMobGriefing = false; + public boolean villagerTakeDamageFromWater = false; private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); @@ -2031,6 +2154,7 @@ public class PurpurWorldConfig { villagerClericsFarmWarts = getBoolean("mobs.villager.clerics-farm-warts", villagerClericsFarmWarts); villagerClericFarmersThrowWarts = getBoolean("mobs.villager.cleric-wart-farmers-throw-warts-at-villagers", villagerClericFarmersThrowWarts); villagerBypassMobGriefing = getBoolean("mobs.villager.bypass-mob-griefing", villagerBypassMobGriefing); + villagerTakeDamageFromWater = getBoolean("mobs.villager.takes-damage-from-water", villagerTakeDamageFromWater); } public boolean vindicatorRidable = false; @@ -2039,6 +2163,7 @@ public class PurpurWorldConfig { public double vindicatorMaxHealth = 24.0D; public double vindicatorScale = 1.0D; public double vindicatorJohnnySpawnChance = 0D; + public boolean vindicatorTakeDamageFromWater = false; private void vindicatorSettings() { vindicatorRidable = getBoolean("mobs.vindicator.ridable", vindicatorRidable); vindicatorRidableInWater = getBoolean("mobs.vindicator.ridable-in-water", vindicatorRidableInWater); @@ -2051,6 +2176,7 @@ public class PurpurWorldConfig { vindicatorMaxHealth = getDouble("mobs.vindicator.attributes.max_health", vindicatorMaxHealth); vindicatorScale = Mth.clamp(getDouble("mobs.vindicator.attributes.scale", vindicatorScale), 0.0625D, 16.0D); vindicatorJohnnySpawnChance = getDouble("mobs.vindicator.johnny.spawn-chance", vindicatorJohnnySpawnChance); + vindicatorTakeDamageFromWater = getBoolean("mobs.vindicator.takes-damage-from-water", vindicatorTakeDamageFromWater); } public boolean wanderingTraderRidable = false; @@ -2061,6 +2187,7 @@ public class PurpurWorldConfig { public boolean wanderingTraderFollowEmeraldBlock = false; public double wanderingTraderTemptRange = 10.0D; public boolean wanderingTraderCanBeLeashed = false; + public boolean wanderingTraderTakeDamageFromWater = false; private void wanderingTraderSettings() { wanderingTraderRidable = getBoolean("mobs.wandering_trader.ridable", wanderingTraderRidable); wanderingTraderRidableInWater = getBoolean("mobs.wandering_trader.ridable-in-water", wanderingTraderRidableInWater); @@ -2075,6 +2202,7 @@ public class PurpurWorldConfig { wanderingTraderFollowEmeraldBlock = getBoolean("mobs.wandering_trader.follow-emerald-blocks", wanderingTraderFollowEmeraldBlock); wanderingTraderTemptRange = getDouble("mobs.wandering_trader.attributes.tempt_range", wanderingTraderTemptRange); wanderingTraderCanBeLeashed = getBoolean("mobs.wandering_trader.can-be-leashed", wanderingTraderCanBeLeashed); + wanderingTraderTakeDamageFromWater = getBoolean("mobs.wandering_trader.takes-damage-from-water", wanderingTraderTakeDamageFromWater); } public boolean wardenRidable = false; @@ -2091,6 +2219,7 @@ public class PurpurWorldConfig { public boolean witchControllable = true; public double witchMaxHealth = 26.0D; public double witchScale = 1.0D; + public boolean witchTakeDamageFromWater = false; private void witchSettings() { witchRidable = getBoolean("mobs.witch.ridable", witchRidable); witchRidableInWater = getBoolean("mobs.witch.ridable-in-water", witchRidableInWater); @@ -2102,6 +2231,7 @@ public class PurpurWorldConfig { } witchMaxHealth = getDouble("mobs.witch.attributes.max_health", witchMaxHealth); witchScale = Mth.clamp(getDouble("mobs.witch.attributes.scale", witchScale), 0.0625D, 16.0D); + witchTakeDamageFromWater = getBoolean("mobs.witch.takes-damage-from-water", witchTakeDamageFromWater); } public boolean witherRidable = false; @@ -2113,6 +2243,7 @@ public class PurpurWorldConfig { public float witherHealthRegenAmount = 1.0f; public int witherHealthRegenDelay = 20; public boolean witherBypassMobGriefing = false; + public boolean witherTakeDamageFromWater = false; private void witherSettings() { witherRidable = getBoolean("mobs.wither.ridable", witherRidable); witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater); @@ -2132,6 +2263,7 @@ public class PurpurWorldConfig { witherHealthRegenAmount = (float) getDouble("mobs.wither.health-regen-amount", witherHealthRegenAmount); witherHealthRegenDelay = getInt("mobs.wither.health-regen-delay", witherHealthRegenDelay); witherBypassMobGriefing = getBoolean("mobs.wither.bypass-mob-griefing", witherBypassMobGriefing); + witherTakeDamageFromWater = getBoolean("mobs.wither.takes-damage-from-water", witherTakeDamageFromWater); } public boolean witherSkeletonRidable = false; @@ -2139,6 +2271,7 @@ public class PurpurWorldConfig { public boolean witherSkeletonControllable = true; public double witherSkeletonMaxHealth = 20.0D; public double witherSkeletonScale = 1.0D; + public boolean witherSkeletonTakeDamageFromWater = false; private void witherSkeletonSettings() { witherSkeletonRidable = getBoolean("mobs.wither_skeleton.ridable", witherSkeletonRidable); witherSkeletonRidableInWater = getBoolean("mobs.wither_skeleton.ridable-in-water", witherSkeletonRidableInWater); @@ -2150,6 +2283,7 @@ public class PurpurWorldConfig { } witherSkeletonMaxHealth = getDouble("mobs.wither_skeleton.attributes.max_health", witherSkeletonMaxHealth); witherSkeletonScale = Mth.clamp(getDouble("mobs.wither_skeleton.attributes.scale", witherSkeletonScale), 0.0625D, 16.0D); + witherSkeletonTakeDamageFromWater = getBoolean("mobs.wither_skeleton.takes-damage-from-water", witherSkeletonTakeDamageFromWater); } public boolean wolfRidable = false; @@ -2161,6 +2295,7 @@ public class PurpurWorldConfig { public boolean wolfMilkCuresRabies = true; public double wolfNaturalRabid = 0.0D; public int wolfBreedingTicks = 6000; + public boolean wolfTakeDamageFromWater = false; private void wolfSettings() { wolfRidable = getBoolean("mobs.wolf.ridable", wolfRidable); wolfRidableInWater = getBoolean("mobs.wolf.ridable-in-water", wolfRidableInWater); @@ -2180,6 +2315,7 @@ public class PurpurWorldConfig { wolfMilkCuresRabies = getBoolean("mobs.wolf.milk-cures-rabid-wolves", wolfMilkCuresRabies); wolfNaturalRabid = getDouble("mobs.wolf.spawn-rabid-chance", wolfNaturalRabid); wolfBreedingTicks = getInt("mobs.wolf.breeding-delay-ticks", wolfBreedingTicks); + wolfTakeDamageFromWater = getBoolean("mobs.wolf.takes-damage-from-water", wolfTakeDamageFromWater); } public boolean zoglinRidable = false; @@ -2187,6 +2323,7 @@ public class PurpurWorldConfig { public boolean zoglinControllable = true; public double zoglinMaxHealth = 40.0D; public double zoglinScale = 1.0D; + public boolean zoglinTakeDamageFromWater = false; private void zoglinSettings() { zoglinRidable = getBoolean("mobs.zoglin.ridable", zoglinRidable); zoglinRidableInWater = getBoolean("mobs.zoglin.ridable-in-water", zoglinRidableInWater); @@ -2198,6 +2335,7 @@ public class PurpurWorldConfig { } zoglinMaxHealth = getDouble("mobs.zoglin.attributes.max_health", zoglinMaxHealth); zoglinScale = Mth.clamp(getDouble("mobs.zoglin.attributes.scale", zoglinScale), 0.0625D, 16.0D); + zoglinTakeDamageFromWater = getBoolean("mobs.zoglin.takes-damage-from-water", zoglinTakeDamageFromWater); } public boolean zombieRidable = false; @@ -2211,6 +2349,7 @@ public class PurpurWorldConfig { public boolean zombieJockeyTryExistingChickens = true; public boolean zombieAggressiveTowardsVillagerWhenLagging = true; public boolean zombieBypassMobGriefing = false; + public boolean zombieTakeDamageFromWater = false; private void zombieSettings() { zombieRidable = getBoolean("mobs.zombie.ridable", zombieRidable); zombieRidableInWater = getBoolean("mobs.zombie.ridable-in-water", zombieRidableInWater); @@ -2228,6 +2367,7 @@ public class PurpurWorldConfig { zombieJockeyTryExistingChickens = getBoolean("mobs.zombie.jockey.try-existing-chickens", zombieJockeyTryExistingChickens); zombieAggressiveTowardsVillagerWhenLagging = getBoolean("mobs.zombie.aggressive-towards-villager-when-lagging", zombieAggressiveTowardsVillagerWhenLagging); zombieBypassMobGriefing = getBoolean("mobs.zombie.bypass-mob-griefing", zombieBypassMobGriefing); + zombieTakeDamageFromWater = getBoolean("mobs.zombie.takes-damage-from-water", zombieTakeDamageFromWater); } public boolean zombieHorseRidable = false; @@ -2240,6 +2380,7 @@ public class PurpurWorldConfig { public double zombieHorseMovementSpeedMin = 0.2D; public double zombieHorseMovementSpeedMax = 0.2D; public double zombieHorseSpawnChance = 0.0D; + public boolean zombieHorseTakeDamageFromWater = false; private void zombieHorseSettings() { zombieHorseRidable = getBoolean("mobs.zombie_horse.ridable", zombieHorseRidable); zombieHorseRidableInWater = getBoolean("mobs.zombie_horse.ridable-in-water", zombieHorseRidableInWater); @@ -2257,6 +2398,7 @@ public class PurpurWorldConfig { zombieHorseMovementSpeedMin = getDouble("mobs.zombie_horse.attributes.movement_speed.min", zombieHorseMovementSpeedMin); zombieHorseMovementSpeedMax = getDouble("mobs.zombie_horse.attributes.movement_speed.max", zombieHorseMovementSpeedMax); zombieHorseSpawnChance = getDouble("mobs.zombie_horse.spawn-chance", zombieHorseSpawnChance); + zombieHorseTakeDamageFromWater = getBoolean("mobs.zombie_horse.takes-damage-from-water", zombieHorseTakeDamageFromWater); } public boolean zombieVillagerRidable = false; @@ -2268,6 +2410,7 @@ public class PurpurWorldConfig { public boolean zombieVillagerJockeyOnlyBaby = true; public double zombieVillagerJockeyChance = 0.05D; public boolean zombieVillagerJockeyTryExistingChickens = true; + public boolean zombieVillagerTakeDamageFromWater = false; private void zombieVillagerSettings() { zombieVillagerRidable = getBoolean("mobs.zombie_villager.ridable", zombieVillagerRidable); zombieVillagerRidableInWater = getBoolean("mobs.zombie_villager.ridable-in-water", zombieVillagerRidableInWater); @@ -2283,6 +2426,7 @@ public class PurpurWorldConfig { zombieVillagerJockeyOnlyBaby = getBoolean("mobs.zombie_villager.jockey.only-babies", zombieVillagerJockeyOnlyBaby); zombieVillagerJockeyChance = getDouble("mobs.zombie_villager.jockey.chance", zombieVillagerJockeyChance); zombieVillagerJockeyTryExistingChickens = getBoolean("mobs.zombie_villager.jockey.try-existing-chickens", zombieVillagerJockeyTryExistingChickens); + zombieVillagerTakeDamageFromWater = getBoolean("mobs.zombie_villager.takes-damage-from-water", zombieVillagerTakeDamageFromWater); } public boolean zombifiedPiglinRidable = false; @@ -2295,6 +2439,7 @@ public class PurpurWorldConfig { public double zombifiedPiglinJockeyChance = 0.05D; public boolean zombifiedPiglinJockeyTryExistingChickens = true; public boolean zombifiedPiglinCountAsPlayerKillWhenAngry = true; + public boolean zombifiedPiglinTakeDamageFromWater = false; private void zombifiedPiglinSettings() { zombifiedPiglinRidable = getBoolean("mobs.zombified_piglin.ridable", zombifiedPiglinRidable); zombifiedPiglinRidableInWater = getBoolean("mobs.zombified_piglin.ridable-in-water", zombifiedPiglinRidableInWater); @@ -2311,5 +2456,6 @@ public class PurpurWorldConfig { zombifiedPiglinJockeyChance = getDouble("mobs.zombified_piglin.jockey.chance", zombifiedPiglinJockeyChance); zombifiedPiglinJockeyTryExistingChickens = getBoolean("mobs.zombified_piglin.jockey.try-existing-chickens", zombifiedPiglinJockeyTryExistingChickens); zombifiedPiglinCountAsPlayerKillWhenAngry = getBoolean("mobs.zombified_piglin.count-as-player-kill-when-angry", zombifiedPiglinCountAsPlayerKillWhenAngry); + zombifiedPiglinTakeDamageFromWater = getBoolean("mobs.zombified_piglin.takes-damage-from-water", zombifiedPiglinTakeDamageFromWater); } }