diff --git a/patches/server/0246-Mobs-always-drop-experience.patch b/patches/server/0246-Mobs-always-drop-experience.patch new file mode 100644 index 000000000..011b36b9a --- /dev/null +++ b/patches/server/0246-Mobs-always-drop-experience.patch @@ -0,0 +1,2286 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: BillyGalbreath +Date: Tue, 21 Dec 2021 20:40:42 -0600 +Subject: [PATCH] Mobs always drop experience + + +diff --git a/src/main/java/net/minecraft/world/entity/GlowSquid.java b/src/main/java/net/minecraft/world/entity/GlowSquid.java +index 2feec97ffe62cfe063085e3767937e8af122ee95..c2cf01d43d6550b8231d85a55bed861497bcded2 100644 +--- a/src/main/java/net/minecraft/world/entity/GlowSquid.java ++++ b/src/main/java/net/minecraft/world/entity/GlowSquid.java +@@ -48,6 +48,11 @@ public class GlowSquid extends Squid { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.glowSquidTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.glowSquidAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/ambient/Bat.java b/src/main/java/net/minecraft/world/entity/ambient/Bat.java +index df62c7a24560f305832e925afa7ce7b182bb1b35..78e7279e88d72768e64fc51ef8fab19059aa3489 100644 +--- a/src/main/java/net/minecraft/world/entity/ambient/Bat.java ++++ b/src/main/java/net/minecraft/world/entity/ambient/Bat.java +@@ -103,6 +103,11 @@ public class Bat extends AmbientCreature { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.batTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.batAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/Bee.java b/src/main/java/net/minecraft/world/entity/animal/Bee.java +index 9fa2359662079f406ca6204fa06d5dbfefec49d5..350863ed11b62600dc88324283637a01162acd21 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Bee.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java +@@ -225,6 +225,11 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.beeTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.beeAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/Cat.java b/src/main/java/net/minecraft/world/entity/animal/Cat.java +index c4ffe4517d7b8c521b5a11555eeffbe3c7a1801d..a66c307a2eb7b7d854cb57907fa2a6ff36cf2254 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Cat.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Cat.java +@@ -155,6 +155,11 @@ public class Cat extends TamableAnimal { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.catTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.catAlwaysDropExp; ++ } + // Purpur end + + public ResourceLocation getResourceLocation() { +diff --git a/src/main/java/net/minecraft/world/entity/animal/Chicken.java b/src/main/java/net/minecraft/world/entity/animal/Chicken.java +index eb3678d3a23d1eddc09b8032564235e101d56166..4470805d41ae81edda708ecc022ab8700b20b3b3 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Chicken.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Chicken.java +@@ -80,6 +80,11 @@ public class Chicken extends Animal { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.chickenTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.chickenAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/Cod.java b/src/main/java/net/minecraft/world/entity/animal/Cod.java +index 82fdce04fe3867016d1b5e24df52a550e08dfa39..1383b6ef25bea8c6215d5c6253bebeb30c4c383a 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Cod.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Cod.java +@@ -33,6 +33,11 @@ public class Cod extends AbstractSchoolingFish { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.codTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.codAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/Cow.java b/src/main/java/net/minecraft/world/entity/animal/Cow.java +index bbd210f8779138b225ce886b3917ca9ccbcbcf60..c3c1f7b66b9c4a7373fe73cfa4cf5d12eb3c3f45 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Cow.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Cow.java +@@ -75,6 +75,11 @@ public class Cow extends Animal { + this.isNaturallyAggressiveToPlayers = level.purpurConfig.cowNaturallyAggressiveToPlayersChance > 0.0D && random.nextDouble() <= level.purpurConfig.cowNaturallyAggressiveToPlayersChance; + return super.finalizeSpawn(world, difficulty, spawnReason, entityData, entityNbt); + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.cowAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/Dolphin.java b/src/main/java/net/minecraft/world/entity/animal/Dolphin.java +index 022441af276cd9facba1ee4013d9d367db26711d..d94cac06a53bd36145cb025fdddc2ce94d9dd297 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Dolphin.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Dolphin.java +@@ -159,6 +159,11 @@ public class Dolphin extends WaterAnimal { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.dolphinTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.dolphinAlwaysDropExp; ++ } + // Purpur end + + @Nullable +diff --git a/src/main/java/net/minecraft/world/entity/animal/Fox.java b/src/main/java/net/minecraft/world/entity/animal/Fox.java +index f409215a99d6d0d2eda35173d1be762b11e96441..6e2c4e833a02f854fe0809a8168722576b680ab1 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Fox.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Fox.java +@@ -187,6 +187,11 @@ public class Fox extends Animal { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.foxTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.foxAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/IronGolem.java b/src/main/java/net/minecraft/world/entity/animal/IronGolem.java +index dd328a4514ef3638a44442797cbc616dbaef1f72..6c3edf731d5a74c7b16cf9d2caea8b9fa80b6457 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/IronGolem.java ++++ b/src/main/java/net/minecraft/world/entity/animal/IronGolem.java +@@ -100,6 +100,11 @@ public class IronGolem extends AbstractGolem implements NeutralMob { + public void setSummoner(@Nullable UUID summoner) { + this.summoner = summoner; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.ironGolemAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java b/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java +index 467e5bc4e9262fc331bb88f02e3b26f9f6bec72d..16b4b6a382db7c81eb19771a4fa0cc3ae73c3645 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java ++++ b/src/main/java/net/minecraft/world/entity/animal/MushroomCow.java +@@ -90,6 +90,11 @@ public class MushroomCow extends Cow implements Shearable { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.mooshroomTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.mooshroomAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/Ocelot.java b/src/main/java/net/minecraft/world/entity/animal/Ocelot.java +index 97d4caad92a2b54daff12e4909bc7b041ba99094..cbbfcfa93af935ec07986f85948f416d53494085 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Ocelot.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Ocelot.java +@@ -94,6 +94,11 @@ public class Ocelot extends Animal { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.ocelotTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.ocelotAlwaysDropExp; ++ } + // Purpur end + + public boolean isTrusting() { +diff --git a/src/main/java/net/minecraft/world/entity/animal/Panda.java b/src/main/java/net/minecraft/world/entity/animal/Panda.java +index 6270c4bad2c4f4f2770bc2cc2688de5ddd18dae4..4c555b7fabb03618cefaf9171002a006684059c6 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Panda.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Panda.java +@@ -142,6 +142,11 @@ public class Panda extends Animal { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.pandaTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.pandaAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/Parrot.java b/src/main/java/net/minecraft/world/entity/animal/Parrot.java +index bb9717d1b2039469aae26e0eb9a4304bff4ae7af..59037dc3a888b763c4fb6e5b06d0e5a0e1f3c935 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Parrot.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Parrot.java +@@ -196,6 +196,11 @@ public class Parrot extends ShoulderRidingEntity implements FlyingAnimal { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.parrotTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.parrotAlwaysDropExp; ++ } + // Purpur end + + @Nullable +diff --git a/src/main/java/net/minecraft/world/entity/animal/Pig.java b/src/main/java/net/minecraft/world/entity/animal/Pig.java +index 5aa57ce71c401e47c361dc8b74ac241a1732aede..77228b09f64c4d8eec4333316272f00284e12c5c 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Pig.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Pig.java +@@ -89,6 +89,11 @@ public class Pig extends Animal implements ItemSteerable, Saddleable { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.pigTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.pigAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/PolarBear.java b/src/main/java/net/minecraft/world/entity/animal/PolarBear.java +index 288de9480635f0df718596ff73e69101e164fc61..a4b8a4ef043be8961ea35c3fb8a9512d9ac286c3 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/PolarBear.java ++++ b/src/main/java/net/minecraft/world/entity/animal/PolarBear.java +@@ -125,6 +125,11 @@ public class PolarBear extends Animal implements NeutralMob { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.polarBearTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.polarBearAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/Pufferfish.java b/src/main/java/net/minecraft/world/entity/animal/Pufferfish.java +index 5d8a01df7b86f1a23b30ed67b27ebde7d800c08c..c3ca62ab107cc7b8f7ac6f7d8ad88d33f13cceaa 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Pufferfish.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Pufferfish.java +@@ -65,6 +65,11 @@ public class Pufferfish extends AbstractFish { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.pufferfishTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.pufferfishAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/Rabbit.java b/src/main/java/net/minecraft/world/entity/animal/Rabbit.java +index 59286f143f7ffcaf4da5bad4a0990cf437d53fdb..4f040854399cdd6c91f824e06f98a56eb65313d4 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Rabbit.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Rabbit.java +@@ -145,6 +145,11 @@ public class Rabbit extends Animal { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.rabbitTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.rabbitAlwaysDropExp; ++ } + // Purpur end + + // CraftBukkit start - code from constructor +diff --git a/src/main/java/net/minecraft/world/entity/animal/Salmon.java b/src/main/java/net/minecraft/world/entity/animal/Salmon.java +index 04bf6f321e39821bae2d1871c54e304c9dcaf179..9f77369189b1a528806e6b4d6eff897a39b8b78f 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Salmon.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Salmon.java +@@ -33,6 +33,11 @@ public class Salmon extends AbstractSchoolingFish { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.salmonTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.salmonAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/Sheep.java b/src/main/java/net/minecraft/world/entity/animal/Sheep.java +index 1d80303243da8a945c3866291e3a1a196245a0db..860e03111b29f9178a1cd361357985308a39d254 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Sheep.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Sheep.java +@@ -141,6 +141,11 @@ public class Sheep extends Animal implements Shearable { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.sheepTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.sheepAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java b/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java +index 1e646078c4522aaad4e298172af6972a940cdf5c..d60cb629586e6eccfcd79b1b2e4da119550497f3 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java ++++ b/src/main/java/net/minecraft/world/entity/animal/SnowGolem.java +@@ -79,6 +79,11 @@ public class SnowGolem extends AbstractGolem implements Shearable, RangedAttackM + public void setSummoner(@Nullable java.util.UUID summoner) { + this.summoner = summoner; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.snowGolemAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/Squid.java b/src/main/java/net/minecraft/world/entity/animal/Squid.java +index 7397d04b3fabca1f6d32adc571f56d2ad8fed751..764513425732d177d7c5a42b8d6aafe58061a88c 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Squid.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Squid.java +@@ -96,6 +96,11 @@ public class Squid extends WaterAnimal { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.squidTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.squidAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/TropicalFish.java b/src/main/java/net/minecraft/world/entity/animal/TropicalFish.java +index cbe50aacc9279d147d25775b3855c3a8caff2b9c..c2bb2fbb07d5bf6b3ad3d74baf594705d0c7170d 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/TropicalFish.java ++++ b/src/main/java/net/minecraft/world/entity/animal/TropicalFish.java +@@ -70,6 +70,11 @@ public class TropicalFish extends AbstractSchoolingFish { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.tropicalFishTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.tropicalFishAlwaysDropExp; ++ } + // Purpur end + + public static String getPredefinedName(int variant) { +diff --git a/src/main/java/net/minecraft/world/entity/animal/Turtle.java b/src/main/java/net/minecraft/world/entity/animal/Turtle.java +index 29749815ef26c7e956d6e773037554893e82284d..b39d942c874dac91833e860ea4f6980f2c23d9f9 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Turtle.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Turtle.java +@@ -111,6 +111,11 @@ public class Turtle extends Animal { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.turtleTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.turtleAlwaysDropExp; ++ } + // Purpur end + + public void setHomePos(BlockPos pos) { +diff --git a/src/main/java/net/minecraft/world/entity/animal/Wolf.java b/src/main/java/net/minecraft/world/entity/animal/Wolf.java +index 713fe8ac2293fe2e60c5834b3d6fd2f12f3bc391..3dba3f0bd9c2264a2ea703745f90fbaa5f64a0c2 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/Wolf.java ++++ b/src/main/java/net/minecraft/world/entity/animal/Wolf.java +@@ -204,6 +204,11 @@ public class Wolf extends TamableAnimal implements NeutralMob { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.wolfTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.wolfAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java +index d0edbad76a749163f77723547001e59352654e12..96c2920a808a0ab7fbd52677f29955d1b73ca290 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java ++++ b/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java +@@ -121,6 +121,11 @@ public class Axolotl extends Animal implements LerpingModel, Bucketable { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.axolotlTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.axolotlAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java +index d8bd81f1c8069f81983ccf0aee8200bd67c913de..66106dc6879b7b37dd149131a5fe751b788a15fa 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java ++++ b/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java +@@ -99,6 +99,11 @@ public class Goat extends Animal { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.goatTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.goatAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/Donkey.java b/src/main/java/net/minecraft/world/entity/animal/horse/Donkey.java +index c888516a1e4b7283fdb2cb15bc9a13900e901e53..645ff6433a299ef3ad8b2ea37c6c46e60a610d48 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/horse/Donkey.java ++++ b/src/main/java/net/minecraft/world/entity/animal/horse/Donkey.java +@@ -45,6 +45,11 @@ public class Donkey extends AbstractChestedHorse { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.donkeyTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.donkeyAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/Horse.java b/src/main/java/net/minecraft/world/entity/animal/horse/Horse.java +index 16755249c4700fa59f704b7c88e3490d2ce3fc48..17a6ddaaa474ee4ac9dd77c19a471bfb91486207 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/horse/Horse.java ++++ b/src/main/java/net/minecraft/world/entity/animal/horse/Horse.java +@@ -69,6 +69,11 @@ public class Horse extends AbstractHorse { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.horseTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.horseAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java b/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java +index 7656c933a835f15c40e75851e7a2348bdef4010e..6010683137f3ca1fb2cc3893608402ecfef57676 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java ++++ b/src/main/java/net/minecraft/world/entity/animal/horse/Llama.java +@@ -137,6 +137,11 @@ public class Llama extends AbstractChestedHorse implements RangedAttackMob { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.llamaTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.llamaAlwaysDropExp; ++ } + // Purpur end + + public boolean isTraderLlama() { +diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/Mule.java b/src/main/java/net/minecraft/world/entity/animal/horse/Mule.java +index 610282c7be7355f0800c1265cc8b19dd557d065a..7c52b316c24c8cf55bf4a68337dd70515b270a1a 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/horse/Mule.java ++++ b/src/main/java/net/minecraft/world/entity/animal/horse/Mule.java +@@ -44,6 +44,11 @@ public class Mule extends AbstractChestedHorse { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.muleTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.muleAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/SkeletonHorse.java b/src/main/java/net/minecraft/world/entity/animal/horse/SkeletonHorse.java +index 75b85b5a6ff38f32d0344a76d9f626c2d8f8077b..63269c9788fdc860fdde79f1bf56f4f3b28dc72f 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/horse/SkeletonHorse.java ++++ b/src/main/java/net/minecraft/world/entity/animal/horse/SkeletonHorse.java +@@ -59,6 +59,11 @@ public class SkeletonHorse extends AbstractHorse { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.skeletonHorseTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.skeletonHorseAlwaysDropExp; ++ } + // Purpur end + + public static AttributeSupplier.Builder createAttributes() { +diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/TraderLlama.java b/src/main/java/net/minecraft/world/entity/animal/horse/TraderLlama.java +index 201944f01609ad4e386504cab4b36bd57d298aac..95b99f4d46b18cbb8142e11fbfb4189172c2e7a0 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/horse/TraderLlama.java ++++ b/src/main/java/net/minecraft/world/entity/animal/horse/TraderLlama.java +@@ -67,6 +67,11 @@ public class TraderLlama extends Llama { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.traderLlamaTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.traderLlamaAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/animal/horse/ZombieHorse.java b/src/main/java/net/minecraft/world/entity/animal/horse/ZombieHorse.java +index 88da7a365c28e2d097d0a7bff30ea1acd4c7d5dc..74de599bfe2ee696848b3f74392b696fdbd42c5f 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/horse/ZombieHorse.java ++++ b/src/main/java/net/minecraft/world/entity/animal/horse/ZombieHorse.java +@@ -57,6 +57,11 @@ public class ZombieHorse extends AbstractHorse { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.zombieHorseTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.zombieHorseAlwaysDropExp; ++ } + // Purpur end + + public static AttributeSupplier.Builder createAttributes() { +diff --git a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java +index 1cab4c037c99babf4e35480de7ffc02be0c28583..f4ff9b299eef9029069ee0af6ae290b9a4d65465 100644 +--- a/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java ++++ b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java +@@ -233,6 +233,11 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob + public void setSummoner(@Nullable java.util.UUID summoner) { + this.summoner = summoner; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.witherAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Blaze.java b/src/main/java/net/minecraft/world/entity/monster/Blaze.java +index e9d540984b9bb7fab563b81f6d28aa85c90402e9..c253066d6c77e22b90605296ad1ca78235945c05 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Blaze.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Blaze.java +@@ -72,6 +72,11 @@ public class Blaze extends Monster { + public void initAttributes() { + this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.blazeMaxHealth); + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.blazeAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/CaveSpider.java b/src/main/java/net/minecraft/world/entity/monster/CaveSpider.java +index 58d11054bd62338a8b6959663420d286abcfd499..1ec0363cfb69df8ad19c9d37b7e5b3771b87c4e6 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/CaveSpider.java ++++ b/src/main/java/net/minecraft/world/entity/monster/CaveSpider.java +@@ -48,6 +48,11 @@ public class CaveSpider extends Spider { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.caveSpiderTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.caveSpiderAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Creeper.java b/src/main/java/net/minecraft/world/entity/monster/Creeper.java +index 35cbd013b1d58bb5fd1480922c2bd4307edfb6c3..2cfac37e9fdd4600da63071931f82110c9570e30 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Creeper.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Creeper.java +@@ -160,6 +160,11 @@ public class Creeper extends Monster implements PowerableMob { + } + return super.dropAllDeathLoot(damagesource); + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.creeperAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Drowned.java b/src/main/java/net/minecraft/world/entity/monster/Drowned.java +index a592fb29097232d5d9c6e6d946fb326fd901f27b..8c9ef5113e66d07c62e66a54c5a87b07793f5e3d 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Drowned.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Drowned.java +@@ -110,6 +110,11 @@ public class Drowned extends Zombie implements RangedAttackMob { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.drownedTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.drownedAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/ElderGuardian.java b/src/main/java/net/minecraft/world/entity/monster/ElderGuardian.java +index 0aa4d8e506462cfe6fb69414a30cc5eb441d7ad1..00dee17c95479ca93d8bfcc861ae1808ba189379 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/ElderGuardian.java ++++ b/src/main/java/net/minecraft/world/entity/monster/ElderGuardian.java +@@ -50,6 +50,11 @@ public class ElderGuardian extends Guardian { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.elderGuardianTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.elderGuardianAlwaysDropExp; ++ } + // Purpur end + + public static AttributeSupplier.Builder createAttributes() { +diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java +index 8923274fc04282cf97398b997603f699d92e6699..4e6b8f6afcbf4e84759a5ec07930717fb363613f 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java ++++ b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java +@@ -103,6 +103,11 @@ public class EnderMan extends Monster implements NeutralMob { + public void initAttributes() { + this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.endermanMaxHealth); + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.endermanAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Endermite.java b/src/main/java/net/minecraft/world/entity/monster/Endermite.java +index fce4cf14f5275d7e996db60dab83d4351cc08796..9187ad4c8647dba1c6bdddfbcd9a403314e8e612 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Endermite.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Endermite.java +@@ -65,6 +65,11 @@ public class Endermite extends Monster { + public void setPlayerSpawned(boolean playerSpawned) { + this.isPlayerSpawned = playerSpawned; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.endermiteAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Evoker.java b/src/main/java/net/minecraft/world/entity/monster/Evoker.java +index 1f5aa1980b49b36900d515dc57696a4bc22267d0..35739fb765aa5663f984727980c03d3621bfd7f9 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Evoker.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Evoker.java +@@ -67,6 +67,11 @@ public class Evoker extends SpellcasterIllager { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.evokerTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.evokerAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Ghast.java b/src/main/java/net/minecraft/world/entity/monster/Ghast.java +index 753227f5eb9c944e708aafb5247202aa5e4e729f..cad77f2fb10c5bb6840654d4d4a9c04bec7a69e7 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Ghast.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Ghast.java +@@ -81,6 +81,11 @@ public class Ghast extends FlyingMob implements Enemy { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.ghastTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.ghastAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Giant.java b/src/main/java/net/minecraft/world/entity/monster/Giant.java +index c2d39a4a4d0bddc38accd31772a2fd7926b6e08c..bd4595344cbe83e47d0373b0b060e80226630908 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Giant.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Giant.java +@@ -107,6 +107,11 @@ public class Giant extends Monster { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.giantTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.giantAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Guardian.java b/src/main/java/net/minecraft/world/entity/monster/Guardian.java +index 0675c018bbf4eb0947350737b41de4e56410520e..af22b186a8a8fc5713e59e07d84c3a69900c57d6 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Guardian.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Guardian.java +@@ -97,6 +97,11 @@ public class Guardian extends Monster { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.guardianTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.guardianAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Husk.java b/src/main/java/net/minecraft/world/entity/monster/Husk.java +index ca5683e9b0b4aad3827fe6d00198da8e5b6a69ec..dd7723ce39d3ec4178bf7ce25e5dcd2c487131ab 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Husk.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Husk.java +@@ -63,6 +63,11 @@ public class Husk extends Zombie { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.huskTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.huskAlwaysDropExp; ++ } + // Purpur end + + public static boolean checkHuskSpawnRules(EntityType type, ServerLevelAccessor world, MobSpawnType spawnReason, BlockPos pos, Random random) { +diff --git a/src/main/java/net/minecraft/world/entity/monster/Illusioner.java b/src/main/java/net/minecraft/world/entity/monster/Illusioner.java +index 322058dbb82888c70bf770bed58356dc07839188..e8cb4bd5081d1435ab1eeffe559f224dda23a560 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Illusioner.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Illusioner.java +@@ -81,6 +81,11 @@ public class Illusioner extends SpellcasterIllager implements RangedAttackMob { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.illusionerTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.illusionerAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/MagmaCube.java b/src/main/java/net/minecraft/world/entity/monster/MagmaCube.java +index cd6b136960b2c37c6e6d56c4e5f7fd302e49e5e7..9f555a02d2fec242953e5c2d12d68d6a2ff2a30f 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/MagmaCube.java ++++ b/src/main/java/net/minecraft/world/entity/monster/MagmaCube.java +@@ -57,6 +57,11 @@ public class MagmaCube extends Slime { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.magmaCubeTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.magmaCubeAlwaysDropExp; ++ } + // Purpur end + + public static AttributeSupplier.Builder createAttributes() { +diff --git a/src/main/java/net/minecraft/world/entity/monster/Phantom.java b/src/main/java/net/minecraft/world/entity/monster/Phantom.java +index 10b5c7f58f6f7248e9c97160faf7a52d57a797cf..a22e2ccec7bb9498e40f6cb42fb4a9dbdce21304 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Phantom.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Phantom.java +@@ -142,6 +142,11 @@ public class Phantom extends FlyingMob implements Enemy { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.phantomTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.phantomAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Pillager.java b/src/main/java/net/minecraft/world/entity/monster/Pillager.java +index 4c98060c8edcd58bcd957dee54ebba5d03b62546..fcbf94d9670f7572078a98c7fe122dd4f6301eeb 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Pillager.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Pillager.java +@@ -83,6 +83,11 @@ public class Pillager extends AbstractIllager implements CrossbowAttackMob, Inve + public boolean isSensitiveToWater() { + return this.level.purpurConfig.pillagerTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.pillagerAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Ravager.java b/src/main/java/net/minecraft/world/entity/monster/Ravager.java +index 83e835a63bc0a211b75db82f4f4eb28874eea9ec..5f093bb263f6a4d761f4c922b6a2b0f10e9c1ce4 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Ravager.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Ravager.java +@@ -95,6 +95,11 @@ public class Ravager extends Raider { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.ravagerTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.ravagerAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Shulker.java b/src/main/java/net/minecraft/world/entity/monster/Shulker.java +index e9f4a1de40ab4d7a82d4f222b4aba0aaaef05c88..1494420fb86d78b7e8accf16354003f85506b2ff 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Shulker.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Shulker.java +@@ -129,6 +129,11 @@ public class Shulker extends AbstractGolem implements Enemy { + } + return super.mobInteract(player, hand); + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.shulkerAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Silverfish.java b/src/main/java/net/minecraft/world/entity/monster/Silverfish.java +index 2b77a73c0042a40fcc464dd878a3b9114138b3ff..bb23b232d6b9a950adaf87f83448059d845bf72e 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Silverfish.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Silverfish.java +@@ -61,6 +61,11 @@ public class Silverfish extends Monster { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.silverfishTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.silverfishAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Skeleton.java b/src/main/java/net/minecraft/world/entity/monster/Skeleton.java +index 2cf7a67e5294099154f8acaa897f12e8d2f46e77..3c5231406ddd0ff5343f3e4da93ecefad614c895 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Skeleton.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Skeleton.java +@@ -45,6 +45,11 @@ public class Skeleton extends AbstractSkeleton { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.skeletonTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.skeletonAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Slime.java b/src/main/java/net/minecraft/world/entity/monster/Slime.java +index d49ba154d173aa7bf5a679b7bfcc55de851ea34b..641d6e58a1b84c7abc4b9e6c76c35cbe51aeba4d 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Slime.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Slime.java +@@ -130,6 +130,11 @@ public class Slime extends Mob implements Enemy { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.slimeTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.slimeAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Spider.java b/src/main/java/net/minecraft/world/entity/monster/Spider.java +index be6b7c91990c133f8ca1c9747f64119829888bbb..f85daf21ae3d77d2d56c131c6df9aa0715a306ca 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Spider.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Spider.java +@@ -71,6 +71,11 @@ public class Spider extends Monster { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.spiderTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.spiderAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Stray.java b/src/main/java/net/minecraft/world/entity/monster/Stray.java +index 9c556ee62a0eb09629d80dc5fc70347696dacd66..011d5e46fdd88c10bfbc0d54cf8016805d300703 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Stray.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Stray.java +@@ -41,6 +41,11 @@ public class Stray extends AbstractSkeleton { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.strayTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.strayAlwaysDropExp; ++ } + // Purpur end + + public static boolean checkStraySpawnRules(EntityType type, ServerLevelAccessor world, MobSpawnType spawnReason, BlockPos pos, Random random) { +diff --git a/src/main/java/net/minecraft/world/entity/monster/Strider.java b/src/main/java/net/minecraft/world/entity/monster/Strider.java +index 400afd587c6f9f52adf8d575d54b8dbe515b3144..01fc2567898f2c0f3b662ce1abf4d3829e76954a 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Strider.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Strider.java +@@ -117,6 +117,11 @@ public class Strider extends Animal implements ItemSteerable, Saddleable { + public int getPurpurBreedTime() { + return this.level.purpurConfig.striderBreedingTicks; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.striderAlwaysDropExp; ++ } + // Purpur end + + public static boolean checkStriderSpawnRules(EntityType type, LevelAccessor world, MobSpawnType spawnReason, BlockPos pos, Random random) { +diff --git a/src/main/java/net/minecraft/world/entity/monster/Vex.java b/src/main/java/net/minecraft/world/entity/monster/Vex.java +index 1606f15ee56383533b3e2bfca9cf00b63c7c474a..6b450486e50d95a65b3ef8d0521d14e391e63046 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Vex.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Vex.java +@@ -105,6 +105,11 @@ public class Vex extends Monster { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.vexTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.vexAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Vindicator.java b/src/main/java/net/minecraft/world/entity/monster/Vindicator.java +index 626784961ac0ee2de987ee8e5a996683960ff878..fe9acbae2ddf69c97582d283fa3d8a266298df3f 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Vindicator.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Vindicator.java +@@ -78,6 +78,11 @@ public class Vindicator extends AbstractIllager { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.vindicatorTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.vindicatorAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Witch.java b/src/main/java/net/minecraft/world/entity/monster/Witch.java +index 263009d0d69e26b7eab6d387c67590511c9b8ff6..2f99cf8b232ea7f6000cf2897826fc18987b85ac 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Witch.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Witch.java +@@ -79,6 +79,11 @@ public class Witch extends Raider implements RangedAttackMob { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.witchTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.witchAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/WitherSkeleton.java b/src/main/java/net/minecraft/world/entity/monster/WitherSkeleton.java +index 2aa2d0cd277be59a99c3cd52f5265409913f359e..4368d7f1fd2517c5308247b17eb1b7f4e1151b80 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/WitherSkeleton.java ++++ b/src/main/java/net/minecraft/world/entity/monster/WitherSkeleton.java +@@ -54,6 +54,11 @@ public class WitherSkeleton extends AbstractSkeleton { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.witherSkeletonTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.witherSkeletonAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Zoglin.java b/src/main/java/net/minecraft/world/entity/monster/Zoglin.java +index f96d891eeae384a210a7399a605d5d9cb0e3e591..cee685bf0d842ae0600aab2e1e4e372de3e9316d 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Zoglin.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Zoglin.java +@@ -88,6 +88,11 @@ public class Zoglin extends Monster implements Enemy, HoglinBase { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.zoglinTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.zoglinAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/Zombie.java b/src/main/java/net/minecraft/world/entity/monster/Zombie.java +index cb5a04aacf5e9f0f024f3a1c3a38dd88b49d86ee..29cc16f135b15c87345181263d1ff175311533ec 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/Zombie.java ++++ b/src/main/java/net/minecraft/world/entity/monster/Zombie.java +@@ -137,6 +137,11 @@ public class Zombie extends Monster { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.zombieTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.zombieAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java b/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java +index 22a5d2f0de4bdd4432d1beff840f448a30985188..d40fc6b38ca9b58ed1b0d9a2ed61f9a4f2a8be63 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java ++++ b/src/main/java/net/minecraft/world/entity/monster/ZombieVillager.java +@@ -115,6 +115,11 @@ public class ZombieVillager extends Zombie implements VillagerDataHolder { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.zombieVillagerTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.zombieVillagerAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/ZombifiedPiglin.java b/src/main/java/net/minecraft/world/entity/monster/ZombifiedPiglin.java +index fd2828469badbc7936ea68c0bdd8d689c86146b6..3288e9bd8e9758d9f5137614aedd0fc73f1a3ea0 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/ZombifiedPiglin.java ++++ b/src/main/java/net/minecraft/world/entity/monster/ZombifiedPiglin.java +@@ -94,6 +94,11 @@ public class ZombifiedPiglin extends Zombie implements NeutralMob { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.zombifiedPiglinTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.zombifiedPiglinAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java +index 866665186e7dd20a00a635d4675da2e7ac57ae91..170b48953a4bf494d92ded572f27711fc50a2723 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java ++++ b/src/main/java/net/minecraft/world/entity/monster/hoglin/Hoglin.java +@@ -92,6 +92,11 @@ public class Hoglin extends Animal implements Enemy, HoglinBase { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.hoglinTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.hoglinAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java +index 825a2fe1eac36812744b134be76798d8ae3d0bbf..aa1ea4c7c2de1c148ebcd569130c48bb8d3a4287 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java ++++ b/src/main/java/net/minecraft/world/entity/monster/piglin/Piglin.java +@@ -116,6 +116,11 @@ public class Piglin extends AbstractPiglin implements CrossbowAttackMob, Invento + public boolean isSensitiveToWater() { + return this.level.purpurConfig.piglinTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.piglinAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinBrute.java b/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinBrute.java +index d3a298734e4434d29b66e94fc6c299d34e0ad432..eb194daac43571a5eb6282c1465a695d4a040e21 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinBrute.java ++++ b/src/main/java/net/minecraft/world/entity/monster/piglin/PiglinBrute.java +@@ -60,6 +60,11 @@ public class PiglinBrute extends AbstractPiglin { + public boolean isSensitiveToWater() { + return this.level.purpurConfig.piglinBruteTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.piglinBruteAlwaysDropExp; ++ } + // Purpur end + + public static AttributeSupplier.Builder createAttributes() { +diff --git a/src/main/java/net/minecraft/world/entity/npc/Villager.java b/src/main/java/net/minecraft/world/entity/npc/Villager.java +index e95210c6deee2c6431ef01d23953174465f199e0..efb98dd788b5b8ce51c92847c585e5ee9c0465f3 100644 +--- a/src/main/java/net/minecraft/world/entity/npc/Villager.java ++++ b/src/main/java/net/minecraft/world/entity/npc/Villager.java +@@ -184,6 +184,11 @@ public class Villager extends AbstractVillager implements ReputationEventHandler + public boolean isSensitiveToWater() { + return this.level.purpurConfig.villagerTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.villagerAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java +index 1a8df13b06b1ac5e5a7d63033b4a53261c779eda..8be025b735cea47ab3ce6c6b2aef052ef3e5cab0 100644 +--- a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java ++++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java +@@ -92,6 +92,11 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill + public boolean isSensitiveToWater() { + return this.level.purpurConfig.wanderingTraderTakeDamageFromWater; + } ++ ++ @Override ++ protected boolean isAlwaysExperienceDropper() { ++ return this.level.purpurConfig.wanderingTraderAlwaysDropExp; ++ } + // Purpur end + + @Override +diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +index 8d5525c7b7b867360d6e0b4222e8c2452790d994..f4dca5581c8d15963fd6d2cfa926737b92ed86b3 100644 +--- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java ++++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +@@ -999,11 +999,13 @@ public class PurpurWorldConfig { + public boolean axolotlRidable = false; + public double axolotlMaxHealth = 14.0D; + public int axolotlBreedingTicks = 6000; ++ public boolean axolotlAlwaysDropExp = false; + private void axolotlSettings() { + axolotlRidable = getBoolean("mobs.axolotl.ridable", axolotlRidable); + axolotlMaxHealth = getDouble("mobs.axolotl.attributes.max_health", axolotlMaxHealth); + axolotlBreedingTicks = getInt("mobs.axolotl.breeding-delay-ticks", axolotlBreedingTicks); + axolotlTakeDamageFromWater = getBoolean("mobs.axolotl.takes-damage-from-water", axolotlTakeDamageFromWater); ++ axolotlAlwaysDropExp = getBoolean("mobs.axolotl.always-drop-exp", axolotlAlwaysDropExp); + } + + public boolean batRidable = false; +@@ -1018,6 +1020,7 @@ public class PurpurWorldConfig { + public double batArmorToughness = 0.0D; + public double batAttackKnockback = 0.0D; + public boolean batTakeDamageFromWater = false; ++ public boolean batAlwaysDropExp = false; + private void batSettings() { + batRidable = getBoolean("mobs.bat.ridable", batRidable); + batRidableInWater = getBoolean("mobs.bat.ridable-in-water", batRidableInWater); +@@ -1029,6 +1032,7 @@ public class PurpurWorldConfig { + } + batMaxHealth = getDouble("mobs.bat.attributes.max_health", batMaxHealth); + batTakeDamageFromWater = getBoolean("mobs.bat.takes-damage-from-water", batTakeDamageFromWater); ++ batAlwaysDropExp = getBoolean("mobs.bat.always-drop-exp", batAlwaysDropExp); + } + + public boolean beeRidable = false; +@@ -1039,6 +1043,7 @@ public class PurpurWorldConfig { + public boolean beeTakeDamageFromWater = false; + public boolean beeCanWorkAtNight = false; + public boolean beeCanWorkInRain = false; ++ public boolean beeAlwaysDropExp = false; + private void beeSettings() { + beeRidable = getBoolean("mobs.bee.ridable", beeRidable); + beeRidableInWater = getBoolean("mobs.bee.ridable-in-water", beeRidableInWater); +@@ -1053,6 +1058,7 @@ public class PurpurWorldConfig { + beeTakeDamageFromWater = getBoolean("mobs.bee.takes-damage-from-water", beeTakeDamageFromWater); + beeCanWorkAtNight = getBoolean("mobs.bee.can-work-at-night", beeCanWorkAtNight); + beeCanWorkInRain = getBoolean("mobs.bee.can-work-in-rain", beeCanWorkInRain); ++ beeAlwaysDropExp = getBoolean("mobs.bee.always-drop-exp", beeAlwaysDropExp); + } + + public boolean blazeRidable = false; +@@ -1060,6 +1066,7 @@ public class PurpurWorldConfig { + public double blazeMaxY = 256D; + public double blazeMaxHealth = 20.0D; + public boolean blazeTakeDamageFromWater = true; ++ public boolean blazeAlwaysDropExp = false; + private void blazeSettings() { + blazeRidable = getBoolean("mobs.blaze.ridable", blazeRidable); + blazeRidableInWater = getBoolean("mobs.blaze.ridable-in-water", blazeRidableInWater); +@@ -1071,6 +1078,7 @@ public class PurpurWorldConfig { + } + blazeMaxHealth = getDouble("mobs.blaze.attributes.max_health", blazeMaxHealth); + blazeTakeDamageFromWater = getBoolean("mobs.blaze.takes-damage-from-water", blazeTakeDamageFromWater); ++ blazeAlwaysDropExp = getBoolean("mobs.blaze.always-drop-exp", blazeAlwaysDropExp); + } + + public boolean catRidable = false; +@@ -1082,6 +1090,7 @@ public class PurpurWorldConfig { + public int catSpawnVillageScanRange = 48; + public int catBreedingTicks = 6000; + public boolean catTakeDamageFromWater = false; ++ public boolean catAlwaysDropExp = false; + private void catSettings() { + catRidable = getBoolean("mobs.cat.ridable", catRidable); + catRidableInWater = getBoolean("mobs.cat.ridable-in-water", catRidableInWater); +@@ -1101,12 +1110,14 @@ public class PurpurWorldConfig { + catSpawnVillageScanRange = getInt("mobs.cat.scan-range-for-other-cats.village", catSpawnVillageScanRange); + catBreedingTicks = getInt("mobs.cat.breeding-delay-ticks", catBreedingTicks); + catTakeDamageFromWater = getBoolean("mobs.cat.takes-damage-from-water", catTakeDamageFromWater); ++ catAlwaysDropExp = getBoolean("mobs.cat.always-drop-exp", catAlwaysDropExp); + } + + public boolean caveSpiderRidable = false; + public boolean caveSpiderRidableInWater = false; + public double caveSpiderMaxHealth = 12.0D; + public boolean caveSpiderTakeDamageFromWater = false; ++ public boolean caveSpiderAlwaysDropExp = false; + private void caveSpiderSettings() { + caveSpiderRidable = getBoolean("mobs.cave_spider.ridable", caveSpiderRidable); + caveSpiderRidableInWater = getBoolean("mobs.cave_spider.ridable-in-water", caveSpiderRidableInWater); +@@ -1117,6 +1128,7 @@ public class PurpurWorldConfig { + } + caveSpiderMaxHealth = getDouble("mobs.cave_spider.attributes.max_health", caveSpiderMaxHealth); + caveSpiderTakeDamageFromWater = getBoolean("mobs.cave_spider.takes-damage-from-water", caveSpiderTakeDamageFromWater); ++ caveSpiderAlwaysDropExp = getBoolean("mobs.cave_spider.always-drop-exp", caveSpiderAlwaysDropExp); + } + + public boolean chickenRidable = false; +@@ -1125,6 +1137,7 @@ public class PurpurWorldConfig { + public boolean chickenRetaliate = false; + public int chickenBreedingTicks = 6000; + public boolean chickenTakeDamageFromWater = false; ++ public boolean chickenAlwaysDropExp = false; + private void chickenSettings() { + chickenRidable = getBoolean("mobs.chicken.ridable", chickenRidable); + chickenRidableInWater = getBoolean("mobs.chicken.ridable-in-water", chickenRidableInWater); +@@ -1137,11 +1150,13 @@ public class PurpurWorldConfig { + chickenRetaliate = getBoolean("mobs.chicken.retaliate", chickenRetaliate); + chickenBreedingTicks = getInt("mobs.chicken.breeding-delay-ticks", chickenBreedingTicks); + chickenTakeDamageFromWater = getBoolean("mobs.chicken.takes-damage-from-water", chickenTakeDamageFromWater); ++ chickenAlwaysDropExp = getBoolean("mobs.chicken.always-drop-exp", chickenAlwaysDropExp); + } + + public boolean codRidable = false; + public double codMaxHealth = 3.0D; + public boolean codTakeDamageFromWater = false; ++ public boolean codAlwaysDropExp = false; + private void codSettings() { + codRidable = getBoolean("mobs.cod.ridable", codRidable); + if (PurpurConfig.version < 10) { +@@ -1151,6 +1166,7 @@ public class PurpurWorldConfig { + } + codMaxHealth = getDouble("mobs.cod.attributes.max_health", codMaxHealth); + codTakeDamageFromWater = getBoolean("mobs.cod.takes-damage-from-water", codTakeDamageFromWater); ++ codAlwaysDropExp = getBoolean("mobs.cod.always-drop-exp", codAlwaysDropExp); + } + + public boolean cowRidable = false; +@@ -1161,6 +1177,7 @@ public class PurpurWorldConfig { + public boolean cowTakeDamageFromWater = false; + public double cowNaturallyAggressiveToPlayersChance = 0.0D; + public double cowNaturallyAggressiveToPlayersDamage = 2.0D; ++ public boolean cowAlwaysDropExp = false; + private void cowSettings() { + if (PurpurConfig.version < 22) { + double oldValue = getDouble("mobs.cow.naturally-aggressive-to-players-chance", cowNaturallyAggressiveToPlayersChance); +@@ -1180,6 +1197,7 @@ public class PurpurWorldConfig { + cowTakeDamageFromWater = getBoolean("mobs.cow.takes-damage-from-water", cowTakeDamageFromWater); + cowNaturallyAggressiveToPlayersChance = getDouble("mobs.cow.naturally-aggressive-to-players.chance", cowNaturallyAggressiveToPlayersChance); + cowNaturallyAggressiveToPlayersDamage = getDouble("mobs.cow.naturally-aggressive-to-players.damage", cowNaturallyAggressiveToPlayersDamage); ++ cowAlwaysDropExp = getBoolean("mobs.cow.always-drop-exp", cowAlwaysDropExp); + } + + public boolean creeperRidable = false; +@@ -1191,6 +1209,7 @@ public class PurpurWorldConfig { + public boolean creeperTakeDamageFromWater = false; + public boolean creeperExplodeWhenKilled = false; + public boolean creeperHealthRadius = false; ++ public boolean creeperAlwaysDropExp = false; + private void creeperSettings() { + creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable); + creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater); +@@ -1206,6 +1225,7 @@ public class PurpurWorldConfig { + creeperTakeDamageFromWater = getBoolean("mobs.creeper.takes-damage-from-water", creeperTakeDamageFromWater); + creeperExplodeWhenKilled = getBoolean("mobs.creeper.explode-when-killed", creeperExplodeWhenKilled); + creeperHealthRadius = getBoolean("mobs.creeper.health-impacts-explosion", creeperHealthRadius); ++ creeperAlwaysDropExp = getBoolean("mobs.creeper.always-drop-exp", creeperAlwaysDropExp); + } + + public boolean dolphinRidable = false; +@@ -1216,6 +1236,7 @@ public class PurpurWorldConfig { + public boolean dolphinDisableTreasureSearching = false; + public boolean dolphinTakeDamageFromWater = false; + public double dolphinNaturallyAggressiveToPlayersChance = 0.0D; ++ public boolean dolphinAlwaysDropExp = false; + private void dolphinSettings() { + dolphinRidable = getBoolean("mobs.dolphin.ridable", dolphinRidable); + dolphinSpitCooldown = getInt("mobs.dolphin.spit.cooldown", dolphinSpitCooldown); +@@ -1230,6 +1251,7 @@ public class PurpurWorldConfig { + dolphinDisableTreasureSearching = getBoolean("mobs.dolphin.disable-treasure-searching", dolphinDisableTreasureSearching); + dolphinTakeDamageFromWater = getBoolean("mobs.dolphin.takes-damage-from-water", dolphinTakeDamageFromWater); + dolphinNaturallyAggressiveToPlayersChance = getDouble("mobs.dolphin.naturally-aggressive-to-players-chance", dolphinNaturallyAggressiveToPlayersChance); ++ dolphinAlwaysDropExp = getBoolean("mobs.dolphin.always-drop-exp", dolphinAlwaysDropExp); + } + + public boolean donkeyRidableInWater = false; +@@ -1241,6 +1263,7 @@ public class PurpurWorldConfig { + public double donkeyMovementSpeedMax = 0.175D; + public int donkeyBreedingTicks = 6000; + public boolean donkeyTakeDamageFromWater = false; ++ public boolean donkeyAlwaysDropExp = false; + private void donkeySettings() { + donkeyRidableInWater = getBoolean("mobs.donkey.ridable-in-water", donkeyRidableInWater); + if (PurpurConfig.version < 10) { +@@ -1258,6 +1281,7 @@ public class PurpurWorldConfig { + 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); ++ donkeyAlwaysDropExp = getBoolean("mobs.donkey.always-drop-exp", donkeyAlwaysDropExp); + } + + public boolean drownedRidable = false; +@@ -1269,6 +1293,7 @@ public class PurpurWorldConfig { + public boolean drownedJockeyTryExistingChickens = true; + public boolean drownedTakeDamageFromWater = false; + public boolean drownedBreakDoors = false; ++ public boolean drownedAlwaysDropExp = false; + private void drownedSettings() { + drownedRidable = getBoolean("mobs.drowned.ridable", drownedRidable); + drownedRidableInWater = getBoolean("mobs.drowned.ridable-in-water", drownedRidableInWater); +@@ -1284,11 +1309,13 @@ public class PurpurWorldConfig { + drownedJockeyTryExistingChickens = getBoolean("mobs.drowned.jockey.try-existing-chickens", drownedJockeyTryExistingChickens); + drownedTakeDamageFromWater = getBoolean("mobs.drowned.takes-damage-from-water", drownedTakeDamageFromWater); + drownedBreakDoors = getBoolean("mobs.drowned.can-break-doors", drownedBreakDoors); ++ drownedAlwaysDropExp = getBoolean("mobs.drowned.always-drop-exp", drownedAlwaysDropExp); + } + + public boolean elderGuardianRidable = false; + public double elderGuardianMaxHealth = 80.0D; + public boolean elderGuardianTakeDamageFromWater = false; ++ public boolean elderGuardianAlwaysDropExp = false; + private void elderGuardianSettings() { + elderGuardianRidable = getBoolean("mobs.elder_guardian.ridable", elderGuardianRidable); + if (PurpurConfig.version < 10) { +@@ -1298,6 +1325,7 @@ public class PurpurWorldConfig { + } + elderGuardianMaxHealth = getDouble("mobs.elder_guardian.attributes.max_health", elderGuardianMaxHealth); + elderGuardianTakeDamageFromWater = getBoolean("mobs.elder_guardian.takes-damage-from-water", elderGuardianTakeDamageFromWater); ++ elderGuardianAlwaysDropExp = getBoolean("mobs.elder_guardian.always-drop-exp", elderGuardianAlwaysDropExp); + } + + public boolean enderDragonRidable = false; +@@ -1340,6 +1368,7 @@ public class PurpurWorldConfig { + public boolean endermanIgnorePlayerDragonHead = false; + public boolean endermanDisableStareAggro = false; + public boolean endermanIgnoreProjectiles = false; ++ public boolean endermanAlwaysDropExp = false; + private void endermanSettings() { + endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable); + endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater); +@@ -1362,12 +1391,14 @@ public class PurpurWorldConfig { + endermanIgnorePlayerDragonHead = getBoolean("mobs.enderman.ignore-players-wearing-dragon-head", endermanIgnorePlayerDragonHead); + endermanDisableStareAggro = getBoolean("mobs.enderman.disable-player-stare-aggression", endermanDisableStareAggro); + endermanIgnoreProjectiles = getBoolean("mobs.enderman.ignore-projectiles", endermanIgnoreProjectiles); ++ endermanAlwaysDropExp = getBoolean("mobs.enderman.always-drop-exp", endermanAlwaysDropExp); + } + + public boolean endermiteRidable = false; + public boolean endermiteRidableInWater = false; + public double endermiteMaxHealth = 8.0D; + public boolean endermiteTakeDamageFromWater = false; ++ public boolean endermiteAlwaysDropExp = false; + private void endermiteSettings() { + endermiteRidable = getBoolean("mobs.endermite.ridable", endermiteRidable); + endermiteRidableInWater = getBoolean("mobs.endermite.ridable-in-water", endermiteRidableInWater); +@@ -1378,6 +1409,7 @@ public class PurpurWorldConfig { + } + endermiteMaxHealth = getDouble("mobs.endermite.attributes.max_health", endermiteMaxHealth); + endermiteTakeDamageFromWater = getBoolean("mobs.endermite.takes-damage-from-water", endermiteTakeDamageFromWater); ++ endermiteAlwaysDropExp = getBoolean("mobs.endermite.always-drop-exp", endermiteAlwaysDropExp); + } + + public boolean evokerRidable = false; +@@ -1385,6 +1417,7 @@ public class PurpurWorldConfig { + public double evokerMaxHealth = 24.0D; + public boolean evokerBypassMobGriefing = false; + public boolean evokerTakeDamageFromWater = false; ++ public boolean evokerAlwaysDropExp = false; + private void evokerSettings() { + evokerRidable = getBoolean("mobs.evoker.ridable", evokerRidable); + evokerRidableInWater = getBoolean("mobs.evoker.ridable-in-water", evokerRidableInWater); +@@ -1396,6 +1429,7 @@ public class PurpurWorldConfig { + evokerMaxHealth = getDouble("mobs.evoker.attributes.max_health", evokerMaxHealth); + evokerBypassMobGriefing = getBoolean("mobs.evoker.bypass-mob-griefing", evokerBypassMobGriefing); + evokerTakeDamageFromWater = getBoolean("mobs.evoker.takes-damage-from-water", evokerTakeDamageFromWater); ++ evokerAlwaysDropExp = getBoolean("mobs.evoker.always-drop-exp", evokerAlwaysDropExp); + } + + public boolean foxRidable = false; +@@ -1405,6 +1439,7 @@ public class PurpurWorldConfig { + public int foxBreedingTicks = 6000; + public boolean foxBypassMobGriefing = false; + public boolean foxTakeDamageFromWater = false; ++ public boolean foxAlwaysDropExp = false; + private void foxSettings() { + foxRidable = getBoolean("mobs.fox.ridable", foxRidable); + foxRidableInWater = getBoolean("mobs.fox.ridable-in-water", foxRidableInWater); +@@ -1418,6 +1453,7 @@ public class PurpurWorldConfig { + 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); ++ foxAlwaysDropExp = getBoolean("mobs.fox.always-drop-exp", foxAlwaysDropExp); + } + + public boolean ghastRidable = false; +@@ -1425,6 +1461,7 @@ public class PurpurWorldConfig { + public double ghastMaxY = 256D; + public double ghastMaxHealth = 10.0D; + public boolean ghastTakeDamageFromWater = false; ++ public boolean ghastAlwaysDropExp = false; + private void ghastSettings() { + ghastRidable = getBoolean("mobs.ghast.ridable", ghastRidable); + ghastRidableInWater = getBoolean("mobs.ghast.ridable-in-water", ghastRidableInWater); +@@ -1436,6 +1473,7 @@ public class PurpurWorldConfig { + } + ghastMaxHealth = getDouble("mobs.ghast.attributes.max_health", ghastMaxHealth); + ghastTakeDamageFromWater = getBoolean("mobs.ghast.takes-damage-from-water", ghastTakeDamageFromWater); ++ ghastAlwaysDropExp = getBoolean("mobs.ghast.always-drop-exp", ghastAlwaysDropExp); + } + + public boolean giantRidable = false; +@@ -1448,6 +1486,7 @@ public class PurpurWorldConfig { + public boolean giantHaveAI = false; + public boolean giantHaveHostileAI = false; + public boolean giantTakeDamageFromWater = false; ++ public boolean giantAlwaysDropExp = false; + private void giantSettings() { + giantRidable = getBoolean("mobs.giant.ridable", giantRidable); + giantRidableInWater = getBoolean("mobs.giant.ridable-in-water", giantRidableInWater); +@@ -1468,17 +1507,20 @@ public class PurpurWorldConfig { + giantHaveAI = getBoolean("mobs.giant.have-ai", giantHaveAI); + giantHaveHostileAI = getBoolean("mobs.giant.have-hostile-ai", giantHaveHostileAI); + giantTakeDamageFromWater = getBoolean("mobs.giant.takes-damage-from-water", giantTakeDamageFromWater); ++ giantAlwaysDropExp = getBoolean("mobs.giant.always-drop-exp", giantAlwaysDropExp); + } + + public boolean glowSquidRidable = false; + public double glowSquidMaxHealth = 10.0D; + public boolean glowSquidsCanFly = false; + public boolean glowSquidTakeDamageFromWater = false; ++ public boolean glowSquidAlwaysDropExp = false; + private void glowSquidSettings() { + glowSquidRidable = getBoolean("mobs.glow_squid.ridable", glowSquidRidable); + glowSquidMaxHealth = getDouble("mobs.glow_squid.attributes.max_health", glowSquidMaxHealth); + glowSquidsCanFly = getBoolean("mobs.glow_squid.can-fly", glowSquidsCanFly); + glowSquidTakeDamageFromWater = getBoolean("mobs.glow_squid.takes-damage-from-water", glowSquidTakeDamageFromWater); ++ glowSquidAlwaysDropExp = getBoolean("mobs.glow_squid.always-drop-exp", glowSquidAlwaysDropExp); + } + + public boolean goatRidable = false; +@@ -1486,17 +1528,20 @@ public class PurpurWorldConfig { + public double goatMaxHealth = 10.0D; + public int goatBreedingTicks = 6000; + public boolean goatTakeDamageFromWater = false; ++ public boolean goatAlwaysDropExp = false; + private void goatSettings() { + goatRidable = getBoolean("mobs.goat.ridable", goatRidable); + goatRidableInWater = getBoolean("mobs.goat.ridable-in-water", goatRidableInWater); + goatMaxHealth = getDouble("mobs.goat.attributes.max_health", goatMaxHealth); + goatBreedingTicks = getInt("mobs.goat.breeding-delay-ticks", goatBreedingTicks); + goatTakeDamageFromWater = getBoolean("mobs.goat.takes-damage-from-water", goatTakeDamageFromWater); ++ goatAlwaysDropExp = getBoolean("mobs.goat.always-drop-exp", goatAlwaysDropExp); + } + + public boolean guardianRidable = false; + public double guardianMaxHealth = 30.0D; + public boolean guardianTakeDamageFromWater = false; ++ public boolean guardianAlwaysDropExp = false; + private void guardianSettings() { + guardianRidable = getBoolean("mobs.guardian.ridable", guardianRidable); + if (PurpurConfig.version < 10) { +@@ -1506,6 +1551,7 @@ public class PurpurWorldConfig { + } + guardianMaxHealth = getDouble("mobs.guardian.attributes.max_health", guardianMaxHealth); + guardianTakeDamageFromWater = getBoolean("mobs.guardian.takes-damage-from-water", guardianTakeDamageFromWater); ++ guardianAlwaysDropExp = getBoolean("mobs.guardian.always-drop-exp", guardianAlwaysDropExp); + } + + public boolean forceHalloweenSeason = false; +@@ -1520,6 +1566,7 @@ public class PurpurWorldConfig { + public double hoglinMaxHealth = 40.0D; + public int hoglinBreedingTicks = 6000; + public boolean hoglinTakeDamageFromWater = false; ++ public boolean hoglinAlwaysDropExp = false; + private void hoglinSettings() { + hoglinRidable = getBoolean("mobs.hoglin.ridable", hoglinRidable); + hoglinRidableInWater = getBoolean("mobs.hoglin.ridable-in-water", hoglinRidableInWater); +@@ -1531,6 +1578,7 @@ public class PurpurWorldConfig { + hoglinMaxHealth = getDouble("mobs.hoglin.attributes.max_health", hoglinMaxHealth); + hoglinBreedingTicks = getInt("mobs.hoglin.breeding-delay-ticks", hoglinBreedingTicks); + hoglinTakeDamageFromWater = getBoolean("mobs.hoglin.takes-damage-from-water", hoglinTakeDamageFromWater); ++ hoglinAlwaysDropExp = getBoolean("mobs.hoglin.always-drop-exp", hoglinAlwaysDropExp); + } + + public boolean horseRidableInWater = false; +@@ -1543,6 +1591,7 @@ public class PurpurWorldConfig { + public int horseBreedingTicks = 6000; + public boolean horseTakeDamageFromWater = false; + public boolean horseStandWithRider = true; ++ public boolean horseAlwaysDropExp = false; + private void horseSettings() { + horseRidableInWater = getBoolean("mobs.horse.ridable-in-water", horseRidableInWater); + if (PurpurConfig.version < 10) { +@@ -1561,6 +1610,7 @@ public class PurpurWorldConfig { + horseBreedingTicks = getInt("mobs.horse.breeding-delay-ticks", horseBreedingTicks); + horseTakeDamageFromWater = getBoolean("mobs.horse.takes-damage-from-water", horseTakeDamageFromWater); + horseStandWithRider = getBoolean("mobs.horse.stand-with-rider", horseStandWithRider); ++ horseAlwaysDropExp = getBoolean("mobs.horse.always-drop-exp", horseAlwaysDropExp); + } + + public boolean huskRidable = false; +@@ -1571,6 +1621,7 @@ public class PurpurWorldConfig { + public double huskJockeyChance = 0.05D; + public boolean huskJockeyTryExistingChickens = true; + public boolean huskTakeDamageFromWater = false; ++ public boolean huskAlwaysDropExp = false; + private void huskSettings() { + huskRidable = getBoolean("mobs.husk.ridable", huskRidable); + huskRidableInWater = getBoolean("mobs.husk.ridable-in-water", huskRidableInWater); +@@ -1585,6 +1636,7 @@ public class PurpurWorldConfig { + 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); ++ huskAlwaysDropExp = getBoolean("mobs.husk.always-drop-exp", huskAlwaysDropExp); + } + + public boolean illusionerRidable = false; +@@ -1593,6 +1645,7 @@ public class PurpurWorldConfig { + public double illusionerFollowRange = 18.0D; + public double illusionerMaxHealth = 32.0D; + public boolean illusionerTakeDamageFromWater = false; ++ public boolean illusionerAlwaysDropExp = false; + private void illusionerSettings() { + illusionerRidable = getBoolean("mobs.illusioner.ridable", illusionerRidable); + illusionerRidableInWater = getBoolean("mobs.illusioner.ridable-in-water", illusionerRidableInWater); +@@ -1609,6 +1662,7 @@ public class PurpurWorldConfig { + } + illusionerMaxHealth = getDouble("mobs.illusioner.attributes.max_health", illusionerMaxHealth); + illusionerTakeDamageFromWater = getBoolean("mobs.illusioner.takes-damage-from-water", illusionerTakeDamageFromWater); ++ illusionerAlwaysDropExp = getBoolean("mobs.illusioner.always-drop-exp", illusionerAlwaysDropExp); + } + + public boolean ironGolemRidable = false; +@@ -1617,6 +1671,7 @@ public class PurpurWorldConfig { + public double ironGolemMaxHealth = 100.0D; + public boolean ironGolemTakeDamageFromWater = false; + public boolean ironGolemPoppyCalm = false; ++ public boolean ironGolemAlwaysDropExp = false; + private void ironGolemSettings() { + ironGolemRidable = getBoolean("mobs.iron_golem.ridable", ironGolemRidable); + ironGolemRidableInWater = getBoolean("mobs.iron_golem.ridable-in-water", ironGolemRidableInWater); +@@ -1629,6 +1684,7 @@ public class PurpurWorldConfig { + ironGolemMaxHealth = getDouble("mobs.iron_golem.attributes.max_health", ironGolemMaxHealth); + ironGolemTakeDamageFromWater = getBoolean("mobs.iron_golem.takes-damage-from-water", ironGolemTakeDamageFromWater); + ironGolemPoppyCalm = getBoolean("mobs.iron_golem.poppy-calms-anger", ironGolemPoppyCalm); ++ ironGolemAlwaysDropExp = getBoolean("mobs.iron_golem.always-drop-exp", ironGolemAlwaysDropExp); + } + + public boolean llamaRidable = false; +@@ -1642,6 +1698,7 @@ public class PurpurWorldConfig { + public int llamaBreedingTicks = 6000; + public boolean llamaTakeDamageFromWater = false; + public boolean llamaJoinCaravans = true; ++ public boolean llamaAlwaysDropExp = false; + private void llamaSettings() { + llamaRidable = getBoolean("mobs.llama.ridable", llamaRidable); + llamaRidableInWater = getBoolean("mobs.llama.ridable-in-water", llamaRidableInWater); +@@ -1661,12 +1718,14 @@ public class PurpurWorldConfig { + llamaBreedingTicks = getInt("mobs.llama.breeding-delay-ticks", llamaBreedingTicks); + llamaTakeDamageFromWater = getBoolean("mobs.llama.takes-damage-from-water", llamaTakeDamageFromWater); + llamaJoinCaravans = getBoolean("mobs.llama.join-caravans", llamaJoinCaravans); ++ llamaAlwaysDropExp = getBoolean("mobs.llama.always-drop-exp", llamaAlwaysDropExp); + } + + public boolean magmaCubeRidable = false; + public boolean magmaCubeRidableInWater = false; + public String magmaCubeMaxHealth = "size * size"; + public boolean magmaCubeTakeDamageFromWater = false; ++ public boolean magmaCubeAlwaysDropExp = false; + private void magmaCubeSettings() { + magmaCubeRidable = getBoolean("mobs.magma_cube.ridable", magmaCubeRidable); + magmaCubeRidableInWater = getBoolean("mobs.magma_cube.ridable-in-water", magmaCubeRidableInWater); +@@ -1677,6 +1736,7 @@ public class PurpurWorldConfig { + } + magmaCubeMaxHealth = getString("mobs.magma_cube.attributes.max_health", magmaCubeMaxHealth); + magmaCubeTakeDamageFromWater = getBoolean("mobs.magma_cube.takes-damage-from-water", magmaCubeTakeDamageFromWater); ++ magmaCubeAlwaysDropExp = getBoolean("mobs.magma_cube.always-drop-exp", magmaCubeAlwaysDropExp); + } + + public boolean mooshroomRidable = false; +@@ -1684,6 +1744,7 @@ public class PurpurWorldConfig { + public double mooshroomMaxHealth = 10.0D; + public int mooshroomBreedingTicks = 6000; + public boolean mooshroomTakeDamageFromWater = false; ++ public boolean mooshroomAlwaysDropExp = false; + private void mooshroomSettings() { + mooshroomRidable = getBoolean("mobs.mooshroom.ridable", mooshroomRidable); + mooshroomRidableInWater = getBoolean("mobs.mooshroom.ridable-in-water", mooshroomRidableInWater); +@@ -1695,6 +1756,7 @@ public class PurpurWorldConfig { + mooshroomMaxHealth = getDouble("mobs.mooshroom.attributes.max_health", mooshroomMaxHealth); + mooshroomBreedingTicks = getInt("mobs.mooshroom.breeding-delay-ticks", mooshroomBreedingTicks); + mooshroomTakeDamageFromWater = getBoolean("mobs.mooshroom.takes-damage-from-water", mooshroomTakeDamageFromWater); ++ mooshroomAlwaysDropExp = getBoolean("mobs.mooshroom.always-drop-exp", mooshroomAlwaysDropExp); + } + + public boolean muleRidableInWater = false; +@@ -1706,6 +1768,7 @@ public class PurpurWorldConfig { + public double muleMovementSpeedMax = 0.175D; + public int muleBreedingTicks = 6000; + public boolean muleTakeDamageFromWater = false; ++ public boolean muleAlwaysDropExp = false; + private void muleSettings() { + muleRidableInWater = getBoolean("mobs.mule.ridable-in-water", muleRidableInWater); + if (PurpurConfig.version < 10) { +@@ -1723,6 +1786,7 @@ public class PurpurWorldConfig { + 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); ++ muleAlwaysDropExp = getBoolean("mobs.mule.always-drop-exp", muleAlwaysDropExp); + } + + public boolean ocelotRidable = false; +@@ -1730,6 +1794,7 @@ public class PurpurWorldConfig { + public double ocelotMaxHealth = 10.0D; + public int ocelotBreedingTicks = 6000; + public boolean ocelotTakeDamageFromWater = false; ++ public boolean ocelotAlwaysDropExp = false; + private void ocelotSettings() { + ocelotRidable = getBoolean("mobs.ocelot.ridable", ocelotRidable); + ocelotRidableInWater = getBoolean("mobs.ocelot.ridable-in-water", ocelotRidableInWater); +@@ -1741,6 +1806,7 @@ public class PurpurWorldConfig { + ocelotMaxHealth = getDouble("mobs.ocelot.attributes.max_health", ocelotMaxHealth); + ocelotBreedingTicks = getInt("mobs.ocelot.breeding-delay-ticks", ocelotBreedingTicks); + ocelotTakeDamageFromWater = getBoolean("mobs.ocelot.takes-damage-from-water", ocelotTakeDamageFromWater); ++ ocelotAlwaysDropExp = getBoolean("mobs.ocelot.always-drop-exp", ocelotAlwaysDropExp); + } + + public boolean pandaRidable = false; +@@ -1748,6 +1814,7 @@ public class PurpurWorldConfig { + public double pandaMaxHealth = 20.0D; + public int pandaBreedingTicks = 6000; + public boolean pandaTakeDamageFromWater = false; ++ public boolean pandaAlwaysDropExp = false; + private void pandaSettings() { + pandaRidable = getBoolean("mobs.panda.ridable", pandaRidable); + pandaRidableInWater = getBoolean("mobs.panda.ridable-in-water", pandaRidableInWater); +@@ -1759,6 +1826,7 @@ public class PurpurWorldConfig { + pandaMaxHealth = getDouble("mobs.panda.attributes.max_health", pandaMaxHealth); + pandaBreedingTicks = getInt("mobs.panda.breeding-delay-ticks", pandaBreedingTicks); + pandaTakeDamageFromWater = getBoolean("mobs.panda.takes-damage-from-water", pandaTakeDamageFromWater); ++ pandaAlwaysDropExp = getBoolean("mobs.panda.always-drop-exp", pandaAlwaysDropExp); + } + + public boolean parrotRidable = false; +@@ -1767,6 +1835,7 @@ public class PurpurWorldConfig { + public double parrotMaxHealth = 6.0D; + public boolean parrotTakeDamageFromWater = false; + public boolean parrotBreedable = false; ++ public boolean parrotAlwaysDropExp = false; + private void parrotSettings() { + parrotRidable = getBoolean("mobs.parrot.ridable", parrotRidable); + parrotRidableInWater = getBoolean("mobs.parrot.ridable-in-water", parrotRidableInWater); +@@ -1779,6 +1848,7 @@ public class PurpurWorldConfig { + parrotMaxHealth = getDouble("mobs.parrot.attributes.max_health", parrotMaxHealth); + parrotTakeDamageFromWater = getBoolean("mobs.parrot.takes-damage-from-water", parrotTakeDamageFromWater); + parrotBreedable = getBoolean("mobs.parrot.can-breed", parrotBreedable); ++ parrotAlwaysDropExp = getBoolean("mobs.parrot.always-drop-exp", parrotAlwaysDropExp); + } + + public boolean phantomRidable = false; +@@ -1808,6 +1878,7 @@ public class PurpurWorldConfig { + public boolean phantomIgnorePlayersWithTorch = false; + public boolean phantomBurnInDaylight = true; + public boolean phantomTakeDamageFromWater = false; ++ public boolean phantomAlwaysDropExp = false; + private void phantomSettings() { + phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable); + phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater); +@@ -1841,6 +1912,7 @@ public class PurpurWorldConfig { + phantomBurnInDaylight = getBoolean("mobs.phantom.burn-in-daylight", phantomBurnInDaylight); + phantomIgnorePlayersWithTorch = getBoolean("mobs.phantom.ignore-players-with-torch", phantomIgnorePlayersWithTorch); + phantomTakeDamageFromWater = getBoolean("mobs.phantom.takes-damage-from-water", phantomTakeDamageFromWater); ++ phantomAlwaysDropExp = getBoolean("mobs.phantom.always-drop-exp", phantomAlwaysDropExp); + } + + public boolean pigRidable = false; +@@ -1849,6 +1921,7 @@ public class PurpurWorldConfig { + public boolean pigGiveSaddleBack = false; + public int pigBreedingTicks = 6000; + public boolean pigTakeDamageFromWater = false; ++ public boolean pigAlwaysDropExp = false; + private void pigSettings() { + pigRidable = getBoolean("mobs.pig.ridable", pigRidable); + pigRidableInWater = getBoolean("mobs.pig.ridable-in-water", pigRidableInWater); +@@ -1861,6 +1934,7 @@ public class PurpurWorldConfig { + 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); ++ pigAlwaysDropExp = getBoolean("mobs.pig.always-drop-exp", pigAlwaysDropExp); + } + + public boolean piglinRidable = false; +@@ -1869,6 +1943,7 @@ public class PurpurWorldConfig { + public boolean piglinBypassMobGriefing = false; + public boolean piglinTakeDamageFromWater = false; + public int piglinPortalSpawnModifier = 2000; ++ public boolean piglinAlwaysDropExp = false; + private void piglinSettings() { + piglinRidable = getBoolean("mobs.piglin.ridable", piglinRidable); + piglinRidableInWater = getBoolean("mobs.piglin.ridable-in-water", piglinRidableInWater); +@@ -1881,12 +1956,14 @@ public class PurpurWorldConfig { + piglinBypassMobGriefing = getBoolean("mobs.piglin.bypass-mob-griefing", piglinBypassMobGriefing); + piglinTakeDamageFromWater = getBoolean("mobs.piglin.takes-damage-from-water", piglinTakeDamageFromWater); + piglinPortalSpawnModifier = getInt("mobs.piglin.portal-spawn-modifier", piglinPortalSpawnModifier); ++ piglinAlwaysDropExp = getBoolean("mobs.piglin.always-drop-exp", piglinAlwaysDropExp); + } + + public boolean piglinBruteRidable = false; + public boolean piglinBruteRidableInWater = false; + public double piglinBruteMaxHealth = 50.0D; + public boolean piglinBruteTakeDamageFromWater = false; ++ public boolean piglinBruteAlwaysDropExp = false; + private void piglinBruteSettings() { + piglinBruteRidable = getBoolean("mobs.piglin_brute.ridable", piglinBruteRidable); + piglinBruteRidableInWater = getBoolean("mobs.piglin_brute.ridable-in-water", piglinBruteRidableInWater); +@@ -1897,6 +1974,7 @@ public class PurpurWorldConfig { + } + piglinBruteMaxHealth = getDouble("mobs.piglin_brute.attributes.max_health", piglinBruteMaxHealth); + piglinBruteTakeDamageFromWater = getBoolean("mobs.piglin_brute.takes-damage-from-water", piglinBruteTakeDamageFromWater); ++ piglinBruteAlwaysDropExp = getBoolean("mobs.piglin_brute.always-drop-exp", piglinBruteAlwaysDropExp); + } + + public boolean pillagerRidable = false; +@@ -1904,6 +1982,7 @@ public class PurpurWorldConfig { + public double pillagerMaxHealth = 24.0D; + public boolean pillagerBypassMobGriefing = false; + public boolean pillagerTakeDamageFromWater = false; ++ public boolean pillagerAlwaysDropExp = false; + private void pillagerSettings() { + pillagerRidable = getBoolean("mobs.pillager.ridable", pillagerRidable); + pillagerRidableInWater = getBoolean("mobs.pillager.ridable-in-water", pillagerRidableInWater); +@@ -1915,6 +1994,7 @@ public class PurpurWorldConfig { + pillagerMaxHealth = getDouble("mobs.pillager.attributes.max_health", pillagerMaxHealth); + pillagerBypassMobGriefing = getBoolean("mobs.pillager.bypass-mob-griefing", pillagerBypassMobGriefing); + pillagerTakeDamageFromWater = getBoolean("mobs.pillager.takes-damage-from-water", pillagerTakeDamageFromWater); ++ pillagerAlwaysDropExp = getBoolean("mobs.pillager.always-drop-exp", pillagerAlwaysDropExp); + } + + public boolean polarBearRidable = false; +@@ -1924,6 +2004,7 @@ public class PurpurWorldConfig { + public Item polarBearBreedableItem = null; + public int polarBearBreedingTicks = 6000; + public boolean polarBearTakeDamageFromWater = false; ++ public boolean polarBearAlwaysDropExp = false; + private void polarBearSettings() { + polarBearRidable = getBoolean("mobs.polar_bear.ridable", polarBearRidable); + polarBearRidableInWater = getBoolean("mobs.polar_bear.ridable-in-water", polarBearRidableInWater); +@@ -1938,11 +2019,13 @@ public class PurpurWorldConfig { + 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); ++ polarBearAlwaysDropExp = getBoolean("mobs.polar_bear.always-drop-exp", polarBearAlwaysDropExp); + } + + public boolean pufferfishRidable = false; + public double pufferfishMaxHealth = 3.0D; + public boolean pufferfishTakeDamageFromWater = false; ++ public boolean pufferfishAlwaysDropExp = false; + private void pufferfishSettings() { + pufferfishRidable = getBoolean("mobs.pufferfish.ridable", pufferfishRidable); + if (PurpurConfig.version < 10) { +@@ -1952,6 +2035,7 @@ public class PurpurWorldConfig { + } + pufferfishMaxHealth = getDouble("mobs.pufferfish.attributes.max_health", pufferfishMaxHealth); + pufferfishTakeDamageFromWater = getBoolean("mobs.pufferfish.takes-damage-from-water", pufferfishTakeDamageFromWater); ++ pufferfishAlwaysDropExp = getBoolean("mobs.pufferfish.always-drop-exp", pufferfishAlwaysDropExp); + } + + public boolean rabbitRidable = false; +@@ -1962,6 +2046,7 @@ public class PurpurWorldConfig { + public int rabbitBreedingTicks = 6000; + public boolean rabbitBypassMobGriefing = false; + public boolean rabbitTakeDamageFromWater = false; ++ public boolean rabbitAlwaysDropExp = false; + private void rabbitSettings() { + rabbitRidable = getBoolean("mobs.rabbit.ridable", rabbitRidable); + rabbitRidableInWater = getBoolean("mobs.rabbit.ridable-in-water", rabbitRidableInWater); +@@ -1976,6 +2061,7 @@ public class PurpurWorldConfig { + 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); ++ rabbitAlwaysDropExp = getBoolean("mobs.rabbit.always-drop-exp", rabbitAlwaysDropExp); + } + + public boolean ravagerRidable = false; +@@ -1984,6 +2070,7 @@ public class PurpurWorldConfig { + public boolean ravagerBypassMobGriefing = false; + public boolean ravagerTakeDamageFromWater = false; + public List ravagerGriefableBlocks = new ArrayList<>(); ++ public boolean ravagerAlwaysDropExp = false; + private void ravagerSettings() { + ravagerRidable = getBoolean("mobs.ravager.ridable", ravagerRidable); + ravagerRidableInWater = getBoolean("mobs.ravager.ridable-in-water", ravagerRidableInWater); +@@ -2012,11 +2099,13 @@ public class PurpurWorldConfig { + ravagerGriefableBlocks.add(block); + } + }); ++ ravagerAlwaysDropExp = getBoolean("mobs.ravager.always-drop-exp", ravagerAlwaysDropExp); + } + + public boolean salmonRidable = false; + public double salmonMaxHealth = 3.0D; + public boolean salmonTakeDamageFromWater = false; ++ public boolean salmonAlwaysDropExp = false; + private void salmonSettings() { + salmonRidable = getBoolean("mobs.salmon.ridable", salmonRidable); + if (PurpurConfig.version < 10) { +@@ -2026,6 +2115,7 @@ public class PurpurWorldConfig { + } + salmonMaxHealth = getDouble("mobs.salmon.attributes.max_health", salmonMaxHealth); + salmonTakeDamageFromWater = getBoolean("mobs.salmon.takes-damage-from-water", salmonTakeDamageFromWater); ++ salmonAlwaysDropExp = getBoolean("mobs.salmon.always-drop-exp", salmonAlwaysDropExp); + } + + public boolean sheepRidable = false; +@@ -2034,6 +2124,7 @@ public class PurpurWorldConfig { + public int sheepBreedingTicks = 6000; + public boolean sheepBypassMobGriefing = false; + public boolean sheepTakeDamageFromWater = false; ++ public boolean sheepAlwaysDropExp = false; + private void sheepSettings() { + sheepRidable = getBoolean("mobs.sheep.ridable", sheepRidable); + sheepRidableInWater = getBoolean("mobs.sheep.ridable-in-water", sheepRidableInWater); +@@ -2046,6 +2137,7 @@ public class PurpurWorldConfig { + 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); ++ sheepAlwaysDropExp = getBoolean("mobs.sheep.always-drop-exp", sheepAlwaysDropExp); + } + + public boolean shulkerRidable = false; +@@ -2058,6 +2150,7 @@ public class PurpurWorldConfig { + public String shulkerSpawnFromBulletNearbyEquation = "(nearby - 1) / 5.0"; + public boolean shulkerSpawnFromBulletRandomColor = false; + public boolean shulkerChangeColorWithDye = false; ++ public boolean shulkerAlwaysDropExp = false; + private void shulkerSettings() { + shulkerRidable = getBoolean("mobs.shulker.ridable", shulkerRidable); + shulkerRidableInWater = getBoolean("mobs.shulker.ridable-in-water", shulkerRidableInWater); +@@ -2074,6 +2167,7 @@ public class PurpurWorldConfig { + shulkerSpawnFromBulletNearbyEquation = getString("mobs.shulker.spawn-from-bullet.nearby-equation", shulkerSpawnFromBulletNearbyEquation); + shulkerSpawnFromBulletRandomColor = getBoolean("mobs.shulker.spawn-from-bullet.random-color", shulkerSpawnFromBulletRandomColor); + shulkerChangeColorWithDye = getBoolean("mobs.shulker.change-color-with-dye", shulkerChangeColorWithDye); ++ shulkerAlwaysDropExp = getBoolean("mobs.shulker.always-drop-exp", shulkerAlwaysDropExp); + } + + public boolean silverfishRidable = false; +@@ -2081,6 +2175,7 @@ public class PurpurWorldConfig { + public double silverfishMaxHealth = 8.0D; + public boolean silverfishBypassMobGriefing = false; + public boolean silverfishTakeDamageFromWater = false; ++ public boolean silverfishAlwaysDropExp = false; + private void silverfishSettings() { + silverfishRidable = getBoolean("mobs.silverfish.ridable", silverfishRidable); + silverfishRidableInWater = getBoolean("mobs.silverfish.ridable-in-water", silverfishRidableInWater); +@@ -2092,12 +2187,14 @@ public class PurpurWorldConfig { + silverfishMaxHealth = getDouble("mobs.silverfish.attributes.max_health", silverfishMaxHealth); + silverfishBypassMobGriefing = getBoolean("mobs.silverfish.bypass-mob-griefing", silverfishBypassMobGriefing); + silverfishTakeDamageFromWater = getBoolean("mobs.silverfish.takes-damage-from-water", silverfishTakeDamageFromWater); ++ silverfishAlwaysDropExp = getBoolean("mobs.silverfish.always-drop-exp", silverfishAlwaysDropExp); + } + + public boolean skeletonRidable = false; + public boolean skeletonRidableInWater = false; + public double skeletonMaxHealth = 20.0D; + public boolean skeletonTakeDamageFromWater = false; ++ public boolean skeletonAlwaysDropExp = false; + private void skeletonSettings() { + skeletonRidable = getBoolean("mobs.skeleton.ridable", skeletonRidable); + skeletonRidableInWater = getBoolean("mobs.skeleton.ridable-in-water", skeletonRidableInWater); +@@ -2108,6 +2205,7 @@ public class PurpurWorldConfig { + } + skeletonMaxHealth = getDouble("mobs.skeleton.attributes.max_health", skeletonMaxHealth); + skeletonTakeDamageFromWater = getBoolean("mobs.skeleton.takes-damage-from-water", skeletonTakeDamageFromWater); ++ skeletonAlwaysDropExp = getBoolean("mobs.skeleton.always-drop-exp", skeletonAlwaysDropExp); + } + + public boolean skeletonHorseRidableInWater = true; +@@ -2119,6 +2217,7 @@ public class PurpurWorldConfig { + public double skeletonHorseMovementSpeedMin = 0.2D; + public double skeletonHorseMovementSpeedMax = 0.2D; + public boolean skeletonHorseTakeDamageFromWater = false; ++ public boolean skeletonHorseAlwaysDropExp = false; + private void skeletonHorseSettings() { + skeletonHorseRidableInWater = getBoolean("mobs.skeleton_horse.ridable-in-water", skeletonHorseRidableInWater); + skeletonHorseCanSwim = getBoolean("mobs.skeleton_horse.can-swim", skeletonHorseCanSwim); +@@ -2135,6 +2234,7 @@ public class PurpurWorldConfig { + 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); ++ skeletonHorseAlwaysDropExp = getBoolean("mobs.skeleton_horse.always-drop-exp", skeletonHorseAlwaysDropExp); + } + + public boolean slimeRidable = false; +@@ -2142,6 +2242,7 @@ public class PurpurWorldConfig { + public String slimeMaxHealth = "size * size"; + public Map slimeMaxHealthCache = new HashMap<>(); + public boolean slimeTakeDamageFromWater = false; ++ public boolean slimeAlwaysDropExp = false; + private void slimeSettings() { + slimeRidable = getBoolean("mobs.slime.ridable", slimeRidable); + slimeRidableInWater = getBoolean("mobs.slime.ridable-in-water", slimeRidableInWater); +@@ -2153,6 +2254,7 @@ public class PurpurWorldConfig { + slimeMaxHealth = getString("mobs.slime.attributes.max_health", slimeMaxHealth); + slimeMaxHealthCache.clear(); + slimeTakeDamageFromWater = getBoolean("mobs.slime.takes-damage-from-water", slimeTakeDamageFromWater); ++ slimeAlwaysDropExp = getBoolean("mobs.slime.always-drop-exp", slimeAlwaysDropExp); + } + + public boolean snowGolemRidable = false; +@@ -2167,6 +2269,7 @@ public class PurpurWorldConfig { + public double snowGolemAttackDistance = 1.25D; + public boolean snowGolemBypassMobGriefing = false; + public boolean snowGolemTakeDamageFromWater = true; ++ public boolean snowGolemAlwaysDropExp = false; + private void snowGolemSettings() { + snowGolemRidable = getBoolean("mobs.snow_golem.ridable", snowGolemRidable); + snowGolemRidableInWater = getBoolean("mobs.snow_golem.ridable-in-water", snowGolemRidableInWater); +@@ -2185,6 +2288,7 @@ public class PurpurWorldConfig { + 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); ++ snowGolemAlwaysDropExp = getBoolean("mobs.snow_golem.always-drop-exp", snowGolemAlwaysDropExp); + } + + public boolean squidRidable = false; +@@ -2193,6 +2297,7 @@ public class PurpurWorldConfig { + public double squidOffsetWaterCheck = 0.0D; + public boolean squidsCanFly = false; + public boolean squidTakeDamageFromWater = false; ++ public boolean squidAlwaysDropExp = false; + private void squidSettings() { + squidRidable = getBoolean("mobs.squid.ridable", squidRidable); + if (PurpurConfig.version < 10) { +@@ -2205,12 +2310,14 @@ public class PurpurWorldConfig { + squidOffsetWaterCheck = getDouble("mobs.squid.water-offset-check", squidOffsetWaterCheck); + squidsCanFly = getBoolean("mobs.squid.can-fly", squidsCanFly); + squidTakeDamageFromWater = getBoolean("mobs.squid.takes-damage-from-water", squidTakeDamageFromWater); ++ squidAlwaysDropExp = getBoolean("mobs.squid.always-drop-exp", squidAlwaysDropExp); + } + + public boolean spiderRidable = false; + public boolean spiderRidableInWater = false; + public double spiderMaxHealth = 16.0D; + public boolean spiderTakeDamageFromWater = false; ++ public boolean spiderAlwaysDropExp = false; + private void spiderSettings() { + spiderRidable = getBoolean("mobs.spider.ridable", spiderRidable); + spiderRidableInWater = getBoolean("mobs.spider.ridable-in-water", spiderRidableInWater); +@@ -2221,12 +2328,14 @@ public class PurpurWorldConfig { + } + spiderMaxHealth = getDouble("mobs.spider.attributes.max_health", spiderMaxHealth); + spiderTakeDamageFromWater = getBoolean("mobs.spider.takes-damage-from-water", spiderTakeDamageFromWater); ++ spiderAlwaysDropExp = getBoolean("mobs.spider.always-drop-exp", spiderAlwaysDropExp); + } + + public boolean strayRidable = false; + public boolean strayRidableInWater = false; + public double strayMaxHealth = 20.0D; + public boolean strayTakeDamageFromWater = false; ++ public boolean strayAlwaysDropExp = false; + private void straySettings() { + strayRidable = getBoolean("mobs.stray.ridable", strayRidable); + strayRidableInWater = getBoolean("mobs.stray.ridable-in-water", strayRidableInWater); +@@ -2237,6 +2346,7 @@ public class PurpurWorldConfig { + } + strayMaxHealth = getDouble("mobs.stray.attributes.max_health", strayMaxHealth); + strayTakeDamageFromWater = getBoolean("mobs.stray.takes-damage-from-water", strayTakeDamageFromWater); ++ strayAlwaysDropExp = getBoolean("mobs.stray.always-drop-exp", strayAlwaysDropExp); + } + + public boolean striderRidable = false; +@@ -2245,6 +2355,7 @@ public class PurpurWorldConfig { + public int striderBreedingTicks = 6000; + public boolean striderGiveSaddleBack = false; + public boolean striderTakeDamageFromWater = true; ++ public boolean striderAlwaysDropExp = false; + private void striderSettings() { + striderRidable = getBoolean("mobs.strider.ridable", striderRidable); + striderRidableInWater = getBoolean("mobs.strider.ridable-in-water", striderRidableInWater); +@@ -2257,6 +2368,7 @@ public class PurpurWorldConfig { + 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); ++ striderAlwaysDropExp = getBoolean("mobs.strider.always-drop-exp", striderAlwaysDropExp); + } + + public boolean traderLlamaRidable = false; +@@ -2269,6 +2381,7 @@ public class PurpurWorldConfig { + public double traderLlamaMovementSpeedMax = 0.175D; + public int traderLlamaBreedingTicks = 6000; + public boolean traderLlamaTakeDamageFromWater = false; ++ public boolean traderLlamaAlwaysDropExp = false; + private void traderLlamaSettings() { + traderLlamaRidable = getBoolean("mobs.trader_llama.ridable", traderLlamaRidable); + traderLlamaRidableInWater = getBoolean("mobs.trader_llama.ridable-in-water", traderLlamaRidableInWater); +@@ -2287,11 +2400,13 @@ public class PurpurWorldConfig { + 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); ++ traderLlamaAlwaysDropExp = getBoolean("mobs.trader_llama.always-drop-exp", traderLlamaAlwaysDropExp); + } + + public boolean tropicalFishRidable = false; + public double tropicalFishMaxHealth = 3.0D; + public boolean tropicalFishTakeDamageFromWater = false; ++ public boolean tropicalFishAlwaysDropExp = false; + private void tropicalFishSettings() { + tropicalFishRidable = getBoolean("mobs.tropical_fish.ridable", tropicalFishRidable); + if (PurpurConfig.version < 10) { +@@ -2301,6 +2416,7 @@ public class PurpurWorldConfig { + } + tropicalFishMaxHealth = getDouble("mobs.tropical_fish.attributes.max_health", tropicalFishMaxHealth); + tropicalFishTakeDamageFromWater = getBoolean("mobs.tropical_fish.takes-damage-from-water", tropicalFishTakeDamageFromWater); ++ tropicalFishAlwaysDropExp = getBoolean("mobs.tropical_fish.always-drop-exp", tropicalFishAlwaysDropExp); + } + + public boolean turtleEggsBypassMobGriefing = false; +@@ -2316,6 +2432,7 @@ public class PurpurWorldConfig { + public boolean turtleEggsBreakFromMinecarts = true; + public int turtleBreedingTicks = 6000; + public boolean turtleTakeDamageFromWater = false; ++ public boolean turtleAlwaysDropExp = false; + private void turtleEggSettings() { + turtleRidable = getBoolean("mobs.turtle.ridable", turtleRidable); + turtleRidableInWater = getBoolean("mobs.turtle.ridable-in-water", turtleRidableInWater); +@@ -2330,6 +2447,7 @@ public class PurpurWorldConfig { + turtleEggsBreakFromMinecarts = getBoolean("blocks.turtle_egg.break-from-minecarts", turtleEggsBreakFromMinecarts); + turtleBreedingTicks = getInt("mobs.turtle.breeding-delay-ticks", turtleBreedingTicks); + turtleTakeDamageFromWater = getBoolean("mobs.turtle.takes-damage-from-water", turtleTakeDamageFromWater); ++ turtleAlwaysDropExp = getBoolean("mobs.turtle.always-drop-exp", turtleAlwaysDropExp); + } + + public boolean vexRidable = false; +@@ -2337,6 +2455,7 @@ public class PurpurWorldConfig { + public double vexMaxY = 256D; + public double vexMaxHealth = 14.0D; + public boolean vexTakeDamageFromWater = false; ++ public boolean vexAlwaysDropExp = false; + private void vexSettings() { + vexRidable = getBoolean("mobs.vex.ridable", vexRidable); + vexRidableInWater = getBoolean("mobs.vex.ridable-in-water", vexRidableInWater); +@@ -2348,6 +2467,7 @@ public class PurpurWorldConfig { + } + vexMaxHealth = getDouble("mobs.vex.attributes.max_health", vexMaxHealth); + vexTakeDamageFromWater = getBoolean("mobs.vex.takes-damage-from-water", vexTakeDamageFromWater); ++ vexAlwaysDropExp = getBoolean("mobs.vex.always-drop-exp", vexAlwaysDropExp); + } + + public boolean villagerRidable = false; +@@ -2366,6 +2486,7 @@ public class PurpurWorldConfig { + public boolean villagerBypassMobGriefing = false; + public boolean villagerTakeDamageFromWater = false; + public boolean villagerAllowTrading = true; ++ public boolean villagerAlwaysDropExp = false; + private void villagerSettings() { + villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); + villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); +@@ -2388,6 +2509,7 @@ public class PurpurWorldConfig { + villagerBypassMobGriefing = getBoolean("mobs.villager.bypass-mob-griefing", villagerBypassMobGriefing); + villagerTakeDamageFromWater = getBoolean("mobs.villager.takes-damage-from-water", villagerTakeDamageFromWater); + villagerAllowTrading = getBoolean("mobs.villager.allow-trading", villagerAllowTrading); ++ villagerAlwaysDropExp = getBoolean("mobs.villager.always-drop-exp", villagerAlwaysDropExp); + } + + public boolean vindicatorRidable = false; +@@ -2395,6 +2517,7 @@ public class PurpurWorldConfig { + public double vindicatorMaxHealth = 24.0D; + public double vindicatorJohnnySpawnChance = 0D; + public boolean vindicatorTakeDamageFromWater = false; ++ public boolean vindicatorAlwaysDropExp = false; + private void vindicatorSettings() { + vindicatorRidable = getBoolean("mobs.vindicator.ridable", vindicatorRidable); + vindicatorRidableInWater = getBoolean("mobs.vindicator.ridable-in-water", vindicatorRidableInWater); +@@ -2406,6 +2529,7 @@ public class PurpurWorldConfig { + vindicatorMaxHealth = getDouble("mobs.vindicator.attributes.max_health", vindicatorMaxHealth); + vindicatorJohnnySpawnChance = getDouble("mobs.vindicator.johnny.spawn-chance", vindicatorJohnnySpawnChance); + vindicatorTakeDamageFromWater = getBoolean("mobs.vindicator.takes-damage-from-water", vindicatorTakeDamageFromWater); ++ vindicatorAlwaysDropExp = getBoolean("mobs.vindicator.always-drop-exp", vindicatorAlwaysDropExp); + } + + public boolean wanderingTraderRidable = false; +@@ -2415,6 +2539,7 @@ public class PurpurWorldConfig { + public boolean wanderingTraderCanBeLeashed = false; + public boolean wanderingTraderTakeDamageFromWater = false; + public boolean wanderingTraderAllowTrading = true; ++ public boolean wanderingTraderAlwaysDropExp = false; + private void wanderingTraderSettings() { + wanderingTraderRidable = getBoolean("mobs.wandering_trader.ridable", wanderingTraderRidable); + wanderingTraderRidableInWater = getBoolean("mobs.wandering_trader.ridable-in-water", wanderingTraderRidableInWater); +@@ -2428,12 +2553,14 @@ public class PurpurWorldConfig { + wanderingTraderCanBeLeashed = getBoolean("mobs.wandering_trader.can-be-leashed", wanderingTraderCanBeLeashed); + wanderingTraderTakeDamageFromWater = getBoolean("mobs.wandering_trader.takes-damage-from-water", wanderingTraderTakeDamageFromWater); + wanderingTraderAllowTrading = getBoolean("mobs.wandering_trader.allow-trading", wanderingTraderAllowTrading); ++ wanderingTraderAlwaysDropExp = getBoolean("mobs.wandering_trader.always-drop-exp", wanderingTraderAlwaysDropExp); + } + + public boolean witchRidable = false; + public boolean witchRidableInWater = false; + public double witchMaxHealth = 26.0D; + public boolean witchTakeDamageFromWater = false; ++ public boolean witchAlwaysDropExp = false; + private void witchSettings() { + witchRidable = getBoolean("mobs.witch.ridable", witchRidable); + witchRidableInWater = getBoolean("mobs.witch.ridable-in-water", witchRidableInWater); +@@ -2444,6 +2571,7 @@ public class PurpurWorldConfig { + } + witchMaxHealth = getDouble("mobs.witch.attributes.max_health", witchMaxHealth); + witchTakeDamageFromWater = getBoolean("mobs.witch.takes-damage-from-water", witchTakeDamageFromWater); ++ witchAlwaysDropExp = getBoolean("mobs.witch.always-drop-exp", witchAlwaysDropExp); + } + + public boolean witherRidable = false; +@@ -2457,6 +2585,7 @@ public class PurpurWorldConfig { + public boolean witherCanRideVehicles = false; + public float witherExplosionRadius = 1.0F; + public boolean witherPlaySpawnSound = true; ++ public boolean witherAlwaysDropExp = false; + private void witherSettings() { + witherRidable = getBoolean("mobs.wither.ridable", witherRidable); + witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater); +@@ -2478,12 +2607,14 @@ public class PurpurWorldConfig { + witherCanRideVehicles = getBoolean("mobs.wither.can-ride-vehicles", witherCanRideVehicles); + witherExplosionRadius = (float) getDouble("mobs.wither.explosion-radius", witherExplosionRadius); + witherPlaySpawnSound = getBoolean("mobs.wither.play-spawn-sound", witherPlaySpawnSound); ++ witherAlwaysDropExp = getBoolean("mobs.wither.always-drop-exp", witherAlwaysDropExp); + } + + public boolean witherSkeletonRidable = false; + public boolean witherSkeletonRidableInWater = false; + public double witherSkeletonMaxHealth = 20.0D; + public boolean witherSkeletonTakeDamageFromWater = false; ++ public boolean witherSkeletonAlwaysDropExp = false; + private void witherSkeletonSettings() { + witherSkeletonRidable = getBoolean("mobs.wither_skeleton.ridable", witherSkeletonRidable); + witherSkeletonRidableInWater = getBoolean("mobs.wither_skeleton.ridable-in-water", witherSkeletonRidableInWater); +@@ -2494,6 +2625,7 @@ public class PurpurWorldConfig { + } + witherSkeletonMaxHealth = getDouble("mobs.wither_skeleton.attributes.max_health", witherSkeletonMaxHealth); + witherSkeletonTakeDamageFromWater = getBoolean("mobs.wither_skeleton.takes-damage-from-water", witherSkeletonTakeDamageFromWater); ++ witherSkeletonAlwaysDropExp = getBoolean("mobs.wither_skeleton.always-drop-exp", witherSkeletonAlwaysDropExp); + } + + public boolean wolfRidable = false; +@@ -2504,6 +2636,7 @@ public class PurpurWorldConfig { + public double wolfNaturalRabid = 0.0D; + public int wolfBreedingTicks = 6000; + public boolean wolfTakeDamageFromWater = false; ++ public boolean wolfAlwaysDropExp = false; + private void wolfSettings() { + wolfRidable = getBoolean("mobs.wolf.ridable", wolfRidable); + wolfRidableInWater = getBoolean("mobs.wolf.ridable-in-water", wolfRidableInWater); +@@ -2522,12 +2655,14 @@ public class PurpurWorldConfig { + 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); ++ wolfAlwaysDropExp = getBoolean("mobs.wolf.always-drop-exp", wolfAlwaysDropExp); + } + + public boolean zoglinRidable = false; + public boolean zoglinRidableInWater = false; + public double zoglinMaxHealth = 40.0D; + public boolean zoglinTakeDamageFromWater = false; ++ public boolean zoglinAlwaysDropExp = false; + private void zoglinSettings() { + zoglinRidable = getBoolean("mobs.zoglin.ridable", zoglinRidable); + zoglinRidableInWater = getBoolean("mobs.zoglin.ridable-in-water", zoglinRidableInWater); +@@ -2538,6 +2673,7 @@ public class PurpurWorldConfig { + } + zoglinMaxHealth = getDouble("mobs.zoglin.attributes.max_health", zoglinMaxHealth); + zoglinTakeDamageFromWater = getBoolean("mobs.zoglin.takes-damage-from-water", zoglinTakeDamageFromWater); ++ zoglinAlwaysDropExp = getBoolean("mobs.zoglin.always-drop-exp", zoglinAlwaysDropExp); + } + + public boolean zombieRidable = false; +@@ -2550,6 +2686,7 @@ public class PurpurWorldConfig { + public boolean zombieAggressiveTowardsVillagerWhenLagging = true; + public boolean zombieBypassMobGriefing = false; + public boolean zombieTakeDamageFromWater = false; ++ public boolean zombieAlwaysDropExp = false; + private void zombieSettings() { + zombieRidable = getBoolean("mobs.zombie.ridable", zombieRidable); + zombieRidableInWater = getBoolean("mobs.zombie.ridable-in-water", zombieRidableInWater); +@@ -2566,6 +2703,7 @@ public class PurpurWorldConfig { + 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); ++ zombieAlwaysDropExp = getBoolean("mobs.zombie.always-drop-exp", zombieAlwaysDropExp); + } + + public boolean zombieHorseRidableInWater = false; +@@ -2578,6 +2716,7 @@ public class PurpurWorldConfig { + public double zombieHorseMovementSpeedMax = 0.2D; + public double zombieHorseSpawnChance = 0.0D; + public boolean zombieHorseTakeDamageFromWater = false; ++ public boolean zombieHorseAlwaysDropExp = false; + private void zombieHorseSettings() { + zombieHorseRidableInWater = getBoolean("mobs.zombie_horse.ridable-in-water", zombieHorseRidableInWater); + zombieHorseCanSwim = getBoolean("mobs.zombie_horse.can-swim", zombieHorseCanSwim); +@@ -2595,6 +2734,7 @@ public class PurpurWorldConfig { + 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); ++ zombieHorseAlwaysDropExp = getBoolean("mobs.zombie_horse.always-drop-exp", zombieHorseAlwaysDropExp); + } + + public boolean zombieVillagerRidable = false; +@@ -2608,6 +2748,7 @@ public class PurpurWorldConfig { + public int zombieVillagerCuringTimeMin = 3600; + public int zombieVillagerCuringTimeMax = 6000; + public boolean zombieVillagerCureEnabled = true; ++ public boolean zombieVillagerAlwaysDropExp = false; + private void zombieVillagerSettings() { + zombieVillagerRidable = getBoolean("mobs.zombie_villager.ridable", zombieVillagerRidable); + zombieVillagerRidableInWater = getBoolean("mobs.zombie_villager.ridable-in-water", zombieVillagerRidableInWater); +@@ -2625,6 +2766,7 @@ public class PurpurWorldConfig { + zombieVillagerCuringTimeMin = getInt("mobs.zombie_villager.curing_time.min", zombieVillagerCuringTimeMin); + zombieVillagerCuringTimeMax = getInt("mobs.zombie_villager.curing_time.max", zombieVillagerCuringTimeMax); + zombieVillagerCureEnabled = getBoolean("mobs.zombie_villager.cure.enabled", zombieVillagerCureEnabled); ++ zombieVillagerAlwaysDropExp = getBoolean("mobs.zombie_villager.always-drop-exp", zombieVillagerAlwaysDropExp); + } + + public boolean zombifiedPiglinRidable = false; +@@ -2636,6 +2778,7 @@ public class PurpurWorldConfig { + public boolean zombifiedPiglinJockeyTryExistingChickens = true; + public boolean zombifiedPiglinCountAsPlayerKillWhenAngry = true; + public boolean zombifiedPiglinTakeDamageFromWater = false; ++ public boolean zombifiedPiglinAlwaysDropExp = false; + private void zombifiedPiglinSettings() { + zombifiedPiglinRidable = getBoolean("mobs.zombified_piglin.ridable", zombifiedPiglinRidable); + zombifiedPiglinRidableInWater = getBoolean("mobs.zombified_piglin.ridable-in-water", zombifiedPiglinRidableInWater); +@@ -2651,6 +2794,7 @@ public class PurpurWorldConfig { + 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); ++ zombifiedPiglinAlwaysDropExp = getBoolean("mobs.zombified_piglin.always-drop-exp", zombifiedPiglinAlwaysDropExp); + } + + public float hungerStarvationDamage = 1.0F;