From 0045a57c5d87c6f9a85d6cc8c4d17112d402b41c Mon Sep 17 00:00:00 2001 From: BillyGalbreath Date: Sun, 12 Jun 2022 09:06:50 -0500 Subject: [PATCH] add ridable 1.19 mobs --- patches/server/0007-Ridables.patch | 358 +++++++++++++++++- ...-Configurable-entity-base-attributes.patch | 25 +- ...21-Configurable-villager-brain-ticks.patch | 6 +- patches/server/0028-Giants-AI-settings.patch | 6 +- .../0029-Zombie-horse-naturally-spawn.patch | 6 +- ...0030-Charged-creeper-naturally-spawn.patch | 6 +- ...bit-naturally-spawn-toast-and-killer.patch | 6 +- .../server/0033-Tulips-change-fox-type.patch | 8 +- .../server/0034-Breedable-Polar-Bears.patch | 6 +- .../server/0035-Chickens-can-retaliate.patch | 6 +- .../server/0037-Cat-spawning-options.patch | 6 +- patches/server/0039-Cows-eat-mushrooms.patch | 6 +- .../server/0041-Pigs-give-saddle-back.patch | 6 +- ...42-Snowman-drop-and-put-back-pumpkin.patch | 6 +- ...43-Ender-dragon-always-drop-full-exp.patch | 6 +- ...derman-and-creeper-griefing-controls.patch | 10 +- ...0056-Villagers-follow-emerald-blocks.patch | 12 +- .../0057-Allow-leashing-villagers.patch | 12 +- .../0062-Add-canSaveToDisk-to-Entity.patch | 4 +- .../0072-Configurable-jockey-options.patch | 22 +- ...ed-to-crystals-and-crystals-shoot-ph.patch | 6 +- .../0074-Add-phantom-spawning-options.patch | 6 +- patches/server/0081-Squid-EAR-immunity.patch | 6 +- .../server/0082-Phantoms-burn-in-light.patch | 6 +- .../0083-Configurable-villager-breeding.patch | 6 +- ...6-Add-vindicator-johnny-spawn-chance.patch | 6 +- ...o-disable-dolphin-treasure-searching.patch | 6 +- ...Stop-squids-floating-on-top-of-water.patch | 6 +- ...stomizable-wither-health-and-healing.patch | 10 +- ...sable-zombie-aggressiveness-towards-.patch | 6 +- patches/server/0102-Flying-squids-Oh-my.patch | 8 +- ...e-entity-breeding-times-configurable.patch | 125 +++--- ...llowing-Endermen-to-despawn-even-whi.patch | 6 +- .../0117-Snow-Golem-rate-of-fire-config.patch | 6 +- ...Villager-Clerics-to-farm-Nether-Wart.patch | 6 +- ...fied-Piglin-death-always-counting-as.patch | 6 +- ...ble-chance-for-wolves-to-spawn-rabid.patch | 6 +- ...23-Configurable-default-collar-color.patch | 10 +- .../server/0124-Phantom-flames-on-swoop.patch | 6 +- .../0127-Striders-give-saddle-back.patch | 8 +- ...iefing-bypass-to-everything-affected.patch | 68 ++-- ...oggle-for-water-sensitive-mob-damage.patch | 277 +++++++------- ...ither-Ender-Dragon-can-ride-vehicles.patch | 14 +- ...an-aggressiveness-towards-Endermites.patch | 6 +- ...-Dragon-Head-wearers-and-stare-aggro.patch | 6 +- ...149-Config-to-disable-Llama-caravans.patch | 6 +- ...ig-to-make-Creepers-explode-on-death.patch | 6 +- ...urable-ravager-griefable-blocks-list.patch | 6 +- ...0154-Add-config-for-villager-trading.patch | 12 +- .../0165-Piglin-portal-spawn-modifier.patch | 6 +- ...7-Config-for-wither-explosion-radius.patch | 6 +- ...h-to-impact-Creeper-explosion-radius.patch | 6 +- .../0175-Iron-golem-calm-anger-options.patch | 6 +- patches/server/0176-Breedable-parrots.patch | 6 +- ...ee-can-work-when-raining-or-at-night.patch | 8 +- ...94-Shulker-spawn-from-bullet-options.patch | 6 +- ...6-Option-to-make-drowned-break-doors.patch | 6 +- ...onfigurable-hunger-starvation-damage.patch | 4 +- patches/server/0204-Summoner-API.patch | 8 +- ...0207-Silk-touchable-budding-amethyst.patch | 4 +- ...e-Enderman-teleport-on-projectile-hi.patch | 6 +- ...ent-horses-from-standing-with-riders.patch | 6 +- ...izeable-Zombie-Villager-curing-times.patch | 6 +- ...0217-Toggle-for-Wither-s-spawn-sound.patch | 10 +- .../0220-Conduit-behavior-configuration.patch | 4 +- .../server/0221-Cauldron-fill-chances.patch | 4 +- .../0223-Shulker-change-color-with-dye.patch | 6 +- ...turally-aggressive-to-players-chance.patch | 6 +- ...turally-aggressive-to-players-chance.patch | 6 +- ...-Halloween-options-and-optimizations.patch | 4 +- ...ion-to-disable-zombie-villagers-cure.patch | 6 +- .../0241-Mobs-always-drop-experience.patch | 288 +++++++------- ...t-spiders-from-climbing-world-border.patch | 6 +- ...aring-jeb-produces-random-color-wool.patch | 6 +- .../0248-Mob-head-visibility-percent.patch | 14 +- ...-Stop-bees-from-dying-after-stinging.patch | 8 +- .../0257-Configurable-phantom-size.patch | 6 +- ...nfigurable-minimum-demand-for-trades.patch | 6 +- .../0261-Lobotomize-stuck-villagers.patch | 6 +- ...tion-for-villager-display-trade-item.patch | 6 +- ...event-horses-from-standing-when-hurt.patch | 6 +- ...urable-search-radius-for-villagers-t.patch | 6 +- ...sh-added-classes-to-junit-exemptions.patch | 21 - 83 files changed, 995 insertions(+), 689 deletions(-) delete mode 100644 patches/todo/api/0001-Add-pufferfish-added-classes-to-junit-exemptions.patch diff --git a/patches/server/0007-Ridables.patch b/patches/server/0007-Ridables.patch index 9ca8db4bd..43754433f 100644 --- a/patches/server/0007-Ridables.patch +++ b/patches/server/0007-Ridables.patch @@ -702,7 +702,7 @@ index 1f85f34c1e50f34fb270d2fac7d307c82a550bfa..324f52edd95b5f9a498e46def8c14435 double d = this.wantedX - this.fish.getX(); double e = this.wantedY - this.fish.getY(); 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 bd048cc30046f19f9eee89c6ba45d0816a160e67..2c6e1a970d8922047a186fc7eb82abd7066b1fd9 100644 +index bd048cc30046f19f9eee89c6ba45d0816a160e67..1458079a5ffa8b4a50d30cfc01fa1b27b6a46f37 100644 --- a/src/main/java/net/minecraft/world/entity/animal/Bee.java +++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java @@ -43,6 +43,7 @@ import net.minecraft.world.entity.EntityType; @@ -717,7 +717,7 @@ index bd048cc30046f19f9eee89c6ba45d0816a160e67..2c6e1a970d8922047a186fc7eb82abd7 public Bee(EntityType type, Level world) { super(type, world); this.remainingCooldownBeforeLocatingNewFlower = Mth.nextInt(this.random, 20, 60); -+ final org.purpurmc.purpur.controller.FlyingMoveControllerWASD flyingController = new org.purpurmc.purpur.controller.FlyingMoveControllerWASD(this, 0.25F, false); // Purpur ++ final org.purpurmc.purpur.controller.FlyingMoveControllerWASD flyingController = new org.purpurmc.purpur.controller.FlyingMoveControllerWASD(this, 0.25F, 1.0F, false); // Purpur // Paper start - apply gravity to bees when they get stuck in the void, fixes MC-167279 class BeeFlyingMoveControl extends FlyingMoveControl { public BeeFlyingMoveControl(final Mob entity, final int maxPitchChange, final boolean noGravity) { @@ -2193,6 +2193,61 @@ index 45c3cec839a7c23903dedf6e3e004305da2adceb..248531727dcafb71d7d2d2767205e09a this.targetSelector.addGoal(1, new OwnerHurtByTargetGoal(this)); this.targetSelector.addGoal(2, new OwnerHurtTargetGoal(this)); this.targetSelector.addGoal(3, (new HurtByTargetGoal(this, new Class[0])).setAlertOthers()); +diff --git a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java +index 765dee56dd3a77e4bce137b84c4139202a5cef84..1fbdf53691670414564171521583b00d719040e4 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java ++++ b/src/main/java/net/minecraft/world/entity/animal/allay/Allay.java +@@ -72,14 +72,49 @@ public class Allay extends PathfinderMob implements InventoryCarrier, VibrationL + private final SimpleContainer inventory = new SimpleContainer(1); + private float holdingItemAnimationTicks; + private float holdingItemAnimationTicks0; ++ private org.purpurmc.purpur.controller.FlyingMoveControllerWASD purpurController; // Purpur + + public Allay(EntityType type, Level world) { + super(type, world); +- this.moveControl = new FlyingMoveControl(this, 20, true); ++ // Purpur start ++ this.purpurController = new org.purpurmc.purpur.controller.FlyingMoveControllerWASD(this, 0.1F, 0.5F); ++ this.moveControl = new FlyingMoveControl(this, 20, true) { ++ @Override ++ public void tick() { ++ if (mob.getRider() != null && mob.isControllable()) { ++ purpurController.purpurTick(mob.getRider()); ++ } else { ++ super.tick(); ++ } ++ } ++ }; ++ // Purpur end + this.setCanPickUpLoot(this.canPickUpLoot()); + this.dynamicGameEventListener = new DynamicGameEventListener<>(new VibrationListener(new EntityPositionSource(this, this.getEyeHeight()), 16, this, (VibrationListener.ReceivingEvent)null, 0.0F, 0)); + } + ++ // Purpur start ++ @Override ++ public boolean isRidable() { ++ return level.purpurConfig.allayRidable; ++ } ++ ++ @Override ++ public boolean rideableUnderWater() { ++ return level.purpurConfig.allayRidableInWater; ++ } ++ ++ @Override ++ public boolean isControllable() { ++ return level.purpurConfig.allayControllable; ++ } ++ ++ @Override ++ protected void registerGoals() { ++ this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur ++ } ++ // Purpur end ++ + @Override + protected Brain.Provider brainProvider() { + return Brain.provider(MEMORY_TYPES, SENSOR_TYPES); 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 fdd2c63ff0017bafa544a3cff2ee6d2d62c92cb3..32b31e5efb5fc68430b9bcd4cd972494f53accc8 100644 --- a/src/main/java/net/minecraft/world/entity/animal/axolotl/Axolotl.java @@ -2261,6 +2316,158 @@ index fdd2c63ff0017bafa544a3cff2ee6d2d62c92cb3..32b31e5efb5fc68430b9bcd4cd972494 } } +diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java +index 9e17e21a48892686e94a1c21b636695ab84eb7cd..156ab5e6a8e75e55f0f3fbc84c21e397cd1dc589 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java ++++ b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java +@@ -43,7 +43,6 @@ import net.minecraft.world.entity.SpawnGroupData; + import net.minecraft.world.entity.ai.Brain; + import net.minecraft.world.entity.ai.attributes.AttributeSupplier; + import net.minecraft.world.entity.ai.attributes.Attributes; +-import net.minecraft.world.entity.ai.control.LookControl; + import net.minecraft.world.entity.ai.control.SmoothSwimmingMoveControl; + import net.minecraft.world.entity.ai.memory.MemoryModuleType; + import net.minecraft.world.entity.ai.navigation.AmphibiousPathNavigation; +@@ -53,6 +52,7 @@ import net.minecraft.world.entity.ai.sensing.SensorType; + import net.minecraft.world.entity.animal.Animal; + import net.minecraft.world.entity.animal.FrogVariant; + import net.minecraft.world.entity.monster.Slime; ++import net.minecraft.world.entity.player.Player; + import net.minecraft.world.item.ItemStack; + import net.minecraft.world.item.Items; + import net.minecraft.world.item.crafting.Ingredient; +@@ -83,16 +83,65 @@ public class Frog extends Animal { + public final AnimationState walkAnimationState = new AnimationState(); + public final AnimationState swimAnimationState = new AnimationState(); + public final AnimationState swimIdleAnimationState = new AnimationState(); ++ private org.purpurmc.purpur.controller.MoveControllerWASD purpurLandController; // Purpur ++ private org.purpurmc.purpur.controller.WaterMoveControllerWASD purpurWaterController; // Purpur + + public Frog(EntityType type, Level world) { + super(type, world); + this.lookControl = new Frog.FrogLookControl(this); + this.setPathfindingMalus(BlockPathTypes.WATER, 4.0F); + this.setPathfindingMalus(BlockPathTypes.TRAPDOOR, -1.0F); +- this.moveControl = new SmoothSwimmingMoveControl(this, 85, 10, 0.02F, 0.1F, true); ++ // Purpur start ++ this.purpurLandController = new org.purpurmc.purpur.controller.MoveControllerWASD(this, 0.2F); ++ this.purpurWaterController = new org.purpurmc.purpur.controller.WaterMoveControllerWASD(this, 0.5F); ++ this.moveControl = new SmoothSwimmingMoveControl(this, 85, 10, 0.02F, 0.1F, true) { ++ @Override ++ public void tick() { ++ Player rider = mob.getRider(); ++ if (rider != null && mob.isControllable()) { ++ if (mob.isInWater()) { ++ purpurWaterController.purpurTick(rider); ++ mob.setDeltaMovement(mob.getDeltaMovement().add(0.0D, -0.005D, 0.0D)); ++ } else { ++ purpurLandController.purpurTick(rider); ++ } ++ } else { ++ super.tick(); ++ } ++ } ++ }; ++ // Purpur end + this.maxUpStep = 1.0F; + } + ++ // Purpur start ++ @Override ++ public boolean isRidable() { ++ return level.purpurConfig.frogRidable; ++ } ++ ++ @Override ++ public boolean rideableUnderWater() { ++ return level.purpurConfig.frogRidableInWater; ++ } ++ ++ @Override ++ public boolean isControllable() { ++ return level.purpurConfig.frogControllable; ++ } ++ ++ @Override ++ protected void registerGoals() { ++ this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur ++ this.targetSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur ++ } ++ ++ @Override ++ public float getJumpPower() { ++ return (getRider() != null && isControllable()) ? level.purpurConfig.frogRidableJumpHeight * this.getBlockJumpFactor() : super.getJumpPower(); ++ } ++ // Purpur end ++ + @Override + protected Brain.Provider brainProvider() { + return Brain.provider(MEMORY_TYPES, SENSOR_TYPES); +@@ -378,7 +427,7 @@ public class Frog extends Animal { + return world.getBlockState(pos.below()).is(BlockTags.FROGS_SPAWNABLE_ON) && isBrightEnoughToSpawn(world, pos); + } + +- class FrogLookControl extends LookControl { ++ class FrogLookControl extends org.purpurmc.purpur.controller.LookControllerWASD { // Purpur + FrogLookControl(Mob entity) { + super(entity); + } +diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java b/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java +index 7d093e4cc3357abd205302a98cc7b06cf55229bc..77f19a0f90b62b1423381d87194d0e1ae545cbbe 100644 +--- a/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java ++++ b/src/main/java/net/minecraft/world/entity/animal/frog/Tadpole.java +@@ -43,13 +43,50 @@ public class Tadpole extends AbstractFish { + public int age; + protected static final ImmutableList>> SENSOR_TYPES = ImmutableList.of(SensorType.NEAREST_LIVING_ENTITIES, SensorType.NEAREST_PLAYERS, SensorType.HURT_BY, SensorType.FROG_TEMPTATIONS); + protected static final ImmutableList> MEMORY_TYPES = ImmutableList.of(MemoryModuleType.LOOK_TARGET, MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES, MemoryModuleType.WALK_TARGET, MemoryModuleType.CANT_REACH_WALK_TARGET_SINCE, MemoryModuleType.PATH, MemoryModuleType.NEAREST_VISIBLE_ADULT, MemoryModuleType.TEMPTATION_COOLDOWN_TICKS, MemoryModuleType.IS_TEMPTED, MemoryModuleType.TEMPTING_PLAYER, MemoryModuleType.BREED_TARGET, MemoryModuleType.IS_PANICKING); ++ private org.purpurmc.purpur.controller.WaterMoveControllerWASD purpurController; // Purpur + + public Tadpole(EntityType type, Level world) { + super(type, world); +- this.moveControl = new SmoothSwimmingMoveControl(this, 85, 10, 0.02F, 0.1F, true); ++ // Purpur start ++ this.purpurController = new org.purpurmc.purpur.controller.WaterMoveControllerWASD(this, 0.5F); ++ this.moveControl = new SmoothSwimmingMoveControl(this, 85, 10, 0.02F, 0.1F, true) { ++ @Override ++ public void tick() { ++ Player rider = mob.getRider(); ++ if (rider != null && mob.isControllable()) { ++ purpurController.purpurTick(rider); ++ mob.setDeltaMovement(mob.getDeltaMovement().add(0.0D, 0.002D, 0.0D)); ++ } else { ++ super.tick(); ++ } ++ } ++ }; ++ // Purpur end + this.lookControl = new SmoothSwimmingLookControl(this, 10); + } + ++ // Purpur start ++ @Override ++ public boolean isRidable() { ++ return level.purpurConfig.tadpoleRidable; ++ } ++ ++ @Override ++ public boolean rideableUnderWater() { ++ return level.purpurConfig.tadpoleRidableInWater; ++ } ++ ++ @Override ++ public boolean isControllable() { ++ return level.purpurConfig.tadpoleControllable; ++ } ++ ++ @Override ++ protected void registerGoals() { ++ this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur ++ } ++ // Purpur end ++ + @Override + protected PathNavigation createNavigation(Level world) { + return new WaterBoundPathNavigation(this, world); 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 f489301701f8abfb8f509d91089c1433db2346f8..ba47201f7b9ebfba28dc2f7ddc89375a8662476d 100644 --- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java @@ -2725,10 +2932,10 @@ index 219877901fb5fc6401646253d6e5d7bd8416ffe1..079a85f1520cda6a0fb72d0dd7f9e18a this.dragonFight.updateDragon(this); } 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 4fb40aa91e0961f1974c74c88fa68359e4ad6b16..dd7bd70e0b905eea690c2d20b8438b9476d2badc 100644 +index 4fb40aa91e0961f1974c74c88fa68359e4ad6b16..7a0653ae3bf1f9c99e3363fb27a9af30cbc2f27a 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 -@@ -84,6 +84,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -84,16 +84,30 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob return entityliving.getMobType() != MobType.UNDEAD && entityliving.attackable(); }; private static final TargetingConditions TARGETING_CONDITIONS = TargetingConditions.forCombat().range(20.0D).selector(WitherBoss.LIVING_ENTITY_SELECTOR); @@ -2736,11 +2943,31 @@ index 4fb40aa91e0961f1974c74c88fa68359e4ad6b16..dd7bd70e0b905eea690c2d20b8438b94 // Paper start private boolean canPortal = false; -@@ -105,16 +106,123 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob - navigationflying.setCanOpenDoors(false); - navigationflying.setCanFloat(true); - navigationflying.setCanPassDoors(true); -+ this.moveControl = new org.purpurmc.purpur.controller.FlyingWithSpacebarMoveControllerWASD(this, 0.1F); // Purpur + public void setCanTravelThroughPortals(boolean canPortal) { this.canPortal = canPortal; } + // Paper end ++ private org.purpurmc.purpur.controller.FlyingWithSpacebarMoveControllerWASD purpurController; // Purpur + + public WitherBoss(EntityType type, Level world) { + super(type, world); + this.bossEvent = (ServerBossEvent) (new ServerBossEvent(this.getDisplayName(), BossEvent.BossBarColor.PURPLE, BossEvent.BossBarOverlay.PROGRESS)).setDarkenScreen(true); +- this.moveControl = new FlyingMoveControl(this, 10, false); ++ // Purpur start ++ this.purpurController = new org.purpurmc.purpur.controller.FlyingWithSpacebarMoveControllerWASD(this, 0.1F); ++ this.moveControl = new FlyingMoveControl(this, 10, false) { ++ @Override ++ public void tick() { ++ if (mob.getRider() != null && mob.isControllable()) { ++ purpurController.purpurTick(mob.getRider()); ++ } else { ++ super.tick(); ++ } ++ } ++ }; ++ // Purpur end + this.setHealth(this.getMaxHealth()); + this.xpReward = 50; + } +@@ -108,13 +122,119 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob return navigationflying; } @@ -2860,7 +3087,7 @@ index 4fb40aa91e0961f1974c74c88fa68359e4ad6b16..dd7bd70e0b905eea690c2d20b8438b94 this.targetSelector.addGoal(1, new HurtByTargetGoal(this, new Class[0])); this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, LivingEntity.class, 0, false, false, WitherBoss.LIVING_ENTITY_SELECTOR)); } -@@ -256,6 +364,16 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -256,6 +376,16 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob @Override protected void customServerAiStep() { @@ -2877,7 +3104,7 @@ index 4fb40aa91e0961f1974c74c88fa68359e4ad6b16..dd7bd70e0b905eea690c2d20b8438b94 int i; if (this.getInvulnerableTicks() > 0) { -@@ -583,11 +701,11 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -583,11 +713,11 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob } public int getAlternativeTarget(int headIndex) { @@ -4729,6 +4956,51 @@ index 769e4fbaac01a4fe3a45bd9cab5c63b61fc69f53..ff149234a8f3e1c94961e41d5bc81174 this.getBrain().tick((ServerLevel)this.level, this); this.level.getProfiler().pop(); PiglinBruteAi.updateActivity(this); +diff --git a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java +index 4366f7ff095c79a1f4444a27198f2613eb01fdc2..5918c35ebdba83dc93414d05b19a9d2b55b1bb7c 100644 +--- a/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java ++++ b/src/main/java/net/minecraft/world/entity/monster/warden/Warden.java +@@ -118,8 +118,32 @@ public class Warden extends Monster implements VibrationListener.VibrationListen + this.setPathfindingMalus(BlockPathTypes.LAVA, 8.0F); + this.setPathfindingMalus(BlockPathTypes.DAMAGE_FIRE, 0.0F); + this.setPathfindingMalus(BlockPathTypes.DANGER_FIRE, 0.0F); ++ this.moveControl = new org.purpurmc.purpur.controller.MoveControllerWASD(this, 0.5F); // Purpur + } + ++ // Purpur start ++ @Override ++ public boolean isRidable() { ++ return level.purpurConfig.wardenRidable; ++ } ++ ++ @Override ++ public boolean rideableUnderWater() { ++ return level.purpurConfig.wardenRidableInWater; ++ } ++ ++ @Override ++ public boolean isControllable() { ++ return level.purpurConfig.wardenControllable; ++ } ++ ++ @Override ++ protected void registerGoals() { ++ this.goalSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur ++ this.targetSelector.addGoal(0, new org.purpurmc.purpur.entity.ai.HasRider(this)); // Purpur ++ } ++ // Purpur end ++ + @Override + public Packet getAddEntityPacket() { + return new ClientboundAddEntityPacket((LivingEntity)this, this.hasPose(Pose.EMERGING) ? 1 : 0); +@@ -391,6 +415,7 @@ public class Warden extends Monster implements VibrationListener.VibrationListen + + @Contract("null->false") + public boolean canTargetEntity(@Nullable Entity entity) { ++ if (getRider() != null && isControllable()) return false; // Purpur + if (entity instanceof LivingEntity livingEntity) { + if (this.level == entity.level && EntitySelector.NO_CREATIVE_OR_SPECTATOR.test(entity) && !this.isAlliedTo(entity) && livingEntity.getType() != EntityType.ARMOR_STAND && livingEntity.getType() != EntityType.WARDEN && !livingEntity.isInvulnerable() && !livingEntity.isDeadOrDying() && this.level.getWorldBorder().isWithinBounds(livingEntity.getBoundingBox())) { + return true; 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 93077e8c6b5a35adc6febb749d1d08be172402f1..a6519bf96f39fa69ecb65ef25dba80261bb03323 100644 --- a/src/main/java/net/minecraft/world/entity/npc/Villager.java @@ -4962,10 +5234,10 @@ index b3bfc56859d00f9e27bd1d230dd19b92985b5718..e8150d1bec60f7e32d5475c8402fd7b5 + } } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 0ce93836629522c2ff2a57226583009302271daf..969c78aef40aae497a76dd7f3e9c230577a8d31f 100644 +index 0ce93836629522c2ff2a57226583009302271daf..4efbb008bd31a0316d3ceead6be27c6d38dd9f50 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -88,4 +88,668 @@ public class PurpurWorldConfig { +@@ -88,4 +88,706 @@ public class PurpurWorldConfig { final Map value = PurpurConfig.getMap("world-settings." + worldName + "." + path, null); return value.isEmpty() ? fallback : value; } @@ -4979,6 +5251,15 @@ index 0ce93836629522c2ff2a57226583009302271daf..969c78aef40aae497a76dd7f3e9c2305 + useNightVisionWhenRiding = getBoolean("ridable-settings.use-night-vision", useNightVisionWhenRiding); + } + ++ public boolean allayRidable = false; ++ public boolean allayRidableInWater = false; ++ public boolean allayControllable = true; ++ private void allaySettings() { ++ allayRidable = getBoolean("mobs.allay.ridable", allayRidable); ++ allayRidableInWater = getBoolean("mobs.allay.ridable-in-water", allayRidableInWater); ++ allayControllable = getBoolean("mobs.allay.controllable", allayControllable); ++ } ++ + public boolean axolotlRidable = false; + public boolean axolotlControllable = true; + private void axolotlSettings() { @@ -5152,6 +5433,17 @@ index 0ce93836629522c2ff2a57226583009302271daf..969c78aef40aae497a76dd7f3e9c2305 + foxControllable = getBoolean("mobs.fox.controllable", foxControllable); + } + ++ public boolean frogRidable = false; ++ public boolean frogRidableInWater = false; ++ public boolean frogControllable = true; ++ public float frogRidableJumpHeight = 0.65F; ++ private void frogSettings() { ++ frogRidable = getBoolean("mobs.frog.ridable", frogRidable); ++ frogRidableInWater = getBoolean("mobs.frog.ridable-in-water", frogRidableInWater); ++ frogControllable = getBoolean("mobs.frog.controllable", frogControllable); ++ frogRidableJumpHeight = (float) getDouble("mobs.frog.ridable-jump-height", frogRidableJumpHeight); ++ } ++ + public boolean ghastRidable = false; + public boolean ghastRidableInWater = false; + public boolean ghastControllable = true; @@ -5490,6 +5782,15 @@ index 0ce93836629522c2ff2a57226583009302271daf..969c78aef40aae497a76dd7f3e9c2305 + striderControllable = getBoolean("mobs.strider.controllable", striderControllable); + } + ++ public boolean tadpoleRidable = false; ++ public boolean tadpoleRidableInWater = false; ++ public boolean tadpoleControllable = true; ++ private void tadpoleSettings() { ++ tadpoleRidable = getBoolean("mobs.tadpole.ridable", tadpoleRidable); ++ tadpoleRidableInWater = getBoolean("mobs.tadpole.ridable-in-water", tadpoleRidableInWater); ++ tadpoleControllable = getBoolean("mobs.tadpole.controllable", tadpoleControllable); ++ } ++ + public boolean traderLlamaRidable = false; + public boolean traderLlamaRidableInWater = false; + public boolean traderLlamaControllable = true; @@ -5553,6 +5854,15 @@ index 0ce93836629522c2ff2a57226583009302271daf..969c78aef40aae497a76dd7f3e9c2305 + wanderingTraderControllable = getBoolean("mobs.wandering_trader.controllable", wanderingTraderControllable); + } + ++ public boolean wardenRidable = false; ++ public boolean wardenRidableInWater = false; ++ public boolean wardenControllable = true; ++ private void wardenSettings() { ++ wardenRidable = getBoolean("mobs.warden.ridable", wardenRidable); ++ wardenRidableInWater = getBoolean("mobs.warden.ridable-in-water", wardenRidableInWater); ++ wardenControllable = getBoolean("mobs.warden.controllable", wardenControllable); ++ } ++ + public boolean witchRidable = false; + public boolean witchRidableInWater = false; + public boolean witchControllable = true; @@ -5636,10 +5946,10 @@ index 0ce93836629522c2ff2a57226583009302271daf..969c78aef40aae497a76dd7f3e9c2305 } diff --git a/src/main/java/org/purpurmc/purpur/controller/FlyingMoveControllerWASD.java b/src/main/java/org/purpurmc/purpur/controller/FlyingMoveControllerWASD.java new file mode 100644 -index 0000000000000000000000000000000000000000..315d76526a1a9e95d29384e4598d8d77a27466c7 +index 0000000000000000000000000000000000000000..ed494e0ad278813a0eb261101447b84cca3ad7aa --- /dev/null +++ b/src/main/java/org/purpurmc/purpur/controller/FlyingMoveControllerWASD.java -@@ -0,0 +1,63 @@ +@@ -0,0 +1,71 @@ +package org.purpurmc.purpur.controller; + +import net.minecraft.world.entity.Mob; @@ -5648,21 +5958,27 @@ index 0000000000000000000000000000000000000000..315d76526a1a9e95d29384e4598d8d77 + +public class FlyingMoveControllerWASD extends MoveControllerWASD { + protected final float groundSpeedModifier; ++ protected final float flyingSpeedModifier; + protected int tooHighCooldown = 0; -+ protected boolean setGravityFlag = true; ++ protected boolean setNoGravityFlag; + + public FlyingMoveControllerWASD(Mob entity) { + this(entity, 1.0F); + } + + public FlyingMoveControllerWASD(Mob entity, float groundSpeedModifier) { -+ this(entity, groundSpeedModifier, true); ++ this(entity, groundSpeedModifier, 1.0F, true); + } + -+ public FlyingMoveControllerWASD(Mob entity, float groundSpeedModifier, boolean setGravityFlag) { ++ public FlyingMoveControllerWASD(Mob entity, float groundSpeedModifier, float flyingSpeedModifier) { ++ this(entity, groundSpeedModifier, flyingSpeedModifier, true); ++ } ++ ++ public FlyingMoveControllerWASD(Mob entity, float groundSpeedModifier, float flyingSpeedModifier, boolean setNoGravityFlag) { + super(entity); + this.groundSpeedModifier = groundSpeedModifier; -+ this.setGravityFlag = setGravityFlag; ++ this.flyingSpeedModifier = flyingSpeedModifier; ++ this.setNoGravityFlag = setNoGravityFlag; + } + + @Override @@ -5688,9 +6004,11 @@ index 0000000000000000000000000000000000000000..315d76526a1a9e95d29384e4598d8d77 + + if (entity.onGround) { + speed *= groundSpeedModifier; // TODO = fix this! ++ } else { ++ speed *= flyingSpeedModifier; + } + -+ if (setGravityFlag) { ++ if (setNoGravityFlag) { + entity.setNoGravity(forward > 0); + } + diff --git a/patches/server/0008-Configurable-entity-base-attributes.patch b/patches/server/0008-Configurable-entity-base-attributes.patch index 14d932a29..cba2be9c2 100644 --- a/patches/server/0008-Configurable-entity-base-attributes.patch +++ b/patches/server/0008-Configurable-entity-base-attributes.patch @@ -78,7 +78,7 @@ index 2edc11b093dbfc96d287dc9d3e208cc2a39c537e..007c945725721ddb8a3dc4b8085e8c68 @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 2c6e1a970d8922047a186fc7eb82abd7066b1fd9..21bd1f6f24715351d46573964438bcb7304575f5 100644 +index 1458079a5ffa8b4a50d30cfc01fa1b27b6a46f37..0fb1aa7bfbadc5e2df34391a4c9f0d045d576740 100644 --- a/src/main/java/net/minecraft/world/entity/animal/Bee.java +++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java @@ -214,6 +214,11 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal { @@ -735,10 +735,10 @@ index 079a85f1520cda6a0fb72d0dd7f9e18aec6a6c91..c1b67d5dc5fd533fb2aa28a5c7d9dd87 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 dd7bd70e0b905eea690c2d20b8438b9476d2badc..1005e47452f6437b75b050e695493647c92b7cf5 100644 +index 7a0653ae3bf1f9c99e3363fb27a9af30cbc2f27a..606fa521d577f832cd7a82c1c6c67414e1a01589 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 -@@ -212,6 +212,11 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -224,6 +224,11 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob skull.setPosRaw(headX, headY, headZ); level.addFreshEntity(skull); } @@ -750,7 +750,7 @@ index dd7bd70e0b905eea690c2d20b8438b9476d2badc..1005e47452f6437b75b050e695493647 // Purpur end @Override -@@ -416,7 +421,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -428,7 +433,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob this.setInvulnerableTicks(i); if (this.tickCount % 10 == 0) { @@ -1464,10 +1464,10 @@ index 2ae9a5da91ad20f1b566a686dcc8d4f14c62ecc5..8bfa041297db79e8f1452ce7059d1536 @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 969c78aef40aae497a76dd7f3e9c230577a8d31f..c38d9583d8ce50670d78b60d92c90d1d5eb4bbfc 100644 +index 4efbb008bd31a0316d3ceead6be27c6d38dd9f50..bf4c17c61dcc230286fe9ce4cb0855f0f710aad0 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -100,94 +100,166 @@ public class PurpurWorldConfig { +@@ -109,94 +109,166 @@ public class PurpurWorldConfig { public boolean axolotlRidable = false; public boolean axolotlControllable = true; @@ -1634,7 +1634,7 @@ index 969c78aef40aae497a76dd7f3e9c230577a8d31f..c38d9583d8ce50670d78b60d92c90d1d } public boolean dolphinRidable = false; -@@ -195,227 +267,477 @@ public class PurpurWorldConfig { +@@ -204,80 +276,161 @@ public class PurpurWorldConfig { public int dolphinSpitCooldown = 20; public float dolphinSpitSpeed = 1.0F; public float dolphinSpitDamage = 2.0F; @@ -1795,7 +1795,8 @@ index 969c78aef40aae497a76dd7f3e9c230577a8d31f..c38d9583d8ce50670d78b60d92c90d1d + foxMaxHealth = getDouble("mobs.fox.attributes.max_health", foxMaxHealth); } - public boolean ghastRidable = false; + public boolean frogRidable = false; +@@ -295,147 +448,316 @@ public class PurpurWorldConfig { public boolean ghastRidableInWater = false; public boolean ghastControllable = true; public double ghastMaxY = 320D; @@ -2112,7 +2113,7 @@ index 969c78aef40aae497a76dd7f3e9c230577a8d31f..c38d9583d8ce50670d78b60d92c90d1d } public boolean phantomRidable = false; -@@ -425,6 +747,10 @@ public class PurpurWorldConfig { +@@ -445,6 +767,10 @@ public class PurpurWorldConfig { public float phantomFlameDamage = 1.0F; public int phantomFlameFireTime = 8; public boolean phantomAllowGriefing = false; @@ -2123,7 +2124,7 @@ index 969c78aef40aae497a76dd7f3e9c230577a8d31f..c38d9583d8ce50670d78b60d92c90d1d private void phantomSettings() { phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable); phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater); -@@ -433,323 +759,638 @@ public class PurpurWorldConfig { +@@ -453,180 +779,350 @@ public class PurpurWorldConfig { phantomFlameDamage = (float) getDouble("mobs.phantom.flames.damage", phantomFlameDamage); phantomFlameFireTime = getInt("mobs.phantom.flames.fire-time", phantomFlameFireTime); phantomAllowGriefing = getBoolean("mobs.phantom.allow-griefing", phantomAllowGriefing); @@ -2473,6 +2474,8 @@ index 969c78aef40aae497a76dd7f3e9c230577a8d31f..c38d9583d8ce50670d78b60d92c90d1d + striderMaxHealth = getDouble("mobs.strider.attributes.max_health", striderMaxHealth); } + public boolean tadpoleRidable = false; +@@ -641,64 +1137,125 @@ public class PurpurWorldConfig { public boolean traderLlamaRidable = false; public boolean traderLlamaRidableInWater = false; public boolean traderLlamaControllable = true; @@ -2597,6 +2600,8 @@ index 969c78aef40aae497a76dd7f3e9c230577a8d31f..c38d9583d8ce50670d78b60d92c90d1d + wanderingTraderMaxHealth = getDouble("mobs.wandering_trader.attributes.max_health", wanderingTraderMaxHealth); } + public boolean wardenRidable = false; +@@ -713,81 +1270,165 @@ public class PurpurWorldConfig { public boolean witchRidable = false; public boolean witchRidableInWater = false; public boolean witchControllable = true; diff --git a/patches/server/0021-Configurable-villager-brain-ticks.patch b/patches/server/0021-Configurable-villager-brain-ticks.patch index 1da3f9ac5..a2b7c6b72 100644 --- a/patches/server/0021-Configurable-villager-brain-ticks.patch +++ b/patches/server/0021-Configurable-villager-brain-ticks.patch @@ -36,10 +36,10 @@ index ef08ec3eb88ee1ab624e2bd38aaff5e8f97720f2..4cb1cf2b51f1c58e2600996f1d67dcef this.getBrain().tick((ServerLevel) this.level, this); // Paper } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 81524c4f676766c09125187876b46e0704294880..93d89fb27044e5e97574122b0e7863694d245bf0 100644 +index 9dcdc3c57c774d260fb4849e7a90922101c0dd49..45f3d6daa4e3a90c55168da092595324af0a5a19 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1207,6 +1207,8 @@ public class PurpurWorldConfig { +@@ -1236,6 +1236,8 @@ public class PurpurWorldConfig { public boolean villagerRidableInWater = false; public boolean villagerControllable = true; public double villagerMaxHealth = 20.0D; @@ -48,7 +48,7 @@ index 81524c4f676766c09125187876b46e0704294880..93d89fb27044e5e97574122b0e786369 private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -1217,6 +1219,8 @@ public class PurpurWorldConfig { +@@ -1246,6 +1248,8 @@ public class PurpurWorldConfig { set("mobs.villager.attributes.max_health", oldValue); } villagerMaxHealth = getDouble("mobs.villager.attributes.max_health", villagerMaxHealth); diff --git a/patches/server/0028-Giants-AI-settings.patch b/patches/server/0028-Giants-AI-settings.patch index 32cd90d66..51919d489 100644 --- a/patches/server/0028-Giants-AI-settings.patch +++ b/patches/server/0028-Giants-AI-settings.patch @@ -120,10 +120,10 @@ index c1c5e884f00398032196ee71b55b348fcfce21ce..ed032918fb33d60c2d60d4db9275dddf } } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 4d9f7a90928fd4a3dd514799df3661f4ceb2ca36..336b214230600b8b1d223c65470820e388f676d9 100644 +index 39991fb579e6b0df221f62d544f4d0ab79d2a769..9b7d1b8c058f55045bb525511509c5e03e6aebaf 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -511,6 +511,10 @@ public class PurpurWorldConfig { +@@ -531,6 +531,10 @@ public class PurpurWorldConfig { public double giantMovementSpeed = 0.5D; public double giantAttackDamage = 50.0D; public double giantMaxHealth = 100.0D; @@ -134,7 +134,7 @@ index 4d9f7a90928fd4a3dd514799df3661f4ceb2ca36..336b214230600b8b1d223c65470820e3 private void giantSettings() { giantRidable = getBoolean("mobs.giant.ridable", giantRidable); giantRidableInWater = getBoolean("mobs.giant.ridable-in-water", giantRidableInWater); -@@ -527,6 +531,10 @@ public class PurpurWorldConfig { +@@ -547,6 +551,10 @@ public class PurpurWorldConfig { set("mobs.giant.attributes.max_health", oldValue); } giantMaxHealth = getDouble("mobs.giant.attributes.max_health", giantMaxHealth); diff --git a/patches/server/0029-Zombie-horse-naturally-spawn.patch b/patches/server/0029-Zombie-horse-naturally-spawn.patch index 2c87e9927..b29e8bb99 100644 --- a/patches/server/0029-Zombie-horse-naturally-spawn.patch +++ b/patches/server/0029-Zombie-horse-naturally-spawn.patch @@ -28,10 +28,10 @@ index cabd856dc050359bbeb1e138535e44bf2a294d5c..5f07e8669336d4ce27aa5f7837faf836 entityhorseskeleton.setPos((double) blockposition.getX(), (double) blockposition.getY(), (double) blockposition.getZ()); this.addFreshEntity(entityhorseskeleton, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.LIGHTNING); // CraftBukkit diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 336b214230600b8b1d223c65470820e388f676d9..6a5507be0f9a78855225437676865e15f06bcd9a 100644 +index 9b7d1b8c058f55045bb525511509c5e03e6aebaf..c9b639f8ec010146a325b007807b98019fcb3c2f 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1416,6 +1416,7 @@ public class PurpurWorldConfig { +@@ -1454,6 +1454,7 @@ public class PurpurWorldConfig { public double zombieHorseJumpStrengthMax = 1.0D; public double zombieHorseMovementSpeedMin = 0.2D; public double zombieHorseMovementSpeedMax = 0.2D; @@ -39,7 +39,7 @@ index 336b214230600b8b1d223c65470820e388f676d9..6a5507be0f9a78855225437676865e15 private void zombieHorseSettings() { zombieHorseRidableInWater = getBoolean("mobs.zombie_horse.ridable-in-water", zombieHorseRidableInWater); zombieHorseCanSwim = getBoolean("mobs.zombie_horse.can-swim", zombieHorseCanSwim); -@@ -1431,6 +1432,7 @@ public class PurpurWorldConfig { +@@ -1469,6 +1470,7 @@ public class PurpurWorldConfig { zombieHorseJumpStrengthMax = getDouble("mobs.zombie_horse.attributes.jump_strength.max", zombieHorseJumpStrengthMax); zombieHorseMovementSpeedMin = getDouble("mobs.zombie_horse.attributes.movement_speed.min", zombieHorseMovementSpeedMin); zombieHorseMovementSpeedMax = getDouble("mobs.zombie_horse.attributes.movement_speed.max", zombieHorseMovementSpeedMax); diff --git a/patches/server/0030-Charged-creeper-naturally-spawn.patch b/patches/server/0030-Charged-creeper-naturally-spawn.patch index e3c82ba1a..39aa4567e 100644 --- a/patches/server/0030-Charged-creeper-naturally-spawn.patch +++ b/patches/server/0030-Charged-creeper-naturally-spawn.patch @@ -24,10 +24,10 @@ index 0bf2355b7ac80227c06b3e85f1645559275a96e5..2a5f7fb0e60f41b6627255146ca18b27 @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 6a5507be0f9a78855225437676865e15f06bcd9a..a1d8065ef1ac0f065cf6bc030a8746e9418690aa 100644 +index c9b639f8ec010146a325b007807b98019fcb3c2f..e9b357ac289f7e72b4bbbcfdf71c9eac51b73cbd 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -313,6 +313,7 @@ public class PurpurWorldConfig { +@@ -322,6 +322,7 @@ public class PurpurWorldConfig { public boolean creeperRidableInWater = false; public boolean creeperControllable = true; public double creeperMaxHealth = 20.0D; @@ -35,7 +35,7 @@ index 6a5507be0f9a78855225437676865e15f06bcd9a..a1d8065ef1ac0f065cf6bc030a8746e9 private void creeperSettings() { creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable); creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater); -@@ -323,6 +324,7 @@ public class PurpurWorldConfig { +@@ -332,6 +333,7 @@ public class PurpurWorldConfig { set("mobs.creeper.attributes.max_health", oldValue); } creeperMaxHealth = getDouble("mobs.creeper.attributes.max_health", creeperMaxHealth); diff --git a/patches/server/0031-Rabbit-naturally-spawn-toast-and-killer.patch b/patches/server/0031-Rabbit-naturally-spawn-toast-and-killer.patch index 6fe299a8d..877fa1a59 100644 --- a/patches/server/0031-Rabbit-naturally-spawn-toast-and-killer.patch +++ b/patches/server/0031-Rabbit-naturally-spawn-toast-and-killer.patch @@ -38,10 +38,10 @@ index eaf040f10e33fdfb57391b6e7bc6901c87270853..47dc84052f1fb0017ff2e608c3f6d8b9 int i = world.getRandom().nextInt(100); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index a1d8065ef1ac0f065cf6bc030a8746e9418690aa..91f892e411b9f6ce2a64138ed3d3576b43e482ea 100644 +index e9b357ac289f7e72b4bbbcfdf71c9eac51b73cbd..a30300602f23001f14ff8e82854f653db2cb1e79 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -945,6 +945,8 @@ public class PurpurWorldConfig { +@@ -965,6 +965,8 @@ public class PurpurWorldConfig { public boolean rabbitRidableInWater = false; public boolean rabbitControllable = true; public double rabbitMaxHealth = 3.0D; @@ -50,7 +50,7 @@ index a1d8065ef1ac0f065cf6bc030a8746e9418690aa..91f892e411b9f6ce2a64138ed3d3576b private void rabbitSettings() { rabbitRidable = getBoolean("mobs.rabbit.ridable", rabbitRidable); rabbitRidableInWater = getBoolean("mobs.rabbit.ridable-in-water", rabbitRidableInWater); -@@ -955,6 +957,8 @@ public class PurpurWorldConfig { +@@ -975,6 +977,8 @@ public class PurpurWorldConfig { set("mobs.rabbit.attributes.max_health", oldValue); } rabbitMaxHealth = getDouble("mobs.rabbit.attributes.max_health", rabbitMaxHealth); diff --git a/patches/server/0033-Tulips-change-fox-type.patch b/patches/server/0033-Tulips-change-fox-type.patch index da7b8d34c..b44b88355 100644 --- a/patches/server/0033-Tulips-change-fox-type.patch +++ b/patches/server/0033-Tulips-change-fox-type.patch @@ -75,10 +75,10 @@ index 8d25d79be606b173a59264706172561165f82143..f03bd9a9129f0d45d36ef56a726d513a // Paper start - Cancellable death event protected org.bukkit.event.entity.EntityDeathEvent dropAllDeathLoot(DamageSource source) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 91f892e411b9f6ce2a64138ed3d3576b43e482ea..53a6c64338a77f22ee2293fbb85522ad51a97276 100644 +index a30300602f23001f14ff8e82854f653db2cb1e79..878321a8f3665c0b1577cc49ede54e7041187af7 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -477,6 +477,7 @@ public class PurpurWorldConfig { +@@ -486,6 +486,7 @@ public class PurpurWorldConfig { public boolean foxRidableInWater = false; public boolean foxControllable = true; public double foxMaxHealth = 10.0D; @@ -86,11 +86,11 @@ index 91f892e411b9f6ce2a64138ed3d3576b43e482ea..53a6c64338a77f22ee2293fbb85522ad private void foxSettings() { foxRidable = getBoolean("mobs.fox.ridable", foxRidable); foxRidableInWater = getBoolean("mobs.fox.ridable-in-water", foxRidableInWater); -@@ -487,6 +488,7 @@ public class PurpurWorldConfig { +@@ -496,6 +497,7 @@ public class PurpurWorldConfig { set("mobs.fox.attributes.max_health", oldValue); } foxMaxHealth = getDouble("mobs.fox.attributes.max_health", foxMaxHealth); + foxTypeChangesWithTulips = getBoolean("mobs.fox.tulips-change-type", foxTypeChangesWithTulips); } - public boolean ghastRidable = false; + public boolean frogRidable = false; diff --git a/patches/server/0034-Breedable-Polar-Bears.patch b/patches/server/0034-Breedable-Polar-Bears.patch index 5f74eb0db..09ef2ad83 100644 --- a/patches/server/0034-Breedable-Polar-Bears.patch +++ b/patches/server/0034-Breedable-Polar-Bears.patch @@ -59,10 +59,10 @@ index 798269a1098008e14fc2548e480c815fa4ff4d25..e68782ac48fd9ee11080dfd76c88d9a4 this.goalSelector.addGoal(5, new RandomStrollGoal(this, 1.0D)); this.goalSelector.addGoal(6, new LookAtPlayerGoal(this, Player.class, 6.0F)); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 53a6c64338a77f22ee2293fbb85522ad51a97276..ad0474ca08510f55cb20b2b5d11f7c4a7223b40e 100644 +index 878321a8f3665c0b1577cc49ede54e7041187af7..e35cec7207a48ec6632a1546e39bd3c2dc8b042e 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -917,6 +917,8 @@ public class PurpurWorldConfig { +@@ -937,6 +937,8 @@ public class PurpurWorldConfig { public boolean polarBearRidableInWater = false; public boolean polarBearControllable = true; public double polarBearMaxHealth = 30.0D; @@ -71,7 +71,7 @@ index 53a6c64338a77f22ee2293fbb85522ad51a97276..ad0474ca08510f55cb20b2b5d11f7c4a private void polarBearSettings() { polarBearRidable = getBoolean("mobs.polar_bear.ridable", polarBearRidable); polarBearRidableInWater = getBoolean("mobs.polar_bear.ridable-in-water", polarBearRidableInWater); -@@ -927,6 +929,9 @@ public class PurpurWorldConfig { +@@ -947,6 +949,9 @@ public class PurpurWorldConfig { set("mobs.polar_bear.attributes.max_health", oldValue); } polarBearMaxHealth = getDouble("mobs.polar_bear.attributes.max_health", polarBearMaxHealth); diff --git a/patches/server/0035-Chickens-can-retaliate.patch b/patches/server/0035-Chickens-can-retaliate.patch index 1919816a5..52489b1f4 100644 --- a/patches/server/0035-Chickens-can-retaliate.patch +++ b/patches/server/0035-Chickens-can-retaliate.patch @@ -51,10 +51,10 @@ index 8503a3393026134df18601ed87dcec1f3e6680b8..96dceb9943c4320e0edfba47cc211d60 @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ad0474ca08510f55cb20b2b5d11f7c4a7223b40e..62bb7fafb686170f8ae6d2f7c7b10d04365e433c 100644 +index e35cec7207a48ec6632a1546e39bd3c2dc8b042e..442e8dceeee7cd7e05bad5ce722b0dce121978ae 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -267,6 +267,7 @@ public class PurpurWorldConfig { +@@ -276,6 +276,7 @@ public class PurpurWorldConfig { public boolean chickenRidableInWater = false; public boolean chickenControllable = true; public double chickenMaxHealth = 4.0D; @@ -62,7 +62,7 @@ index ad0474ca08510f55cb20b2b5d11f7c4a7223b40e..62bb7fafb686170f8ae6d2f7c7b10d04 private void chickenSettings() { chickenRidable = getBoolean("mobs.chicken.ridable", chickenRidable); chickenRidableInWater = getBoolean("mobs.chicken.ridable-in-water", chickenRidableInWater); -@@ -277,6 +278,7 @@ public class PurpurWorldConfig { +@@ -286,6 +287,7 @@ public class PurpurWorldConfig { set("mobs.chicken.attributes.max_health", oldValue); } chickenMaxHealth = getDouble("mobs.chicken.attributes.max_health", chickenMaxHealth); diff --git a/patches/server/0037-Cat-spawning-options.patch b/patches/server/0037-Cat-spawning-options.patch index 0b9885d40..c3a825eb3 100644 --- a/patches/server/0037-Cat-spawning-options.patch +++ b/patches/server/0037-Cat-spawning-options.patch @@ -51,10 +51,10 @@ index 8808cb9f5df43d781cbb9c7943ff2f222e3a6969..f7e3ee98b006a53c3c6bf87fc90e5ef4 } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 7ab9864662b1a3de509e43b2177272078a7f3882..38f4ac177823bd6317d778163ae924c4869e8a91 100644 +index 1c47c36d1fd31a270b28f1e92a6855a6a236ffa6..b06c801bee4dade7d655ec3f29dd38713db201e4 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -240,6 +240,9 @@ public class PurpurWorldConfig { +@@ -249,6 +249,9 @@ public class PurpurWorldConfig { public boolean catRidableInWater = false; public boolean catControllable = true; public double catMaxHealth = 10.0D; @@ -64,7 +64,7 @@ index 7ab9864662b1a3de509e43b2177272078a7f3882..38f4ac177823bd6317d778163ae924c4 private void catSettings() { catRidable = getBoolean("mobs.cat.ridable", catRidable); catRidableInWater = getBoolean("mobs.cat.ridable-in-water", catRidableInWater); -@@ -250,6 +253,9 @@ public class PurpurWorldConfig { +@@ -259,6 +262,9 @@ public class PurpurWorldConfig { set("mobs.cat.attributes.max_health", oldValue); } catMaxHealth = getDouble("mobs.cat.attributes.max_health", catMaxHealth); diff --git a/patches/server/0039-Cows-eat-mushrooms.patch b/patches/server/0039-Cows-eat-mushrooms.patch index 4253c73ec..50ea272b1 100644 --- a/patches/server/0039-Cows-eat-mushrooms.patch +++ b/patches/server/0039-Cows-eat-mushrooms.patch @@ -114,10 +114,10 @@ index dd4d5e2e7cbfed18cf3b4664dbe08eaf9d95f61e..732c560383da3b8a270139758f29734d public Cow getBreedOffspring(ServerLevel world, AgeableMob entity) { return (Cow) EntityType.COW.create(world); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 38f4ac177823bd6317d778163ae924c4869e8a91..2108615ad64bac1e7b9d4950b9dd62407d16504a 100644 +index b06c801bee4dade7d655ec3f29dd38713db201e4..fcdfad2d539a65365e05ce9d49fd90e6febabecd 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -310,6 +310,7 @@ public class PurpurWorldConfig { +@@ -319,6 +319,7 @@ public class PurpurWorldConfig { public boolean cowRidableInWater = false; public boolean cowControllable = true; public double cowMaxHealth = 10.0D; @@ -125,7 +125,7 @@ index 38f4ac177823bd6317d778163ae924c4869e8a91..2108615ad64bac1e7b9d4950b9dd6240 private void cowSettings() { cowRidable = getBoolean("mobs.cow.ridable", cowRidable); cowRidableInWater = getBoolean("mobs.cow.ridable-in-water", cowRidableInWater); -@@ -320,6 +321,7 @@ public class PurpurWorldConfig { +@@ -329,6 +330,7 @@ public class PurpurWorldConfig { set("mobs.cow.attributes.max_health", oldValue); } cowMaxHealth = getDouble("mobs.cow.attributes.max_health", cowMaxHealth); diff --git a/patches/server/0041-Pigs-give-saddle-back.patch b/patches/server/0041-Pigs-give-saddle-back.patch index 1c63001d1..776e1be41 100644 --- a/patches/server/0041-Pigs-give-saddle-back.patch +++ b/patches/server/0041-Pigs-give-saddle-back.patch @@ -27,10 +27,10 @@ index a02476bdc34a4e3e0389abaf08687393cc3bff97..d4348bd3877813295d01d0171fee2d59 if (!this.level.isClientSide) { player.startRiding(this); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 2108615ad64bac1e7b9d4950b9dd62407d16504a..0d042476484fd6fd2e7ad98cb695e80be2e0a1d4 100644 +index fcdfad2d539a65365e05ce9d49fd90e6febabecd..3e7b24a03cb84255d05d8262fdce814731ba2cf5 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -868,6 +868,7 @@ public class PurpurWorldConfig { +@@ -888,6 +888,7 @@ public class PurpurWorldConfig { public boolean pigRidableInWater = false; public boolean pigControllable = true; public double pigMaxHealth = 10.0D; @@ -38,7 +38,7 @@ index 2108615ad64bac1e7b9d4950b9dd62407d16504a..0d042476484fd6fd2e7ad98cb695e80b private void pigSettings() { pigRidable = getBoolean("mobs.pig.ridable", pigRidable); pigRidableInWater = getBoolean("mobs.pig.ridable-in-water", pigRidableInWater); -@@ -878,6 +879,7 @@ public class PurpurWorldConfig { +@@ -898,6 +899,7 @@ public class PurpurWorldConfig { set("mobs.pig.attributes.max_health", oldValue); } pigMaxHealth = getDouble("mobs.pig.attributes.max_health", pigMaxHealth); diff --git a/patches/server/0042-Snowman-drop-and-put-back-pumpkin.patch b/patches/server/0042-Snowman-drop-and-put-back-pumpkin.patch index 108aa7755..b000bb88f 100644 --- a/patches/server/0042-Snowman-drop-and-put-back-pumpkin.patch +++ b/patches/server/0042-Snowman-drop-and-put-back-pumpkin.patch @@ -32,10 +32,10 @@ index e2f0f1d7ed8004a03f14887750a470e08ee1f42d..b4459d68397cc5bac4f7ef79a2dfb18f this.forceDrops = false; // CraftBukkit } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 0d042476484fd6fd2e7ad98cb695e80be2e0a1d4..54c0fe906604b14314125ff35322f75c84c1ee7d 100644 +index 3e7b24a03cb84255d05d8262fdce814731ba2cf5..3184fa1fb2cbd3862162a23e30a9994606b4b85b 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1131,6 +1131,8 @@ public class PurpurWorldConfig { +@@ -1151,6 +1151,8 @@ public class PurpurWorldConfig { public boolean snowGolemControllable = true; public boolean snowGolemLeaveTrailWhenRidden = false; public double snowGolemMaxHealth = 4.0D; @@ -44,7 +44,7 @@ index 0d042476484fd6fd2e7ad98cb695e80be2e0a1d4..54c0fe906604b14314125ff35322f75c private void snowGolemSettings() { snowGolemRidable = getBoolean("mobs.snow_golem.ridable", snowGolemRidable); snowGolemRidableInWater = getBoolean("mobs.snow_golem.ridable-in-water", snowGolemRidableInWater); -@@ -1142,6 +1144,8 @@ public class PurpurWorldConfig { +@@ -1162,6 +1164,8 @@ public class PurpurWorldConfig { set("mobs.snow_golem.attributes.max_health", oldValue); } snowGolemMaxHealth = getDouble("mobs.snow_golem.attributes.max_health", snowGolemMaxHealth); diff --git a/patches/server/0043-Ender-dragon-always-drop-full-exp.patch b/patches/server/0043-Ender-dragon-always-drop-full-exp.patch index ea03d9727..bd5732ed2 100644 --- a/patches/server/0043-Ender-dragon-always-drop-full-exp.patch +++ b/patches/server/0043-Ender-dragon-always-drop-full-exp.patch @@ -18,10 +18,10 @@ index c1b67d5dc5fd533fb2aa28a5c7d9dd87cc7412d8..9ce2527054f5163eae3d1216427378dc } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 54c0fe906604b14314125ff35322f75c84c1ee7d..fa3ae133ed06e4b57a4bc3ea2a32b5f1aef2636b 100644 +index 3184fa1fb2cbd3862162a23e30a9994606b4b85b..7b48454ddf2d838e8c1d418f8218fbf9b1578d38 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -423,6 +423,7 @@ public class PurpurWorldConfig { +@@ -432,6 +432,7 @@ public class PurpurWorldConfig { public boolean enderDragonControllable = true; public double enderDragonMaxY = 320D; public double enderDragonMaxHealth = 200.0D; @@ -29,7 +29,7 @@ index 54c0fe906604b14314125ff35322f75c84c1ee7d..fa3ae133ed06e4b57a4bc3ea2a32b5f1 private void enderDragonSettings() { enderDragonRidable = getBoolean("mobs.ender_dragon.ridable", enderDragonRidable); enderDragonRidableInWater = getBoolean("mobs.ender_dragon.ridable-in-water", enderDragonRidableInWater); -@@ -438,6 +439,7 @@ public class PurpurWorldConfig { +@@ -447,6 +448,7 @@ public class PurpurWorldConfig { set("mobs.ender_dragon.attributes.max_health", oldValue); } enderDragonMaxHealth = getDouble("mobs.ender_dragon.attributes.max_health", enderDragonMaxHealth); diff --git a/patches/server/0055-Add-enderman-and-creeper-griefing-controls.patch b/patches/server/0055-Add-enderman-and-creeper-griefing-controls.patch index 435d88794..00ecb2334 100644 --- a/patches/server/0055-Add-enderman-and-creeper-griefing-controls.patch +++ b/patches/server/0055-Add-enderman-and-creeper-griefing-controls.patch @@ -38,10 +38,10 @@ index d86aeb3f91a01206e7cb13caae3e5c571a73952c..ad47267eb6797e1591841cb7a576fb65 } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 725d29b3e79e45d95635b73c9ea783ff2a04ad39..ce46f2530aad6f2fb96618b101f5dfdec974908e 100644 +index ca4c6ed817cb2b4b53ea48ecc962564d3576d7d9..9c7f40cb3af6dd288ff296b5db503da53b789f78 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -410,6 +410,7 @@ public class PurpurWorldConfig { +@@ -419,6 +419,7 @@ public class PurpurWorldConfig { public boolean creeperControllable = true; public double creeperMaxHealth = 20.0D; public double creeperChargedChance = 0.0D; @@ -49,7 +49,7 @@ index 725d29b3e79e45d95635b73c9ea783ff2a04ad39..ce46f2530aad6f2fb96618b101f5dfde private void creeperSettings() { creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable); creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater); -@@ -421,6 +422,7 @@ public class PurpurWorldConfig { +@@ -430,6 +431,7 @@ public class PurpurWorldConfig { } creeperMaxHealth = getDouble("mobs.creeper.attributes.max_health", creeperMaxHealth); creeperChargedChance = getDouble("mobs.creeper.naturally-charged-chance", creeperChargedChance); @@ -57,7 +57,7 @@ index 725d29b3e79e45d95635b73c9ea783ff2a04ad39..ce46f2530aad6f2fb96618b101f5dfde } public boolean dolphinRidable = false; -@@ -527,6 +529,7 @@ public class PurpurWorldConfig { +@@ -536,6 +538,7 @@ public class PurpurWorldConfig { public boolean endermanRidableInWater = false; public boolean endermanControllable = true; public double endermanMaxHealth = 40.0D; @@ -65,7 +65,7 @@ index 725d29b3e79e45d95635b73c9ea783ff2a04ad39..ce46f2530aad6f2fb96618b101f5dfde private void endermanSettings() { endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable); endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater); -@@ -537,6 +540,7 @@ public class PurpurWorldConfig { +@@ -546,6 +549,7 @@ public class PurpurWorldConfig { set("mobs.enderman.attributes.max_health", oldValue); } endermanMaxHealth = getDouble("mobs.enderman.attributes.max_health", endermanMaxHealth); diff --git a/patches/server/0056-Villagers-follow-emerald-blocks.patch b/patches/server/0056-Villagers-follow-emerald-blocks.patch index 42acca064..3803d4a9c 100644 --- a/patches/server/0056-Villagers-follow-emerald-blocks.patch +++ b/patches/server/0056-Villagers-follow-emerald-blocks.patch @@ -54,10 +54,10 @@ index 8bfa041297db79e8f1452ce7059d1536a6e2854f..615fdf709b81693cced9a208cc96a33f this.goalSelector.addGoal(8, new WaterAvoidingRandomStrollGoal(this, 0.35D)); this.goalSelector.addGoal(9, new InteractGoal(this, Player.class, 3.0F, 1.0F)); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ce46f2530aad6f2fb96618b101f5dfdec974908e..11e9eeeb1ef515ea65701629f61b2a74c5986412 100644 +index 9c7f40cb3af6dd288ff296b5db503da53b789f78..3708e26b4ed8766a835decff5c97b6f687391bed 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1379,6 +1379,7 @@ public class PurpurWorldConfig { +@@ -1408,6 +1408,7 @@ public class PurpurWorldConfig { public double villagerMaxHealth = 20.0D; public int villagerBrainTicks = 1; public boolean villagerUseBrainTicksOnlyWhenLagging = true; @@ -65,7 +65,7 @@ index ce46f2530aad6f2fb96618b101f5dfdec974908e..11e9eeeb1ef515ea65701629f61b2a74 private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -1391,6 +1392,7 @@ public class PurpurWorldConfig { +@@ -1420,6 +1421,7 @@ public class PurpurWorldConfig { villagerMaxHealth = getDouble("mobs.villager.attributes.max_health", villagerMaxHealth); villagerBrainTicks = getInt("mobs.villager.brain-ticks", villagerBrainTicks); villagerUseBrainTicksOnlyWhenLagging = getBoolean("mobs.villager.use-brain-ticks-only-when-lagging", villagerUseBrainTicksOnlyWhenLagging); @@ -73,7 +73,7 @@ index ce46f2530aad6f2fb96618b101f5dfdec974908e..11e9eeeb1ef515ea65701629f61b2a74 } public boolean vindicatorRidable = false; -@@ -1413,6 +1415,7 @@ public class PurpurWorldConfig { +@@ -1442,6 +1444,7 @@ public class PurpurWorldConfig { public boolean wanderingTraderRidableInWater = false; public boolean wanderingTraderControllable = true; public double wanderingTraderMaxHealth = 20.0D; @@ -81,11 +81,11 @@ index ce46f2530aad6f2fb96618b101f5dfdec974908e..11e9eeeb1ef515ea65701629f61b2a74 private void wanderingTraderSettings() { wanderingTraderRidable = getBoolean("mobs.wandering_trader.ridable", wanderingTraderRidable); wanderingTraderRidableInWater = getBoolean("mobs.wandering_trader.ridable-in-water", wanderingTraderRidableInWater); -@@ -1423,6 +1426,7 @@ public class PurpurWorldConfig { +@@ -1452,6 +1455,7 @@ public class PurpurWorldConfig { set("mobs.wandering_trader.attributes.max_health", oldValue); } wanderingTraderMaxHealth = getDouble("mobs.wandering_trader.attributes.max_health", wanderingTraderMaxHealth); + wanderingTraderFollowEmeraldBlock = getBoolean("mobs.wandering_trader.follow-emerald-blocks", wanderingTraderFollowEmeraldBlock); } - public boolean witchRidable = false; + public boolean wardenRidable = false; diff --git a/patches/server/0057-Allow-leashing-villagers.patch b/patches/server/0057-Allow-leashing-villagers.patch index d607dc6be..9dc4f95b4 100644 --- a/patches/server/0057-Allow-leashing-villagers.patch +++ b/patches/server/0057-Allow-leashing-villagers.patch @@ -49,10 +49,10 @@ index 615fdf709b81693cced9a208cc96a33fb686c9a1..8756e0d8d0077308f5fb74bf45fe093d @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 11e9eeeb1ef515ea65701629f61b2a74c5986412..9cab405a67c76e920754d0ba10978cf5476f1b82 100644 +index 3708e26b4ed8766a835decff5c97b6f687391bed..a361faa6723067fb0f9bac1fc9036d92cb0cd9ef 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1380,6 +1380,7 @@ public class PurpurWorldConfig { +@@ -1409,6 +1409,7 @@ public class PurpurWorldConfig { public int villagerBrainTicks = 1; public boolean villagerUseBrainTicksOnlyWhenLagging = true; public boolean villagerFollowEmeraldBlock = false; @@ -60,7 +60,7 @@ index 11e9eeeb1ef515ea65701629f61b2a74c5986412..9cab405a67c76e920754d0ba10978cf5 private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -1393,6 +1394,7 @@ public class PurpurWorldConfig { +@@ -1422,6 +1423,7 @@ public class PurpurWorldConfig { villagerBrainTicks = getInt("mobs.villager.brain-ticks", villagerBrainTicks); villagerUseBrainTicksOnlyWhenLagging = getBoolean("mobs.villager.use-brain-ticks-only-when-lagging", villagerUseBrainTicksOnlyWhenLagging); villagerFollowEmeraldBlock = getBoolean("mobs.villager.follow-emerald-blocks", villagerFollowEmeraldBlock); @@ -68,7 +68,7 @@ index 11e9eeeb1ef515ea65701629f61b2a74c5986412..9cab405a67c76e920754d0ba10978cf5 } public boolean vindicatorRidable = false; -@@ -1416,6 +1418,7 @@ public class PurpurWorldConfig { +@@ -1445,6 +1447,7 @@ public class PurpurWorldConfig { public boolean wanderingTraderControllable = true; public double wanderingTraderMaxHealth = 20.0D; public boolean wanderingTraderFollowEmeraldBlock = false; @@ -76,11 +76,11 @@ index 11e9eeeb1ef515ea65701629f61b2a74c5986412..9cab405a67c76e920754d0ba10978cf5 private void wanderingTraderSettings() { wanderingTraderRidable = getBoolean("mobs.wandering_trader.ridable", wanderingTraderRidable); wanderingTraderRidableInWater = getBoolean("mobs.wandering_trader.ridable-in-water", wanderingTraderRidableInWater); -@@ -1427,6 +1430,7 @@ public class PurpurWorldConfig { +@@ -1456,6 +1459,7 @@ public class PurpurWorldConfig { } wanderingTraderMaxHealth = getDouble("mobs.wandering_trader.attributes.max_health", wanderingTraderMaxHealth); wanderingTraderFollowEmeraldBlock = getBoolean("mobs.wandering_trader.follow-emerald-blocks", wanderingTraderFollowEmeraldBlock); + wanderingTraderCanBeLeashed = getBoolean("mobs.wandering_trader.can-be-leashed", wanderingTraderCanBeLeashed); } - public boolean witchRidable = false; + public boolean wardenRidable = false; diff --git a/patches/server/0062-Add-canSaveToDisk-to-Entity.patch b/patches/server/0062-Add-canSaveToDisk-to-Entity.patch index 5e0eb2c99..5d1acdd13 100644 --- a/patches/server/0062-Add-canSaveToDisk-to-Entity.patch +++ b/patches/server/0062-Add-canSaveToDisk-to-Entity.patch @@ -19,10 +19,10 @@ index d032cd8054bcba9fd29ea62b234e6453e0a44adf..c5898834338046237d2690fd82443ac6 // Purpur end } 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 1005e47452f6437b75b050e695493647c92b7cf5..d88012af58aedf5f92885d74e69b06f5cf98aa71 100644 +index 606fa521d577f832cd7a82c1c6c67414e1a01589..7c2c5b5205c7b422903fb6984f2b411d20189b22 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 -@@ -208,6 +208,11 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -220,6 +220,11 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob // do not hit rider return target != rider && super.canHitEntity(target); } diff --git a/patches/server/0072-Configurable-jockey-options.patch b/patches/server/0072-Configurable-jockey-options.patch index 640b38042..c5100c226 100644 --- a/patches/server/0072-Configurable-jockey-options.patch +++ b/patches/server/0072-Configurable-jockey-options.patch @@ -167,10 +167,10 @@ index bc3ffb8867d5f7c2fa548d31256341d388bf8112..6c1dd723373f9b1b920548de85aeb6ce @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ca30699fde62277e6794d4ba0b829287cfc7c651..8e598f4cfcf0cda4829471cd81f2ae9146caff3b 100644 +index fb1d389cdfa47726718552fd92cf0035858792df..04e27b028782b46db7fc88d1ba14a4da2ba6a3f9 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -565,6 +565,9 @@ public class PurpurWorldConfig { +@@ -574,6 +574,9 @@ public class PurpurWorldConfig { public boolean drownedControllable = true; public double drownedMaxHealth = 20.0D; public double drownedSpawnReinforcements = 0.1D; @@ -180,7 +180,7 @@ index ca30699fde62277e6794d4ba0b829287cfc7c651..8e598f4cfcf0cda4829471cd81f2ae91 private void drownedSettings() { drownedRidable = getBoolean("mobs.drowned.ridable", drownedRidable); drownedRidableInWater = getBoolean("mobs.drowned.ridable-in-water", drownedRidableInWater); -@@ -576,6 +579,9 @@ public class PurpurWorldConfig { +@@ -585,6 +588,9 @@ public class PurpurWorldConfig { } drownedMaxHealth = getDouble("mobs.drowned.attributes.max_health", drownedMaxHealth); drownedSpawnReinforcements = getDouble("mobs.drowned.attributes.spawn_reinforcements", drownedSpawnReinforcements); @@ -190,7 +190,7 @@ index ca30699fde62277e6794d4ba0b829287cfc7c651..8e598f4cfcf0cda4829471cd81f2ae91 } public boolean elderGuardianRidable = false; -@@ -813,6 +819,9 @@ public class PurpurWorldConfig { +@@ -833,6 +839,9 @@ public class PurpurWorldConfig { public boolean huskControllable = true; public double huskMaxHealth = 20.0D; public double huskSpawnReinforcements = 0.1D; @@ -200,7 +200,7 @@ index ca30699fde62277e6794d4ba0b829287cfc7c651..8e598f4cfcf0cda4829471cd81f2ae91 private void huskSettings() { huskRidable = getBoolean("mobs.husk.ridable", huskRidable); huskRidableInWater = getBoolean("mobs.husk.ridable-in-water", huskRidableInWater); -@@ -824,6 +833,9 @@ public class PurpurWorldConfig { +@@ -844,6 +853,9 @@ public class PurpurWorldConfig { } huskMaxHealth = getDouble("mobs.husk.attributes.max_health", huskMaxHealth); huskSpawnReinforcements = getDouble("mobs.husk.attributes.spawn_reinforcements", huskSpawnReinforcements); @@ -210,7 +210,7 @@ index ca30699fde62277e6794d4ba0b829287cfc7c651..8e598f4cfcf0cda4829471cd81f2ae91 } public boolean illusionerRidable = false; -@@ -1615,6 +1627,9 @@ public class PurpurWorldConfig { +@@ -1653,6 +1665,9 @@ public class PurpurWorldConfig { public boolean zombieControllable = true; public double zombieMaxHealth = 20.0D; public double zombieSpawnReinforcements = 0.1D; @@ -220,7 +220,7 @@ index ca30699fde62277e6794d4ba0b829287cfc7c651..8e598f4cfcf0cda4829471cd81f2ae91 private void zombieSettings() { zombieRidable = getBoolean("mobs.zombie.ridable", zombieRidable); zombieRidableInWater = getBoolean("mobs.zombie.ridable-in-water", zombieRidableInWater); -@@ -1626,6 +1641,9 @@ public class PurpurWorldConfig { +@@ -1664,6 +1679,9 @@ public class PurpurWorldConfig { } zombieMaxHealth = getDouble("mobs.zombie.attributes.max_health", zombieMaxHealth); zombieSpawnReinforcements = getDouble("mobs.zombie.attributes.spawn_reinforcements", zombieSpawnReinforcements); @@ -230,7 +230,7 @@ index ca30699fde62277e6794d4ba0b829287cfc7c651..8e598f4cfcf0cda4829471cd81f2ae91 } public boolean zombieHorseRidableInWater = false; -@@ -1660,6 +1678,9 @@ public class PurpurWorldConfig { +@@ -1698,6 +1716,9 @@ public class PurpurWorldConfig { public boolean zombieVillagerControllable = true; public double zombieVillagerMaxHealth = 20.0D; public double zombieVillagerSpawnReinforcements = 0.1D; @@ -240,7 +240,7 @@ index ca30699fde62277e6794d4ba0b829287cfc7c651..8e598f4cfcf0cda4829471cd81f2ae91 private void zombieVillagerSettings() { zombieVillagerRidable = getBoolean("mobs.zombie_villager.ridable", zombieVillagerRidable); zombieVillagerRidableInWater = getBoolean("mobs.zombie_villager.ridable-in-water", zombieVillagerRidableInWater); -@@ -1671,6 +1692,9 @@ public class PurpurWorldConfig { +@@ -1709,6 +1730,9 @@ public class PurpurWorldConfig { } zombieVillagerMaxHealth = getDouble("mobs.zombie_villager.attributes.max_health", zombieVillagerMaxHealth); zombieVillagerSpawnReinforcements = getDouble("mobs.zombie_villager.attributes.spawn_reinforcements", zombieVillagerSpawnReinforcements); @@ -250,7 +250,7 @@ index ca30699fde62277e6794d4ba0b829287cfc7c651..8e598f4cfcf0cda4829471cd81f2ae91 } public boolean zombifiedPiglinRidable = false; -@@ -1678,6 +1702,9 @@ public class PurpurWorldConfig { +@@ -1716,6 +1740,9 @@ public class PurpurWorldConfig { public boolean zombifiedPiglinControllable = true; public double zombifiedPiglinMaxHealth = 20.0D; public double zombifiedPiglinSpawnReinforcements = 0.0D; @@ -260,7 +260,7 @@ index ca30699fde62277e6794d4ba0b829287cfc7c651..8e598f4cfcf0cda4829471cd81f2ae91 private void zombifiedPiglinSettings() { zombifiedPiglinRidable = getBoolean("mobs.zombified_piglin.ridable", zombifiedPiglinRidable); zombifiedPiglinRidableInWater = getBoolean("mobs.zombified_piglin.ridable-in-water", zombifiedPiglinRidableInWater); -@@ -1689,5 +1716,8 @@ public class PurpurWorldConfig { +@@ -1727,5 +1754,8 @@ public class PurpurWorldConfig { } zombifiedPiglinMaxHealth = getDouble("mobs.zombified_piglin.attributes.max_health", zombifiedPiglinMaxHealth); zombifiedPiglinSpawnReinforcements = getDouble("mobs.zombified_piglin.attributes.spawn_reinforcements", zombifiedPiglinSpawnReinforcements); diff --git a/patches/server/0073-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch b/patches/server/0073-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch index ca8025fbd..5d73eba52 100644 --- a/patches/server/0073-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch +++ b/patches/server/0073-Phantoms-attracted-to-crystals-and-crystals-shoot-ph.patch @@ -258,10 +258,10 @@ index a3b871797c3e006f66978a73da01fede52fc8c49..9c82953b45471a40faea41f164feabbd private float speed = 0.1F; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 8e598f4cfcf0cda4829471cd81f2ae9146caff3b..ee8b661523b274c72771dd781d6ff90621d78742 100644 +index 04e27b028782b46db7fc88d1ba14a4da2ba6a3f9..4fad53692a12bf47dc7074df1b3956e81ccdab30 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1031,6 +1031,9 @@ public class PurpurWorldConfig { +@@ -1051,6 +1051,9 @@ public class PurpurWorldConfig { public String phantomAttackDamage = "6 + size"; public Map phantomMaxHealthCache = new HashMap<>(); public Map phantomAttackDamageCache = new HashMap<>(); @@ -271,7 +271,7 @@ index 8e598f4cfcf0cda4829471cd81f2ae9146caff3b..ee8b661523b274c72771dd781d6ff906 private void phantomSettings() { phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable); phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater); -@@ -1052,6 +1055,9 @@ public class PurpurWorldConfig { +@@ -1072,6 +1075,9 @@ public class PurpurWorldConfig { phantomAttackDamage = getString("mobs.phantom.attributes.attack_damage", phantomAttackDamage); phantomMaxHealthCache.clear(); phantomAttackDamageCache.clear(); diff --git a/patches/server/0074-Add-phantom-spawning-options.patch b/patches/server/0074-Add-phantom-spawning-options.patch index efab0dec9..59e1199e8 100644 --- a/patches/server/0074-Add-phantom-spawning-options.patch +++ b/patches/server/0074-Add-phantom-spawning-options.patch @@ -48,10 +48,10 @@ index 6b5c31470499e25d01936106839c2fff21b113c8..cbf4a7ca1f09d156eed12030fafb7240 for (int l = 0; l < k; ++l) { // Paper start diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ee8b661523b274c72771dd781d6ff90621d78742..485e7cfd0c0da45129c0b1a0cd95c5d14d0e0a06 100644 +index 4fad53692a12bf47dc7074df1b3956e81ccdab30..9903ab606d08d51643dfbf45e48a2296f312e0de 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1034,6 +1034,18 @@ public class PurpurWorldConfig { +@@ -1054,6 +1054,18 @@ public class PurpurWorldConfig { public double phantomAttackedByCrystalRadius = 0.0D; public float phantomAttackedByCrystalDamage = 1.0F; public double phantomOrbitCrystalRadius = 0.0D; @@ -70,7 +70,7 @@ index ee8b661523b274c72771dd781d6ff90621d78742..485e7cfd0c0da45129c0b1a0cd95c5d1 private void phantomSettings() { phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable); phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater); -@@ -1058,6 +1070,18 @@ public class PurpurWorldConfig { +@@ -1078,6 +1090,18 @@ public class PurpurWorldConfig { phantomAttackedByCrystalRadius = getDouble("mobs.phantom.attacked-by-crystal-range", phantomAttackedByCrystalRadius); phantomAttackedByCrystalDamage = (float) getDouble("mobs.phantom.attacked-by-crystal-damage", phantomAttackedByCrystalDamage); phantomOrbitCrystalRadius = getDouble("mobs.phantom.orbit-crystal-radius", phantomOrbitCrystalRadius); diff --git a/patches/server/0081-Squid-EAR-immunity.patch b/patches/server/0081-Squid-EAR-immunity.patch index e1ad78ffc..a290bec17 100644 --- a/patches/server/0081-Squid-EAR-immunity.patch +++ b/patches/server/0081-Squid-EAR-immunity.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Squid EAR immunity diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index a28d11edcf87f3e01477e8d7aa70b8a822b76fa6..ecb950c9e43e952b95d47e49c5c4d64199e49398 100644 +index e44b6b03e90a52f5b3e411fb78a3050287a23431..0c937d5b07101735b43c15398b1c8b2e45dcec66 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1410,6 +1410,7 @@ public class PurpurWorldConfig { +@@ -1430,6 +1430,7 @@ public class PurpurWorldConfig { public boolean squidRidable = false; public boolean squidControllable = true; public double squidMaxHealth = 10.0D; @@ -16,7 +16,7 @@ index a28d11edcf87f3e01477e8d7aa70b8a822b76fa6..ecb950c9e43e952b95d47e49c5c4d641 private void squidSettings() { squidRidable = getBoolean("mobs.squid.ridable", squidRidable); squidControllable = getBoolean("mobs.squid.controllable", squidControllable); -@@ -1419,6 +1420,7 @@ public class PurpurWorldConfig { +@@ -1439,6 +1440,7 @@ public class PurpurWorldConfig { set("mobs.squid.attributes.max_health", oldValue); } squidMaxHealth = getDouble("mobs.squid.attributes.max_health", squidMaxHealth); diff --git a/patches/server/0082-Phantoms-burn-in-light.patch b/patches/server/0082-Phantoms-burn-in-light.patch index 4ad138f06..8b66f3deb 100644 --- a/patches/server/0082-Phantoms-burn-in-light.patch +++ b/patches/server/0082-Phantoms-burn-in-light.patch @@ -53,10 +53,10 @@ index 9c82953b45471a40faea41f164feabbd2af02984..82d56a6968f3bbea5a2d32c2a7a84a8b list.sort(Comparator.comparing((Entity e) -> { return e.getY(); }).reversed()); // CraftBukkit - decompile error Iterator iterator = list.iterator(); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ecb950c9e43e952b95d47e49c5c4d64199e49398..02c170ca3cba59ad673cfa4f976ca6927067499c 100644 +index 0c937d5b07101735b43c15398b1c8b2e45dcec66..2da33e0b656b0265bcfdd814b53e132cb88b0dee 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1085,6 +1085,9 @@ public class PurpurWorldConfig { +@@ -1105,6 +1105,9 @@ public class PurpurWorldConfig { public int phantomSpawnOverheadRadius = 10; public int phantomSpawnMinPerAttempt = 1; public int phantomSpawnMaxPerAttempt = -1; @@ -66,7 +66,7 @@ index ecb950c9e43e952b95d47e49c5c4d64199e49398..02c170ca3cba59ad673cfa4f976ca692 private void phantomSettings() { phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable); phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater); -@@ -1121,6 +1124,9 @@ public class PurpurWorldConfig { +@@ -1141,6 +1144,9 @@ public class PurpurWorldConfig { phantomSpawnOverheadRadius = getInt("mobs.phantom.spawn.overhead.radius", phantomSpawnOverheadRadius); phantomSpawnMinPerAttempt = getInt("mobs.phantom.spawn.per-attempt.min", phantomSpawnMinPerAttempt); phantomSpawnMaxPerAttempt = getInt("mobs.phantom.spawn.per-attempt.max", phantomSpawnMaxPerAttempt); diff --git a/patches/server/0083-Configurable-villager-breeding.patch b/patches/server/0083-Configurable-villager-breeding.patch index 92437f1d0..a23f7c6e1 100644 --- a/patches/server/0083-Configurable-villager-breeding.patch +++ b/patches/server/0083-Configurable-villager-breeding.patch @@ -18,10 +18,10 @@ index 2087b4a4fbc4076c5ec59aaf73f1367ffcd0ef7c..09a7af00e05f5369c1c87c51f121ed34 private boolean hungry() { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 02c170ca3cba59ad673cfa4f976ca6927067499c..9b5a45643f288cab8725d1d9050b9d97ea9f97ae 100644 +index 2da33e0b656b0265bcfdd814b53e132cb88b0dee..d224e0586472779ee0205a939e2f0173fa0aed8d 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1561,6 +1561,7 @@ public class PurpurWorldConfig { +@@ -1590,6 +1590,7 @@ public class PurpurWorldConfig { public boolean villagerUseBrainTicksOnlyWhenLagging = true; public boolean villagerFollowEmeraldBlock = false; public boolean villagerCanBeLeashed = false; @@ -29,7 +29,7 @@ index 02c170ca3cba59ad673cfa4f976ca6927067499c..9b5a45643f288cab8725d1d9050b9d97 private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -1575,6 +1576,7 @@ public class PurpurWorldConfig { +@@ -1604,6 +1605,7 @@ public class PurpurWorldConfig { villagerUseBrainTicksOnlyWhenLagging = getBoolean("mobs.villager.use-brain-ticks-only-when-lagging", villagerUseBrainTicksOnlyWhenLagging); villagerFollowEmeraldBlock = getBoolean("mobs.villager.follow-emerald-blocks", villagerFollowEmeraldBlock); villagerCanBeLeashed = getBoolean("mobs.villager.can-be-leashed", villagerCanBeLeashed); diff --git a/patches/server/0086-Add-vindicator-johnny-spawn-chance.patch b/patches/server/0086-Add-vindicator-johnny-spawn-chance.patch index 8ce7584b5..dc5a4e1fe 100644 --- a/patches/server/0086-Add-vindicator-johnny-spawn-chance.patch +++ b/patches/server/0086-Add-vindicator-johnny-spawn-chance.patch @@ -22,10 +22,10 @@ index c3b8bce2d8e1dccb619267923964e06abfed8762..021550a0465dd1fd152b4c2e76301405 } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index bce43c499ef75131ae637ae8d089517f34602357..59597a70f60ccad348dfe56985358cbae8c558e7 100644 +index 529193b0b6b0e2883688c3b1e3ca4bbe315267f8..5761da1c9f712c93b40bb9c67910fb6736150b10 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1590,6 +1590,7 @@ public class PurpurWorldConfig { +@@ -1619,6 +1619,7 @@ public class PurpurWorldConfig { public boolean vindicatorRidableInWater = false; public boolean vindicatorControllable = true; public double vindicatorMaxHealth = 24.0D; @@ -33,7 +33,7 @@ index bce43c499ef75131ae637ae8d089517f34602357..59597a70f60ccad348dfe56985358cba private void vindicatorSettings() { vindicatorRidable = getBoolean("mobs.vindicator.ridable", vindicatorRidable); vindicatorRidableInWater = getBoolean("mobs.vindicator.ridable-in-water", vindicatorRidableInWater); -@@ -1600,6 +1601,7 @@ public class PurpurWorldConfig { +@@ -1629,6 +1630,7 @@ public class PurpurWorldConfig { set("mobs.vindicator.attributes.max_health", oldValue); } vindicatorMaxHealth = getDouble("mobs.vindicator.attributes.max_health", vindicatorMaxHealth); diff --git a/patches/server/0090-Add-option-to-disable-dolphin-treasure-searching.patch b/patches/server/0090-Add-option-to-disable-dolphin-treasure-searching.patch index 44be7ef03..afec6d488 100644 --- a/patches/server/0090-Add-option-to-disable-dolphin-treasure-searching.patch +++ b/patches/server/0090-Add-option-to-disable-dolphin-treasure-searching.patch @@ -17,10 +17,10 @@ index b3e53f922a424a407adb0111c29c8be6f89f8115..b52245d881186f91174819326abb0cf9 } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 4d474c2d2f6c1a7a28daba2d9886cf6e5e12b343..83b2b1d04b3df0eaa3ecdca5186f7b36daaec007 100644 +index fdad39e4a639c46e3ce15bbf77a854f532a4d655..1f1a4a2022ac3111c3761e51662de12ba28c32ec 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -575,6 +575,7 @@ public class PurpurWorldConfig { +@@ -584,6 +584,7 @@ public class PurpurWorldConfig { public float dolphinSpitSpeed = 1.0F; public float dolphinSpitDamage = 2.0F; public double dolphinMaxHealth = 10.0D; @@ -28,7 +28,7 @@ index 4d474c2d2f6c1a7a28daba2d9886cf6e5e12b343..83b2b1d04b3df0eaa3ecdca5186f7b36 private void dolphinSettings() { dolphinRidable = getBoolean("mobs.dolphin.ridable", dolphinRidable); dolphinControllable = getBoolean("mobs.dolphin.controllable", dolphinControllable); -@@ -587,6 +588,7 @@ public class PurpurWorldConfig { +@@ -596,6 +597,7 @@ public class PurpurWorldConfig { set("mobs.dolphin.attributes.max_health", oldValue); } dolphinMaxHealth = getDouble("mobs.dolphin.attributes.max_health", dolphinMaxHealth); diff --git a/patches/server/0092-Stop-squids-floating-on-top-of-water.patch b/patches/server/0092-Stop-squids-floating-on-top-of-water.patch index 5bb6b9982..1ee03d5bc 100644 --- a/patches/server/0092-Stop-squids-floating-on-top-of-water.patch +++ b/patches/server/0092-Stop-squids-floating-on-top-of-water.patch @@ -54,10 +54,10 @@ index 68cc6f2a78a06293a29317fda72ab3ee79b3533a..cfb2e46b34b2982d6724f18214557fc8 + // Purpur } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 83b2b1d04b3df0eaa3ecdca5186f7b36daaec007..68451f2c85e723dcb4835b4c0aeaffaf2f79bc3a 100644 +index 1f1a4a2022ac3111c3761e51662de12ba28c32ec..8f15e760ab50bc8add8de89a4922e99613dfb076 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1433,6 +1433,7 @@ public class PurpurWorldConfig { +@@ -1453,6 +1453,7 @@ public class PurpurWorldConfig { public boolean squidControllable = true; public double squidMaxHealth = 10.0D; public boolean squidImmuneToEAR = true; @@ -65,7 +65,7 @@ index 83b2b1d04b3df0eaa3ecdca5186f7b36daaec007..68451f2c85e723dcb4835b4c0aeaffaf private void squidSettings() { squidRidable = getBoolean("mobs.squid.ridable", squidRidable); squidControllable = getBoolean("mobs.squid.controllable", squidControllable); -@@ -1443,6 +1444,7 @@ public class PurpurWorldConfig { +@@ -1463,6 +1464,7 @@ public class PurpurWorldConfig { } squidMaxHealth = getDouble("mobs.squid.attributes.max_health", squidMaxHealth); squidImmuneToEAR = getBoolean("mobs.squid.immune-to-EAR", squidImmuneToEAR); diff --git a/patches/server/0096-Customizable-wither-health-and-healing.patch b/patches/server/0096-Customizable-wither-health-and-healing.patch index becce1b49..3018d7256 100644 --- a/patches/server/0096-Customizable-wither-health-and-healing.patch +++ b/patches/server/0096-Customizable-wither-health-and-healing.patch @@ -6,10 +6,10 @@ Subject: [PATCH] Customizable wither health and healing Adds the ability to customize the health of the wither, as well as the amount that it heals, and how often. 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 d88012af58aedf5f92885d74e69b06f5cf98aa71..2a7eac0dc5dbf71cb1b98903e78532cb8d506cfc 100644 +index 7c2c5b5205c7b422903fb6984f2b411d20189b22..c39e6ab8ffb850eb6ba783d237daad7e011a03bc 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 -@@ -519,8 +519,10 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -531,8 +531,10 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob } } @@ -23,10 +23,10 @@ index d88012af58aedf5f92885d74e69b06f5cf98aa71..2a7eac0dc5dbf71cb1b98903e78532cb this.bossEvent.setProgress(this.getHealth() / this.getMaxHealth()); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index c3546d8e36fecfd5d6c6c767de30fc6634a72416..7a7bd0fbac184b10dfd2d4a1b210c7c40efc4437 100644 +index a4a590c456b5e3554605f3428f93d3a8e1bd5ba9..88b49ee7171c0ad7be83eeac2aba2573e9707e4f 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1658,6 +1658,8 @@ public class PurpurWorldConfig { +@@ -1696,6 +1696,8 @@ public class PurpurWorldConfig { public boolean witherControllable = true; public double witherMaxY = 320D; public double witherMaxHealth = 300.0D; @@ -35,7 +35,7 @@ index c3546d8e36fecfd5d6c6c767de30fc6634a72416..7a7bd0fbac184b10dfd2d4a1b210c7c4 private void witherSettings() { witherRidable = getBoolean("mobs.wither.ridable", witherRidable); witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater); -@@ -1673,6 +1675,8 @@ public class PurpurWorldConfig { +@@ -1711,6 +1713,8 @@ public class PurpurWorldConfig { set("mobs.wither.attributes.max_health", oldValue); } witherMaxHealth = getDouble("mobs.wither.attributes.max_health", witherMaxHealth); diff --git a/patches/server/0100-Add-option-to-disable-zombie-aggressiveness-towards-.patch b/patches/server/0100-Add-option-to-disable-zombie-aggressiveness-towards-.patch index 245dc674a..6c30e2184 100644 --- a/patches/server/0100-Add-option-to-disable-zombie-aggressiveness-towards-.patch +++ b/patches/server/0100-Add-option-to-disable-zombie-aggressiveness-towards-.patch @@ -71,10 +71,10 @@ index 7be6cb6ad9a8b5f695b1a13564a37917a914b983..efe74738b5a90f822901488aa99f9810 this.targetSelector.addGoal(5, new NearestAttackableTargetGoal<>(this, Turtle.class, 10, true, false, Turtle.BABY_ON_LAND_SELECTOR)); } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 932b43c50fce502237e14852d45e58741393c7ee..1cf7929ca439866c613e6b8b5de878fdeb10a180 100644 +index e3f3ccafb76d73908b400afd0dda809f1d592168..7bfbbe1018dbdbddaa7d97ad3009d2e3849078e9 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1787,6 +1787,7 @@ public class PurpurWorldConfig { +@@ -1825,6 +1825,7 @@ public class PurpurWorldConfig { public boolean zombieJockeyOnlyBaby = true; public double zombieJockeyChance = 0.05D; public boolean zombieJockeyTryExistingChickens = true; @@ -82,7 +82,7 @@ index 932b43c50fce502237e14852d45e58741393c7ee..1cf7929ca439866c613e6b8b5de878fd private void zombieSettings() { zombieRidable = getBoolean("mobs.zombie.ridable", zombieRidable); zombieRidableInWater = getBoolean("mobs.zombie.ridable-in-water", zombieRidableInWater); -@@ -1801,6 +1802,7 @@ public class PurpurWorldConfig { +@@ -1839,6 +1840,7 @@ public class PurpurWorldConfig { zombieJockeyOnlyBaby = getBoolean("mobs.zombie.jockey.only-babies", zombieJockeyOnlyBaby); zombieJockeyChance = getDouble("mobs.zombie.jockey.chance", zombieJockeyChance); zombieJockeyTryExistingChickens = getBoolean("mobs.zombie.jockey.try-existing-chickens", zombieJockeyTryExistingChickens); diff --git a/patches/server/0102-Flying-squids-Oh-my.patch b/patches/server/0102-Flying-squids-Oh-my.patch index b23331e32..2c4447a3d 100644 --- a/patches/server/0102-Flying-squids-Oh-my.patch +++ b/patches/server/0102-Flying-squids-Oh-my.patch @@ -58,10 +58,10 @@ index 709aaa9dc834d91219ce1087d8f89ef5bf3d915c..4850960c7c4f38c7d81b8945f8c87504 float f1 = Mth.cos(f) * 0.2F; float f2 = -0.1F + this.squid.getRandom().nextFloat() * 0.2F; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 1cf7929ca439866c613e6b8b5de878fdeb10a180..93d95018b67a31270c2d8b14d156c3c3c2fe9801 100644 +index 7bfbbe1018dbdbddaa7d97ad3009d2e3849078e9..7f0ef2dfe8e326c53dd32b976c2a978d3f2ace07 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -852,10 +852,12 @@ public class PurpurWorldConfig { +@@ -872,10 +872,12 @@ public class PurpurWorldConfig { public boolean glowSquidRidable = false; public boolean glowSquidControllable = true; public double glowSquidMaxHealth = 10.0D; @@ -74,7 +74,7 @@ index 1cf7929ca439866c613e6b8b5de878fdeb10a180..93d95018b67a31270c2d8b14d156c3c3 } public boolean goatRidable = false; -@@ -1488,6 +1490,7 @@ public class PurpurWorldConfig { +@@ -1508,6 +1510,7 @@ public class PurpurWorldConfig { public double squidMaxHealth = 10.0D; public boolean squidImmuneToEAR = true; public double squidOffsetWaterCheck = 0.0D; @@ -82,7 +82,7 @@ index 1cf7929ca439866c613e6b8b5de878fdeb10a180..93d95018b67a31270c2d8b14d156c3c3 private void squidSettings() { squidRidable = getBoolean("mobs.squid.ridable", squidRidable); squidControllable = getBoolean("mobs.squid.controllable", squidControllable); -@@ -1499,6 +1502,7 @@ public class PurpurWorldConfig { +@@ -1519,6 +1522,7 @@ public class PurpurWorldConfig { squidMaxHealth = getDouble("mobs.squid.attributes.max_health", squidMaxHealth); squidImmuneToEAR = getBoolean("mobs.squid.immune-to-EAR", squidImmuneToEAR); squidOffsetWaterCheck = getDouble("mobs.squid.water-offset-check", squidOffsetWaterCheck); diff --git a/patches/server/0110-Make-entity-breeding-times-configurable.patch b/patches/server/0110-Make-entity-breeding-times-configurable.patch index d4d144bda..a508e7dfc 100644 --- a/patches/server/0110-Make-entity-breeding-times-configurable.patch +++ b/patches/server/0110-Make-entity-breeding-times-configurable.patch @@ -47,7 +47,7 @@ index 34e82b97c5b294f0a6423581220403a10264da8b..a0c3a27a90e0788b573f0776c25cfc6e other.resetLove(); world.addFreshEntityWithPassengers(entityageable, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.BREEDING); // CraftBukkit - added SpawnReason 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 21bd1f6f24715351d46573964438bcb7304575f5..374a026de1fec53ba3433e528d03ad103fa25f86 100644 +index 0fb1aa7bfbadc5e2df34391a4c9f0d045d576740..f9ae9bf91026adcb205302e0f902dda44febb744 100644 --- a/src/main/java/net/minecraft/world/entity/animal/Bee.java +++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java @@ -219,6 +219,11 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal { @@ -316,23 +316,20 @@ index a80a7d460051a39fe805ae669b4586fb42e46943..6d444248b9e283e31d5777d450a52643 @Override diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java -index 9e17e21a48892686e94a1c21b636695ab84eb7cd..ca0051d46a8ebe614d143339f229a3cce73b0bb3 100644 +index 156ab5e6a8e75e55f0f3fbc84c21e397cd1dc589..5c2e345cfc7076f6d4e62da85e81855bc1467a1f 100644 --- a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java +++ b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java -@@ -93,6 +93,13 @@ public class Frog extends Animal { - this.maxUpStep = 1.0F; +@@ -140,6 +140,10 @@ public class Frog extends Animal { + public float getJumpPower() { + return (getRider() != null && isControllable()) ? level.purpurConfig.frogRidableJumpHeight * this.getBlockJumpFactor() : super.getJumpPower(); } - -+ // Purpur start -+ @Override ++ + public int getPurpurBreedTime() { + return this.level.purpurConfig.frogBreedingTicks; + } -+ // Purpur end -+ + // Purpur end + @Override - protected Brain.Provider brainProvider() { - return Brain.provider(MEMORY_TYPES, SENSOR_TYPES); 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 aa2abe00478b002fc90166441d8b89c7046ed022..47c08d7f3e30aa335fb7c43179679b6ae9f23952 100644 --- a/src/main/java/net/minecraft/world/entity/animal/goat/Goat.java @@ -494,10 +491,10 @@ index e99ffbf30652e188e88f8e17ed41d39ff25c9f73..c335a32832c6eef95658fbf632b943bb @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339a11510d0 100644 +index 5236d3bc8acb317d819f59cd5873c6e0d14f091f..4a2c5afda4f59542412b0ef54bfa4cda87a4d776 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -481,10 +481,12 @@ public class PurpurWorldConfig { +@@ -490,10 +490,12 @@ public class PurpurWorldConfig { public boolean axolotlRidable = false; public boolean axolotlControllable = true; public double axolotlMaxHealth = 14.0D; @@ -510,7 +507,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean batRidable = false; -@@ -517,6 +519,7 @@ public class PurpurWorldConfig { +@@ -526,6 +528,7 @@ public class PurpurWorldConfig { public boolean beeControllable = true; public double beeMaxY = 320D; public double beeMaxHealth = 10.0D; @@ -518,7 +515,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void beeSettings() { beeRidable = getBoolean("mobs.bee.ridable", beeRidable); beeRidableInWater = getBoolean("mobs.bee.ridable-in-water", beeRidableInWater); -@@ -528,6 +531,7 @@ public class PurpurWorldConfig { +@@ -537,6 +540,7 @@ public class PurpurWorldConfig { set("mobs.bee.attributes.max_health", oldValue); } beeMaxHealth = getDouble("mobs.bee.attributes.max_health", beeMaxHealth); @@ -526,7 +523,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean blazeRidable = false; -@@ -555,6 +559,7 @@ public class PurpurWorldConfig { +@@ -564,6 +568,7 @@ public class PurpurWorldConfig { public int catSpawnDelay = 1200; public int catSpawnSwampHutScanRange = 16; public int catSpawnVillageScanRange = 48; @@ -534,7 +531,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void catSettings() { catRidable = getBoolean("mobs.cat.ridable", catRidable); catRidableInWater = getBoolean("mobs.cat.ridable-in-water", catRidableInWater); -@@ -568,6 +573,7 @@ public class PurpurWorldConfig { +@@ -577,6 +582,7 @@ public class PurpurWorldConfig { catSpawnDelay = getInt("mobs.cat.spawn-delay", catSpawnDelay); catSpawnSwampHutScanRange = getInt("mobs.cat.scan-range-for-other-cats.swamp-hut", catSpawnSwampHutScanRange); catSpawnVillageScanRange = getInt("mobs.cat.scan-range-for-other-cats.village", catSpawnVillageScanRange); @@ -542,7 +539,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean caveSpiderRidable = false; -@@ -591,6 +597,7 @@ public class PurpurWorldConfig { +@@ -600,6 +606,7 @@ public class PurpurWorldConfig { public boolean chickenControllable = true; public double chickenMaxHealth = 4.0D; public boolean chickenRetaliate = false; @@ -550,7 +547,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void chickenSettings() { chickenRidable = getBoolean("mobs.chicken.ridable", chickenRidable); chickenRidableInWater = getBoolean("mobs.chicken.ridable-in-water", chickenRidableInWater); -@@ -602,6 +609,7 @@ public class PurpurWorldConfig { +@@ -611,6 +618,7 @@ public class PurpurWorldConfig { } chickenMaxHealth = getDouble("mobs.chicken.attributes.max_health", chickenMaxHealth); chickenRetaliate = getBoolean("mobs.chicken.retaliate", chickenRetaliate); @@ -558,7 +555,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean codRidable = false; -@@ -623,6 +631,7 @@ public class PurpurWorldConfig { +@@ -632,6 +640,7 @@ public class PurpurWorldConfig { public boolean cowControllable = true; public double cowMaxHealth = 10.0D; public int cowFeedMushrooms = 0; @@ -566,7 +563,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void cowSettings() { cowRidable = getBoolean("mobs.cow.ridable", cowRidable); cowRidableInWater = getBoolean("mobs.cow.ridable-in-water", cowRidableInWater); -@@ -634,6 +643,7 @@ public class PurpurWorldConfig { +@@ -643,6 +652,7 @@ public class PurpurWorldConfig { } cowMaxHealth = getDouble("mobs.cow.attributes.max_health", cowMaxHealth); cowFeedMushrooms = getInt("mobs.cow.feed-mushrooms-for-mooshroom", cowFeedMushrooms); @@ -574,7 +571,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean creeperRidable = false; -@@ -685,6 +695,7 @@ public class PurpurWorldConfig { +@@ -694,6 +704,7 @@ public class PurpurWorldConfig { public double donkeyJumpStrengthMax = 0.5D; public double donkeyMovementSpeedMin = 0.175D; public double donkeyMovementSpeedMax = 0.175D; @@ -582,7 +579,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void donkeySettings() { donkeyRidableInWater = getBoolean("mobs.donkey.ridable-in-water", donkeyRidableInWater); if (PurpurConfig.version < 10) { -@@ -700,6 +711,7 @@ public class PurpurWorldConfig { +@@ -709,6 +720,7 @@ public class PurpurWorldConfig { donkeyJumpStrengthMax = getDouble("mobs.donkey.attributes.jump_strength.max", donkeyJumpStrengthMax); donkeyMovementSpeedMin = getDouble("mobs.donkey.attributes.movement_speed.min", donkeyMovementSpeedMin); donkeyMovementSpeedMax = getDouble("mobs.donkey.attributes.movement_speed.max", donkeyMovementSpeedMax); @@ -590,7 +587,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean drownedRidable = false; -@@ -819,6 +831,7 @@ public class PurpurWorldConfig { +@@ -828,6 +840,7 @@ public class PurpurWorldConfig { public boolean foxControllable = true; public double foxMaxHealth = 10.0D; public boolean foxTypeChangesWithTulips = false; @@ -598,20 +595,28 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void foxSettings() { foxRidable = getBoolean("mobs.fox.ridable", foxRidable); foxRidableInWater = getBoolean("mobs.fox.ridable-in-water", foxRidableInWater); -@@ -830,6 +843,12 @@ public class PurpurWorldConfig { +@@ -839,17 +852,20 @@ public class PurpurWorldConfig { } foxMaxHealth = getDouble("mobs.fox.attributes.max_health", foxMaxHealth); foxTypeChangesWithTulips = getBoolean("mobs.fox.tulips-change-type", foxTypeChangesWithTulips); + foxBreedingTicks = getInt("mobs.fox.breeding-delay-ticks", foxBreedingTicks); -+ } -+ + } + + public boolean frogRidable = false; + public boolean frogRidableInWater = false; + public boolean frogControllable = true; + public float frogRidableJumpHeight = 0.65F; + public int frogBreedingTicks = 6000; -+ private void frogSettings() { + private void frogSettings() { + frogRidable = getBoolean("mobs.frog.ridable", frogRidable); + frogRidableInWater = getBoolean("mobs.frog.ridable-in-water", frogRidableInWater); + frogControllable = getBoolean("mobs.frog.controllable", frogControllable); + frogRidableJumpHeight = (float) getDouble("mobs.frog.ridable-jump-height", frogRidableJumpHeight); + frogBreedingTicks = getInt("mobs.frog.breeding-delay-ticks", frogBreedingTicks); } public boolean ghastRidable = false; -@@ -897,11 +916,13 @@ public class PurpurWorldConfig { +@@ -917,11 +933,13 @@ public class PurpurWorldConfig { public boolean goatRidableInWater = false; public boolean goatControllable = true; public double goatMaxHealth = 10.0D; @@ -625,7 +630,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean guardianRidable = false; -@@ -922,6 +943,7 @@ public class PurpurWorldConfig { +@@ -942,6 +960,7 @@ public class PurpurWorldConfig { public boolean hoglinRidableInWater = false; public boolean hoglinControllable = true; public double hoglinMaxHealth = 40.0D; @@ -633,7 +638,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void hoglinSettings() { hoglinRidable = getBoolean("mobs.hoglin.ridable", hoglinRidable); hoglinRidableInWater = getBoolean("mobs.hoglin.ridable-in-water", hoglinRidableInWater); -@@ -932,6 +954,7 @@ public class PurpurWorldConfig { +@@ -952,6 +971,7 @@ public class PurpurWorldConfig { set("mobs.hoglin.attributes.max_health", oldValue); } hoglinMaxHealth = getDouble("mobs.hoglin.attributes.max_health", hoglinMaxHealth); @@ -641,7 +646,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean horseRidableInWater = false; -@@ -941,6 +964,7 @@ public class PurpurWorldConfig { +@@ -961,6 +981,7 @@ public class PurpurWorldConfig { public double horseJumpStrengthMax = 1.0D; public double horseMovementSpeedMin = 0.1125D; public double horseMovementSpeedMax = 0.3375D; @@ -649,7 +654,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void horseSettings() { horseRidableInWater = getBoolean("mobs.horse.ridable-in-water", horseRidableInWater); if (PurpurConfig.version < 10) { -@@ -956,6 +980,7 @@ public class PurpurWorldConfig { +@@ -976,6 +997,7 @@ public class PurpurWorldConfig { horseJumpStrengthMax = getDouble("mobs.horse.attributes.jump_strength.max", horseJumpStrengthMax); horseMovementSpeedMin = getDouble("mobs.horse.attributes.movement_speed.min", horseMovementSpeedMin); horseMovementSpeedMax = getDouble("mobs.horse.attributes.movement_speed.max", horseMovementSpeedMax); @@ -657,7 +662,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean huskRidable = false; -@@ -1033,6 +1058,7 @@ public class PurpurWorldConfig { +@@ -1053,6 +1075,7 @@ public class PurpurWorldConfig { public double llamaJumpStrengthMax = 0.5D; public double llamaMovementSpeedMin = 0.175D; public double llamaMovementSpeedMax = 0.175D; @@ -665,7 +670,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void llamaSettings() { llamaRidable = getBoolean("mobs.llama.ridable", llamaRidable); llamaRidableInWater = getBoolean("mobs.llama.ridable-in-water", llamaRidableInWater); -@@ -1050,6 +1076,7 @@ public class PurpurWorldConfig { +@@ -1070,6 +1093,7 @@ public class PurpurWorldConfig { llamaJumpStrengthMax = getDouble("mobs.llama.attributes.jump_strength.max", llamaJumpStrengthMax); llamaMovementSpeedMin = getDouble("mobs.llama.attributes.movement_speed.min", llamaMovementSpeedMin); llamaMovementSpeedMax = getDouble("mobs.llama.attributes.movement_speed.max", llamaMovementSpeedMax); @@ -673,7 +678,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean magmaCubeRidable = false; -@@ -1078,6 +1105,7 @@ public class PurpurWorldConfig { +@@ -1098,6 +1122,7 @@ public class PurpurWorldConfig { public boolean mooshroomRidableInWater = false; public boolean mooshroomControllable = true; public double mooshroomMaxHealth = 10.0D; @@ -681,7 +686,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void mooshroomSettings() { mooshroomRidable = getBoolean("mobs.mooshroom.ridable", mooshroomRidable); mooshroomRidableInWater = getBoolean("mobs.mooshroom.ridable-in-water", mooshroomRidableInWater); -@@ -1088,6 +1116,7 @@ public class PurpurWorldConfig { +@@ -1108,6 +1133,7 @@ public class PurpurWorldConfig { set("mobs.mooshroom.attributes.max_health", oldValue); } mooshroomMaxHealth = getDouble("mobs.mooshroom.attributes.max_health", mooshroomMaxHealth); @@ -689,7 +694,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean muleRidableInWater = false; -@@ -1097,6 +1126,7 @@ public class PurpurWorldConfig { +@@ -1117,6 +1143,7 @@ public class PurpurWorldConfig { public double muleJumpStrengthMax = 0.5D; public double muleMovementSpeedMin = 0.175D; public double muleMovementSpeedMax = 0.175D; @@ -697,7 +702,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void muleSettings() { muleRidableInWater = getBoolean("mobs.mule.ridable-in-water", muleRidableInWater); if (PurpurConfig.version < 10) { -@@ -1112,12 +1142,14 @@ public class PurpurWorldConfig { +@@ -1132,12 +1159,14 @@ public class PurpurWorldConfig { muleJumpStrengthMax = getDouble("mobs.mule.attributes.jump_strength.max", muleJumpStrengthMax); muleMovementSpeedMin = getDouble("mobs.mule.attributes.movement_speed.min", muleMovementSpeedMin); muleMovementSpeedMax = getDouble("mobs.mule.attributes.movement_speed.max", muleMovementSpeedMax); @@ -712,7 +717,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void ocelotSettings() { ocelotRidable = getBoolean("mobs.ocelot.ridable", ocelotRidable); ocelotRidableInWater = getBoolean("mobs.ocelot.ridable-in-water", ocelotRidableInWater); -@@ -1128,12 +1160,14 @@ public class PurpurWorldConfig { +@@ -1148,12 +1177,14 @@ public class PurpurWorldConfig { set("mobs.ocelot.attributes.max_health", oldValue); } ocelotMaxHealth = getDouble("mobs.ocelot.attributes.max_health", ocelotMaxHealth); @@ -727,7 +732,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void pandaSettings() { pandaRidable = getBoolean("mobs.panda.ridable", pandaRidable); pandaRidableInWater = getBoolean("mobs.panda.ridable-in-water", pandaRidableInWater); -@@ -1144,6 +1178,7 @@ public class PurpurWorldConfig { +@@ -1164,6 +1195,7 @@ public class PurpurWorldConfig { set("mobs.panda.attributes.max_health", oldValue); } pandaMaxHealth = getDouble("mobs.panda.attributes.max_health", pandaMaxHealth); @@ -735,7 +740,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean parrotRidable = false; -@@ -1239,6 +1274,7 @@ public class PurpurWorldConfig { +@@ -1259,6 +1291,7 @@ public class PurpurWorldConfig { public boolean pigControllable = true; public double pigMaxHealth = 10.0D; public boolean pigGiveSaddleBack = false; @@ -743,7 +748,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void pigSettings() { pigRidable = getBoolean("mobs.pig.ridable", pigRidable); pigRidableInWater = getBoolean("mobs.pig.ridable-in-water", pigRidableInWater); -@@ -1250,6 +1286,7 @@ public class PurpurWorldConfig { +@@ -1270,6 +1303,7 @@ public class PurpurWorldConfig { } pigMaxHealth = getDouble("mobs.pig.attributes.max_health", pigMaxHealth); pigGiveSaddleBack = getBoolean("mobs.pig.give-saddle-back", pigGiveSaddleBack); @@ -751,7 +756,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean piglinRidable = false; -@@ -1306,6 +1343,7 @@ public class PurpurWorldConfig { +@@ -1326,6 +1360,7 @@ public class PurpurWorldConfig { public double polarBearMaxHealth = 30.0D; public String polarBearBreedableItemString = ""; public Item polarBearBreedableItem = null; @@ -759,7 +764,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void polarBearSettings() { polarBearRidable = getBoolean("mobs.polar_bear.ridable", polarBearRidable); polarBearRidableInWater = getBoolean("mobs.polar_bear.ridable-in-water", polarBearRidableInWater); -@@ -1319,6 +1357,7 @@ public class PurpurWorldConfig { +@@ -1339,6 +1374,7 @@ public class PurpurWorldConfig { polarBearBreedableItemString = getString("mobs.polar_bear.breedable-item", polarBearBreedableItemString); Item item = Registry.ITEM.get(new ResourceLocation(polarBearBreedableItemString)); if (item != Items.AIR) polarBearBreedableItem = item; @@ -767,7 +772,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean pufferfishRidable = false; -@@ -1341,6 +1380,7 @@ public class PurpurWorldConfig { +@@ -1361,6 +1397,7 @@ public class PurpurWorldConfig { public double rabbitMaxHealth = 3.0D; public double rabbitNaturalToast = 0.0D; public double rabbitNaturalKiller = 0.0D; @@ -775,7 +780,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void rabbitSettings() { rabbitRidable = getBoolean("mobs.rabbit.ridable", rabbitRidable); rabbitRidableInWater = getBoolean("mobs.rabbit.ridable-in-water", rabbitRidableInWater); -@@ -1353,6 +1393,7 @@ public class PurpurWorldConfig { +@@ -1373,6 +1410,7 @@ public class PurpurWorldConfig { rabbitMaxHealth = getDouble("mobs.rabbit.attributes.max_health", rabbitMaxHealth); rabbitNaturalToast = getDouble("mobs.rabbit.spawn-toast-chance", rabbitNaturalToast); rabbitNaturalKiller = getDouble("mobs.rabbit.spawn-killer-rabbit-chance", rabbitNaturalKiller); @@ -783,7 +788,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean ravagerRidable = false; -@@ -1389,6 +1430,7 @@ public class PurpurWorldConfig { +@@ -1409,6 +1447,7 @@ public class PurpurWorldConfig { public boolean sheepRidableInWater = false; public boolean sheepControllable = true; public double sheepMaxHealth = 8.0D; @@ -791,7 +796,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void sheepSettings() { sheepRidable = getBoolean("mobs.sheep.ridable", sheepRidable); sheepRidableInWater = getBoolean("mobs.sheep.ridable-in-water", sheepRidableInWater); -@@ -1399,6 +1441,7 @@ public class PurpurWorldConfig { +@@ -1419,6 +1458,7 @@ public class PurpurWorldConfig { set("mobs.sheep.attributes.max_health", oldValue); } sheepMaxHealth = getDouble("mobs.sheep.attributes.max_health", sheepMaxHealth); @@ -799,7 +804,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean shulkerRidable = false; -@@ -1574,6 +1617,7 @@ public class PurpurWorldConfig { +@@ -1594,6 +1634,7 @@ public class PurpurWorldConfig { public boolean striderRidableInWater = false; public boolean striderControllable = true; public double striderMaxHealth = 20.0D; @@ -807,15 +812,15 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void striderSettings() { striderRidable = getBoolean("mobs.strider.ridable", striderRidable); striderRidableInWater = getBoolean("mobs.strider.ridable-in-water", striderRidableInWater); -@@ -1584,6 +1628,7 @@ public class PurpurWorldConfig { +@@ -1604,6 +1645,7 @@ public class PurpurWorldConfig { set("mobs.strider.attributes.max_health", oldValue); } striderMaxHealth = getDouble("mobs.strider.attributes.max_health", striderMaxHealth); + striderBreedingTicks = getInt("mobs.strider.breeding-delay-ticks", striderBreedingTicks); } - public boolean traderLlamaRidable = false; -@@ -1595,6 +1640,7 @@ public class PurpurWorldConfig { + public boolean tadpoleRidable = false; +@@ -1624,6 +1666,7 @@ public class PurpurWorldConfig { public double traderLlamaJumpStrengthMax = 0.5D; public double traderLlamaMovementSpeedMin = 0.175D; public double traderLlamaMovementSpeedMax = 0.175D; @@ -823,7 +828,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void traderLlamaSettings() { traderLlamaRidable = getBoolean("mobs.trader_llama.ridable", traderLlamaRidable); traderLlamaRidableInWater = getBoolean("mobs.trader_llama.ridable-in-water", traderLlamaRidableInWater); -@@ -1612,6 +1658,7 @@ public class PurpurWorldConfig { +@@ -1641,6 +1684,7 @@ public class PurpurWorldConfig { traderLlamaJumpStrengthMax = getDouble("mobs.trader_llama.attributes.jump_strength.max", traderLlamaJumpStrengthMax); traderLlamaMovementSpeedMin = getDouble("mobs.trader_llama.attributes.movement_speed.min", traderLlamaMovementSpeedMin); traderLlamaMovementSpeedMax = getDouble("mobs.trader_llama.attributes.movement_speed.max", traderLlamaMovementSpeedMax); @@ -831,7 +836,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean tropicalFishRidable = false; -@@ -1632,6 +1679,7 @@ public class PurpurWorldConfig { +@@ -1661,6 +1705,7 @@ public class PurpurWorldConfig { public boolean turtleRidableInWater = false; public boolean turtleControllable = true; public double turtleMaxHealth = 30.0D; @@ -839,7 +844,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void turtleSettings() { turtleRidable = getBoolean("mobs.turtle.ridable", turtleRidable); turtleRidableInWater = getBoolean("mobs.turtle.ridable-in-water", turtleRidableInWater); -@@ -1642,6 +1690,7 @@ public class PurpurWorldConfig { +@@ -1671,6 +1716,7 @@ public class PurpurWorldConfig { set("mobs.turtle.attributes.max_health", oldValue); } turtleMaxHealth = getDouble("mobs.turtle.attributes.max_health", turtleMaxHealth); @@ -847,7 +852,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean vexRidable = false; -@@ -1671,6 +1720,7 @@ public class PurpurWorldConfig { +@@ -1700,6 +1746,7 @@ public class PurpurWorldConfig { public boolean villagerFollowEmeraldBlock = false; public boolean villagerCanBeLeashed = false; public boolean villagerCanBreed = true; @@ -855,7 +860,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -1686,6 +1736,7 @@ public class PurpurWorldConfig { +@@ -1715,6 +1762,7 @@ public class PurpurWorldConfig { villagerFollowEmeraldBlock = getBoolean("mobs.villager.follow-emerald-blocks", villagerFollowEmeraldBlock); villagerCanBeLeashed = getBoolean("mobs.villager.can-be-leashed", villagerCanBeLeashed); villagerCanBreed = getBoolean("mobs.villager.can-breed", villagerCanBreed); @@ -863,7 +868,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 } public boolean vindicatorRidable = false; -@@ -1788,6 +1839,7 @@ public class PurpurWorldConfig { +@@ -1826,6 +1874,7 @@ public class PurpurWorldConfig { public boolean wolfRidableInWater = false; public boolean wolfControllable = true; public double wolfMaxHealth = 8.0D; @@ -871,7 +876,7 @@ index 7c203f8b0120d07263c0a96422a69173daebd89e..ac3b0b027c6a9a625d5b54fc2db59339 private void wolfSettings() { wolfRidable = getBoolean("mobs.wolf.ridable", wolfRidable); wolfRidableInWater = getBoolean("mobs.wolf.ridable-in-water", wolfRidableInWater); -@@ -1798,6 +1850,7 @@ public class PurpurWorldConfig { +@@ -1836,6 +1885,7 @@ public class PurpurWorldConfig { set("mobs.wolf.attributes.max_health", oldValue); } wolfMaxHealth = getDouble("mobs.wolf.attributes.max_health", wolfMaxHealth); diff --git a/patches/server/0113-Add-config-for-allowing-Endermen-to-despawn-even-whi.patch b/patches/server/0113-Add-config-for-allowing-Endermen-to-despawn-even-whi.patch index 41ee20589..688291382 100644 --- a/patches/server/0113-Add-config-for-allowing-Endermen-to-despawn-even-whi.patch +++ b/patches/server/0113-Add-config-for-allowing-Endermen-to-despawn-even-whi.patch @@ -21,10 +21,10 @@ index 9458cab33d4ff468d3d009cc1c3b3736f21f649b..4443a4a300d17e8568a81bcb9af89251 private static class EndermanFreezeWhenLookedAt extends Goal { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 99578dba4d30263024eedef3084e46bb7c08c465..119da5f019b83d6c725003bba08842363b6d4115 100644 +index 3d140a8a2e3b3ea968f2f2862f981dc463ac8f7b..e6f8050ab3701c549970f1811449c0a8e9e27bd2 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -787,6 +787,7 @@ public class PurpurWorldConfig { +@@ -796,6 +796,7 @@ public class PurpurWorldConfig { public boolean endermanControllable = true; public double endermanMaxHealth = 40.0D; public boolean endermanAllowGriefing = true; @@ -32,7 +32,7 @@ index 99578dba4d30263024eedef3084e46bb7c08c465..119da5f019b83d6c725003bba0884236 private void endermanSettings() { endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable); endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater); -@@ -798,6 +799,7 @@ public class PurpurWorldConfig { +@@ -807,6 +808,7 @@ public class PurpurWorldConfig { } endermanMaxHealth = getDouble("mobs.enderman.attributes.max_health", endermanMaxHealth); endermanAllowGriefing = getBoolean("mobs.enderman.allow-griefing", endermanAllowGriefing); diff --git a/patches/server/0117-Snow-Golem-rate-of-fire-config.patch b/patches/server/0117-Snow-Golem-rate-of-fire-config.patch index f83092719..88ce7176e 100644 --- a/patches/server/0117-Snow-Golem-rate-of-fire-config.patch +++ b/patches/server/0117-Snow-Golem-rate-of-fire-config.patch @@ -23,10 +23,10 @@ index b4459d68397cc5bac4f7ef79a2dfb18f3eb24f77..b9025929fcc89e72aa820953b91a6542 this.goalSelector.addGoal(3, new LookAtPlayerGoal(this, Player.class, 6.0F)); this.goalSelector.addGoal(4, new RandomLookAroundGoal(this)); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index e4fdbca384109a4c45284648709394d4c425f9b3..6e46b3928f619cc5d2fb596b1cb740eea04a17d3 100644 +index 38ecc62dab7c34831b09ec489f909678d56807ac..b7f7a1c4da6d866e65fbadd63e7487036af25238 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1563,6 +1563,10 @@ public class PurpurWorldConfig { +@@ -1580,6 +1580,10 @@ public class PurpurWorldConfig { public double snowGolemMaxHealth = 4.0D; public boolean snowGolemDropsPumpkin = true; public boolean snowGolemPutPumpkinBack = false; @@ -37,7 +37,7 @@ index e4fdbca384109a4c45284648709394d4c425f9b3..6e46b3928f619cc5d2fb596b1cb740ee private void snowGolemSettings() { snowGolemRidable = getBoolean("mobs.snow_golem.ridable", snowGolemRidable); snowGolemRidableInWater = getBoolean("mobs.snow_golem.ridable-in-water", snowGolemRidableInWater); -@@ -1576,6 +1580,10 @@ public class PurpurWorldConfig { +@@ -1593,6 +1597,10 @@ public class PurpurWorldConfig { snowGolemMaxHealth = getDouble("mobs.snow_golem.attributes.max_health", snowGolemMaxHealth); snowGolemDropsPumpkin = getBoolean("mobs.snow_golem.drop-pumpkin-when-sheared", snowGolemDropsPumpkin); snowGolemPutPumpkinBack = getBoolean("mobs.snow_golem.pumpkin-can-be-added-back", snowGolemPutPumpkinBack); diff --git a/patches/server/0119-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch b/patches/server/0119-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch index b9bce5baf..59c6c6d4b 100644 --- a/patches/server/0119-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch +++ b/patches/server/0119-Option-for-Villager-Clerics-to-farm-Nether-Wart.patch @@ -181,10 +181,10 @@ index b1f20cb356e6b4e89fdddf4e48f2fd932bdb5170..352a7df156c638684a12a864eb5a9d06 public static final VillagerProfession FISHERMAN = register("fisherman", PoiTypes.FISHERMAN, SoundEvents.VILLAGER_WORK_FISHERMAN); public static final VillagerProfession FLETCHER = register("fletcher", PoiTypes.FLETCHER, SoundEvents.VILLAGER_WORK_FLETCHER); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 6e46b3928f619cc5d2fb596b1cb740eea04a17d3..a81a421c13b27e1078d4c34e760920eebc4cd854 100644 +index b7f7a1c4da6d866e65fbadd63e7487036af25238..a0a094d200949a0c9e121f9094bb64682046bac9 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1746,6 +1746,8 @@ public class PurpurWorldConfig { +@@ -1772,6 +1772,8 @@ public class PurpurWorldConfig { public boolean villagerCanBeLeashed = false; public boolean villagerCanBreed = true; public int villagerBreedingTicks = 6000; @@ -193,7 +193,7 @@ index 6e46b3928f619cc5d2fb596b1cb740eea04a17d3..a81a421c13b27e1078d4c34e760920ee private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -1762,6 +1764,8 @@ public class PurpurWorldConfig { +@@ -1788,6 +1790,8 @@ public class PurpurWorldConfig { villagerCanBeLeashed = getBoolean("mobs.villager.can-be-leashed", villagerCanBeLeashed); villagerCanBreed = getBoolean("mobs.villager.can-breed", villagerCanBreed); villagerBreedingTicks = getInt("mobs.villager.breeding-delay-ticks", villagerBreedingTicks); diff --git a/patches/server/0120-Toggle-for-Zombified-Piglin-death-always-counting-as.patch b/patches/server/0120-Toggle-for-Zombified-Piglin-death-always-counting-as.patch index d20c3d2a2..d91cfe04a 100644 --- a/patches/server/0120-Toggle-for-Zombified-Piglin-death-always-counting-as.patch +++ b/patches/server/0120-Toggle-for-Zombified-Piglin-death-always-counting-as.patch @@ -35,10 +35,10 @@ index 6c1dd723373f9b1b920548de85aeb6cef0120fa7..1f0003fb08a45af02e6d38e28fa548ab } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index a81a421c13b27e1078d4c34e760920eebc4cd854..19ca7fb96c5b0fb115dda297d1b386875bf87d02 100644 +index a0a094d200949a0c9e121f9094bb64682046bac9..942df6380276fd427d0c68cfe95ada5ff80df9a6 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1983,6 +1983,7 @@ public class PurpurWorldConfig { +@@ -2018,6 +2018,7 @@ public class PurpurWorldConfig { public boolean zombifiedPiglinJockeyOnlyBaby = true; public double zombifiedPiglinJockeyChance = 0.05D; public boolean zombifiedPiglinJockeyTryExistingChickens = true; @@ -46,7 +46,7 @@ index a81a421c13b27e1078d4c34e760920eebc4cd854..19ca7fb96c5b0fb115dda297d1b38687 private void zombifiedPiglinSettings() { zombifiedPiglinRidable = getBoolean("mobs.zombified_piglin.ridable", zombifiedPiglinRidable); zombifiedPiglinRidableInWater = getBoolean("mobs.zombified_piglin.ridable-in-water", zombifiedPiglinRidableInWater); -@@ -1997,5 +1998,6 @@ public class PurpurWorldConfig { +@@ -2032,5 +2033,6 @@ public class PurpurWorldConfig { zombifiedPiglinJockeyOnlyBaby = getBoolean("mobs.zombified_piglin.jockey.only-babies", zombifiedPiglinJockeyOnlyBaby); zombifiedPiglinJockeyChance = getDouble("mobs.zombified_piglin.jockey.chance", zombifiedPiglinJockeyChance); zombifiedPiglinJockeyTryExistingChickens = getBoolean("mobs.zombified_piglin.jockey.try-existing-chickens", zombifiedPiglinJockeyTryExistingChickens); diff --git a/patches/server/0122-Configurable-chance-for-wolves-to-spawn-rabid.patch b/patches/server/0122-Configurable-chance-for-wolves-to-spawn-rabid.patch index 147b7d333..e29e48cab 100644 --- a/patches/server/0122-Configurable-chance-for-wolves-to-spawn-rabid.patch +++ b/patches/server/0122-Configurable-chance-for-wolves-to-spawn-rabid.patch @@ -222,10 +222,10 @@ index a3bec00368aef0f8cc6aa21cce1389938d15f91b..704667760ab1593647e3f03bdd17ad32 + // Purpur end } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 19ca7fb96c5b0fb115dda297d1b386875bf87d02..6e57ed4f69c97da72d19b93173cc20e2f17e82df 100644 +index 942df6380276fd427d0c68cfe95ada5ff80df9a6..abaccd1447baa66d1aa73f1090448d5a05f85bf0 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1868,6 +1868,8 @@ public class PurpurWorldConfig { +@@ -1903,6 +1903,8 @@ public class PurpurWorldConfig { public boolean wolfRidableInWater = false; public boolean wolfControllable = true; public double wolfMaxHealth = 8.0D; @@ -234,7 +234,7 @@ index 19ca7fb96c5b0fb115dda297d1b386875bf87d02..6e57ed4f69c97da72d19b93173cc20e2 public int wolfBreedingTicks = 6000; private void wolfSettings() { wolfRidable = getBoolean("mobs.wolf.ridable", wolfRidable); -@@ -1879,6 +1881,8 @@ public class PurpurWorldConfig { +@@ -1914,6 +1916,8 @@ public class PurpurWorldConfig { set("mobs.wolf.attributes.max_health", oldValue); } wolfMaxHealth = getDouble("mobs.wolf.attributes.max_health", wolfMaxHealth); diff --git a/patches/server/0123-Configurable-default-collar-color.patch b/patches/server/0123-Configurable-default-collar-color.patch index f09c1e67b..72d9c52df 100644 --- a/patches/server/0123-Configurable-default-collar-color.patch +++ b/patches/server/0123-Configurable-default-collar-color.patch @@ -43,10 +43,10 @@ index f862d83db6127804b9254a33a73e6f186a1d1327..ffe8f80cfe3bec8fe79415015f529074 @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 6e57ed4f69c97da72d19b93173cc20e2f17e82df..507147606fd201cddeb74af0d11d1676a8546f13 100644 +index abaccd1447baa66d1aa73f1090448d5a05f85bf0..cd23d5085ed062b7d9fce71326356e9e389b39e1 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -575,6 +575,7 @@ public class PurpurWorldConfig { +@@ -584,6 +584,7 @@ public class PurpurWorldConfig { public int catSpawnSwampHutScanRange = 16; public int catSpawnVillageScanRange = 48; public int catBreedingTicks = 6000; @@ -54,7 +54,7 @@ index 6e57ed4f69c97da72d19b93173cc20e2f17e82df..507147606fd201cddeb74af0d11d1676 private void catSettings() { catRidable = getBoolean("mobs.cat.ridable", catRidable); catRidableInWater = getBoolean("mobs.cat.ridable-in-water", catRidableInWater); -@@ -589,6 +590,11 @@ public class PurpurWorldConfig { +@@ -598,6 +599,11 @@ public class PurpurWorldConfig { catSpawnSwampHutScanRange = getInt("mobs.cat.scan-range-for-other-cats.swamp-hut", catSpawnSwampHutScanRange); catSpawnVillageScanRange = getInt("mobs.cat.scan-range-for-other-cats.village", catSpawnVillageScanRange); catBreedingTicks = getInt("mobs.cat.breeding-delay-ticks", catBreedingTicks); @@ -66,7 +66,7 @@ index 6e57ed4f69c97da72d19b93173cc20e2f17e82df..507147606fd201cddeb74af0d11d1676 } public boolean caveSpiderRidable = false; -@@ -1868,6 +1874,7 @@ public class PurpurWorldConfig { +@@ -1903,6 +1909,7 @@ public class PurpurWorldConfig { public boolean wolfRidableInWater = false; public boolean wolfControllable = true; public double wolfMaxHealth = 8.0D; @@ -74,7 +74,7 @@ index 6e57ed4f69c97da72d19b93173cc20e2f17e82df..507147606fd201cddeb74af0d11d1676 public boolean wolfMilkCuresRabies = true; public double wolfNaturalRabid = 0.0D; public int wolfBreedingTicks = 6000; -@@ -1881,6 +1888,11 @@ public class PurpurWorldConfig { +@@ -1916,6 +1923,11 @@ public class PurpurWorldConfig { set("mobs.wolf.attributes.max_health", oldValue); } wolfMaxHealth = getDouble("mobs.wolf.attributes.max_health", wolfMaxHealth); diff --git a/patches/server/0124-Phantom-flames-on-swoop.patch b/patches/server/0124-Phantom-flames-on-swoop.patch index b5fd7ceac..426d9a9c6 100644 --- a/patches/server/0124-Phantom-flames-on-swoop.patch +++ b/patches/server/0124-Phantom-flames-on-swoop.patch @@ -17,10 +17,10 @@ index 82d56a6968f3bbea5a2d32c2a7a84a8ba36d3d15..f23ca987666fd23621d3d731fd1a4ab2 @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 507147606fd201cddeb74af0d11d1676a8546f13..f8a9e30b7a62aa595b4d686cb1bfef321c28c982 100644 +index cd23d5085ed062b7d9fce71326356e9e389b39e1..2c8e2faeab641f1019f31339707c62e82c5e9276 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1251,6 +1251,7 @@ public class PurpurWorldConfig { +@@ -1268,6 +1268,7 @@ public class PurpurWorldConfig { public int phantomBurnInLight = 0; public boolean phantomIgnorePlayersWithTorch = false; public boolean phantomBurnInDaylight = true; @@ -28,7 +28,7 @@ index 507147606fd201cddeb74af0d11d1676a8546f13..f8a9e30b7a62aa595b4d686cb1bfef32 private void phantomSettings() { phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable); phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater); -@@ -1290,6 +1291,7 @@ public class PurpurWorldConfig { +@@ -1307,6 +1308,7 @@ public class PurpurWorldConfig { phantomBurnInLight = getInt("mobs.phantom.burn-in-light", phantomBurnInLight); phantomBurnInDaylight = getBoolean("mobs.phantom.burn-in-daylight", phantomBurnInDaylight); phantomIgnorePlayersWithTorch = getBoolean("mobs.phantom.ignore-players-with-torch", phantomIgnorePlayersWithTorch); diff --git a/patches/server/0127-Striders-give-saddle-back.patch b/patches/server/0127-Striders-give-saddle-back.patch index 428488cfe..f5947906e 100644 --- a/patches/server/0127-Striders-give-saddle-back.patch +++ b/patches/server/0127-Striders-give-saddle-back.patch @@ -29,10 +29,10 @@ index eb2083d67f9486a24d2f0aa4bf1f5ba8a00e23a3..df9d16a6493a57b6034cd56bf8dbe38f if (!this.level.isClientSide) { player.startRiding(this); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 329717770d0247d4b3d56817ae5fd38a083a8ff4..e300ad3350a666d81b60488ac4ed1eb0d3bca99f 100644 +index 98875193e44706b180663151a2e3864bd5272ff4..aeacb1b81bcce83188008d3e531e72f739d1e928 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1656,6 +1656,7 @@ public class PurpurWorldConfig { +@@ -1673,6 +1673,7 @@ public class PurpurWorldConfig { public boolean striderControllable = true; public double striderMaxHealth = 20.0D; public int striderBreedingTicks = 6000; @@ -40,11 +40,11 @@ index 329717770d0247d4b3d56817ae5fd38a083a8ff4..e300ad3350a666d81b60488ac4ed1eb0 private void striderSettings() { striderRidable = getBoolean("mobs.strider.ridable", striderRidable); striderRidableInWater = getBoolean("mobs.strider.ridable-in-water", striderRidableInWater); -@@ -1667,6 +1668,7 @@ public class PurpurWorldConfig { +@@ -1684,6 +1685,7 @@ public class PurpurWorldConfig { } striderMaxHealth = getDouble("mobs.strider.attributes.max_health", striderMaxHealth); striderBreedingTicks = getInt("mobs.strider.breeding-delay-ticks", striderBreedingTicks); + striderGiveSaddleBack = getBoolean("mobs.strider.give-saddle-back", striderGiveSaddleBack); } - public boolean traderLlamaRidable = false; + public boolean tadpoleRidable = false; diff --git a/patches/server/0131-Add-mobGriefing-bypass-to-everything-affected.patch b/patches/server/0131-Add-mobGriefing-bypass-to-everything-affected.patch index ffd0802c5..9100e9a6f 100644 --- a/patches/server/0131-Add-mobGriefing-bypass-to-everything-affected.patch +++ b/patches/server/0131-Add-mobGriefing-bypass-to-everything-affected.patch @@ -144,10 +144,10 @@ index 9ce2527054f5163eae3d1216427378dcdf92a2fe..d655bd2ecce01a54695d135b12b2f930 // flag1 = this.level.removeBlock(blockposition, false) || flag1; flag1 = true; 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 2a7eac0dc5dbf71cb1b98903e78532cb8d506cfc..3dfb7f3d11b69e08682d8b955adde3576c3ce6a1 100644 +index c39e6ab8ffb850eb6ba783d237daad7e011a03bc..2207c5a71b8a3c7c0c68388ec744c5272d10ab36 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 -@@ -390,7 +390,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -402,7 +402,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob i = this.getInvulnerableTicks() - 1; this.bossEvent.setProgress(1.0F - (float) i / 220.0F); if (i <= 0) { @@ -156,7 +156,7 @@ index 2a7eac0dc5dbf71cb1b98903e78532cb8d506cfc..3dfb7f3d11b69e08682d8b955adde357 // CraftBukkit start // this.level.explode(this, this.getX(), this.getEyeY(), this.getZ(), 7.0F, false, explosion_effect); ExplosionPrimeEvent event = new ExplosionPrimeEvent(this.getBukkitEntity(), 7.0F, false); -@@ -486,7 +486,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -498,7 +498,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob if (this.destroyBlocksTick > 0) { --this.destroyBlocksTick; @@ -393,7 +393,7 @@ index 1a12fee99a8b69fc6c01e1e217575c7c19e13155..4907e0acb7d01b7f57b75579e58ce743 return true; // Purpur end diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a41241ac50 100644 +index 881e9c611f7f5fc56af316cbf1ff73b680b6e4ce..8b97adcc2461641d89d3340084d15d0bf235ae28 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -109,8 +109,11 @@ public class PurpurWorldConfig { @@ -457,7 +457,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean waterInfinite = true; -@@ -691,6 +706,7 @@ public class PurpurWorldConfig { +@@ -700,6 +715,7 @@ public class PurpurWorldConfig { public double creeperMaxHealth = 20.0D; public double creeperChargedChance = 0.0D; public boolean creeperAllowGriefing = true; @@ -465,7 +465,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void creeperSettings() { creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable); creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater); -@@ -703,6 +719,7 @@ public class PurpurWorldConfig { +@@ -712,6 +728,7 @@ public class PurpurWorldConfig { creeperMaxHealth = getDouble("mobs.creeper.attributes.max_health", creeperMaxHealth); creeperChargedChance = getDouble("mobs.creeper.naturally-charged-chance", creeperChargedChance); creeperAllowGriefing = getBoolean("mobs.creeper.allow-griefing", creeperAllowGriefing); @@ -473,7 +473,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean dolphinRidable = false; -@@ -797,6 +814,7 @@ public class PurpurWorldConfig { +@@ -806,6 +823,7 @@ public class PurpurWorldConfig { public double enderDragonMaxY = 320D; public double enderDragonMaxHealth = 200.0D; public boolean enderDragonAlwaysDropsFullExp = false; @@ -481,7 +481,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void enderDragonSettings() { enderDragonRidable = getBoolean("mobs.ender_dragon.ridable", enderDragonRidable); enderDragonRidableInWater = getBoolean("mobs.ender_dragon.ridable-in-water", enderDragonRidableInWater); -@@ -813,6 +831,7 @@ public class PurpurWorldConfig { +@@ -822,6 +840,7 @@ public class PurpurWorldConfig { } enderDragonMaxHealth = getDouble("mobs.ender_dragon.attributes.max_health", enderDragonMaxHealth); enderDragonAlwaysDropsFullExp = getBoolean("mobs.ender_dragon.always-drop-full-exp", enderDragonAlwaysDropsFullExp); @@ -489,7 +489,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean endermanRidable = false; -@@ -821,6 +840,7 @@ public class PurpurWorldConfig { +@@ -830,6 +849,7 @@ public class PurpurWorldConfig { public double endermanMaxHealth = 40.0D; public boolean endermanAllowGriefing = true; public boolean endermanDespawnEvenWithBlock = false; @@ -497,7 +497,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void endermanSettings() { endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable); endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater); -@@ -833,6 +853,7 @@ public class PurpurWorldConfig { +@@ -842,6 +862,7 @@ public class PurpurWorldConfig { endermanMaxHealth = getDouble("mobs.enderman.attributes.max_health", endermanMaxHealth); endermanAllowGriefing = getBoolean("mobs.enderman.allow-griefing", endermanAllowGriefing); endermanDespawnEvenWithBlock = getBoolean("mobs.enderman.can-despawn-with-held-block", endermanDespawnEvenWithBlock); @@ -505,7 +505,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean endermiteRidable = false; -@@ -855,6 +876,7 @@ public class PurpurWorldConfig { +@@ -864,6 +885,7 @@ public class PurpurWorldConfig { public boolean evokerRidableInWater = false; public boolean evokerControllable = true; public double evokerMaxHealth = 24.0D; @@ -513,7 +513,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void evokerSettings() { evokerRidable = getBoolean("mobs.evoker.ridable", evokerRidable); evokerRidableInWater = getBoolean("mobs.evoker.ridable-in-water", evokerRidableInWater); -@@ -865,6 +887,7 @@ public class PurpurWorldConfig { +@@ -874,6 +896,7 @@ public class PurpurWorldConfig { set("mobs.evoker.attributes.max_health", oldValue); } evokerMaxHealth = getDouble("mobs.evoker.attributes.max_health", evokerMaxHealth); @@ -521,7 +521,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean foxRidable = false; -@@ -873,6 +896,7 @@ public class PurpurWorldConfig { +@@ -882,6 +905,7 @@ public class PurpurWorldConfig { public double foxMaxHealth = 10.0D; public boolean foxTypeChangesWithTulips = false; public int foxBreedingTicks = 6000; @@ -529,15 +529,15 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void foxSettings() { foxRidable = getBoolean("mobs.fox.ridable", foxRidable); foxRidableInWater = getBoolean("mobs.fox.ridable-in-water", foxRidableInWater); -@@ -885,6 +909,7 @@ public class PurpurWorldConfig { +@@ -894,6 +918,7 @@ public class PurpurWorldConfig { foxMaxHealth = getDouble("mobs.fox.attributes.max_health", foxMaxHealth); foxTypeChangesWithTulips = getBoolean("mobs.fox.tulips-change-type", foxTypeChangesWithTulips); foxBreedingTicks = getInt("mobs.fox.breeding-delay-ticks", foxBreedingTicks); + foxBypassMobGriefing = getBoolean("mobs.fox.bypass-mob-griefing", foxBypassMobGriefing); } - public int frogBreedingTicks = 6000; -@@ -1336,6 +1361,7 @@ public class PurpurWorldConfig { + public boolean frogRidable = false; +@@ -1353,6 +1378,7 @@ public class PurpurWorldConfig { public boolean piglinRidableInWater = false; public boolean piglinControllable = true; public double piglinMaxHealth = 16.0D; @@ -545,7 +545,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void piglinSettings() { piglinRidable = getBoolean("mobs.piglin.ridable", piglinRidable); piglinRidableInWater = getBoolean("mobs.piglin.ridable-in-water", piglinRidableInWater); -@@ -1346,6 +1372,7 @@ public class PurpurWorldConfig { +@@ -1363,6 +1389,7 @@ public class PurpurWorldConfig { set("mobs.piglin.attributes.max_health", oldValue); } piglinMaxHealth = getDouble("mobs.piglin.attributes.max_health", piglinMaxHealth); @@ -553,7 +553,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean piglinBruteRidable = false; -@@ -1368,6 +1395,7 @@ public class PurpurWorldConfig { +@@ -1385,6 +1412,7 @@ public class PurpurWorldConfig { public boolean pillagerRidableInWater = false; public boolean pillagerControllable = true; public double pillagerMaxHealth = 24.0D; @@ -561,7 +561,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void pillagerSettings() { pillagerRidable = getBoolean("mobs.pillager.ridable", pillagerRidable); pillagerRidableInWater = getBoolean("mobs.pillager.ridable-in-water", pillagerRidableInWater); -@@ -1378,6 +1406,7 @@ public class PurpurWorldConfig { +@@ -1395,6 +1423,7 @@ public class PurpurWorldConfig { set("mobs.pillager.attributes.max_health", oldValue); } pillagerMaxHealth = getDouble("mobs.pillager.attributes.max_health", pillagerMaxHealth); @@ -569,7 +569,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean polarBearRidable = false; -@@ -1424,6 +1453,7 @@ public class PurpurWorldConfig { +@@ -1441,6 +1470,7 @@ public class PurpurWorldConfig { public double rabbitNaturalToast = 0.0D; public double rabbitNaturalKiller = 0.0D; public int rabbitBreedingTicks = 6000; @@ -577,7 +577,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void rabbitSettings() { rabbitRidable = getBoolean("mobs.rabbit.ridable", rabbitRidable); rabbitRidableInWater = getBoolean("mobs.rabbit.ridable-in-water", rabbitRidableInWater); -@@ -1437,12 +1467,14 @@ public class PurpurWorldConfig { +@@ -1454,12 +1484,14 @@ public class PurpurWorldConfig { rabbitNaturalToast = getDouble("mobs.rabbit.spawn-toast-chance", rabbitNaturalToast); rabbitNaturalKiller = getDouble("mobs.rabbit.spawn-killer-rabbit-chance", rabbitNaturalKiller); rabbitBreedingTicks = getInt("mobs.rabbit.breeding-delay-ticks", rabbitBreedingTicks); @@ -592,7 +592,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void ravagerSettings() { ravagerRidable = getBoolean("mobs.ravager.ridable", ravagerRidable); ravagerRidableInWater = getBoolean("mobs.ravager.ridable-in-water", ravagerRidableInWater); -@@ -1453,6 +1485,7 @@ public class PurpurWorldConfig { +@@ -1470,6 +1502,7 @@ public class PurpurWorldConfig { set("mobs.ravager.attributes.max_health", oldValue); } ravagerMaxHealth = getDouble("mobs.ravager.attributes.max_health", ravagerMaxHealth); @@ -600,7 +600,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean salmonRidable = false; -@@ -1474,6 +1507,7 @@ public class PurpurWorldConfig { +@@ -1491,6 +1524,7 @@ public class PurpurWorldConfig { public boolean sheepControllable = true; public double sheepMaxHealth = 8.0D; public int sheepBreedingTicks = 6000; @@ -608,7 +608,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void sheepSettings() { sheepRidable = getBoolean("mobs.sheep.ridable", sheepRidable); sheepRidableInWater = getBoolean("mobs.sheep.ridable-in-water", sheepRidableInWater); -@@ -1485,6 +1519,7 @@ public class PurpurWorldConfig { +@@ -1502,6 +1536,7 @@ public class PurpurWorldConfig { } sheepMaxHealth = getDouble("mobs.sheep.attributes.max_health", sheepMaxHealth); sheepBreedingTicks = getInt("mobs.sheep.breeding-delay-ticks", sheepBreedingTicks); @@ -616,7 +616,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean shulkerRidable = false; -@@ -1507,6 +1542,7 @@ public class PurpurWorldConfig { +@@ -1524,6 +1559,7 @@ public class PurpurWorldConfig { public boolean silverfishRidableInWater = false; public boolean silverfishControllable = true; public double silverfishMaxHealth = 8.0D; @@ -624,7 +624,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void silverfishSettings() { silverfishRidable = getBoolean("mobs.silverfish.ridable", silverfishRidable); silverfishRidableInWater = getBoolean("mobs.silverfish.ridable-in-water", silverfishRidableInWater); -@@ -1517,6 +1553,7 @@ public class PurpurWorldConfig { +@@ -1534,6 +1570,7 @@ public class PurpurWorldConfig { set("mobs.silverfish.attributes.max_health", oldValue); } silverfishMaxHealth = getDouble("mobs.silverfish.attributes.max_health", silverfishMaxHealth); @@ -632,7 +632,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean skeletonRidable = false; -@@ -1593,6 +1630,7 @@ public class PurpurWorldConfig { +@@ -1610,6 +1647,7 @@ public class PurpurWorldConfig { public int snowGolemSnowBallMax = 20; public float snowGolemSnowBallModifier = 10.0F; public double snowGolemAttackDistance = 1.25D; @@ -640,7 +640,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void snowGolemSettings() { snowGolemRidable = getBoolean("mobs.snow_golem.ridable", snowGolemRidable); snowGolemRidableInWater = getBoolean("mobs.snow_golem.ridable-in-water", snowGolemRidableInWater); -@@ -1610,6 +1648,7 @@ public class PurpurWorldConfig { +@@ -1627,6 +1665,7 @@ public class PurpurWorldConfig { snowGolemSnowBallMax = getInt("mobs.snow_golem.max-shoot-interval-ticks", snowGolemSnowBallMax); snowGolemSnowBallModifier = (float) getDouble("mobs.snow_golem.snow-ball-modifier", snowGolemSnowBallModifier); snowGolemAttackDistance = getDouble("mobs.snow_golem.attack-distance", snowGolemAttackDistance); @@ -648,7 +648,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean squidRidable = false; -@@ -1776,6 +1815,7 @@ public class PurpurWorldConfig { +@@ -1802,6 +1841,7 @@ public class PurpurWorldConfig { public int villagerBreedingTicks = 6000; public boolean villagerClericsFarmWarts = false; public boolean villagerClericFarmersThrowWarts = true; @@ -656,7 +656,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -1794,6 +1834,7 @@ public class PurpurWorldConfig { +@@ -1820,6 +1860,7 @@ public class PurpurWorldConfig { villagerBreedingTicks = getInt("mobs.villager.breeding-delay-ticks", villagerBreedingTicks); villagerClericsFarmWarts = getBoolean("mobs.villager.clerics-farm-warts", villagerClericsFarmWarts); villagerClericFarmersThrowWarts = getBoolean("mobs.villager.cleric-wart-farmers-throw-warts-at-villagers", villagerClericFarmersThrowWarts); @@ -664,7 +664,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean vindicatorRidable = false; -@@ -1857,6 +1898,7 @@ public class PurpurWorldConfig { +@@ -1892,6 +1933,7 @@ public class PurpurWorldConfig { public double witherMaxHealth = 300.0D; public float witherHealthRegenAmount = 1.0f; public int witherHealthRegenDelay = 20; @@ -672,7 +672,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void witherSettings() { witherRidable = getBoolean("mobs.wither.ridable", witherRidable); witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater); -@@ -1874,6 +1916,7 @@ public class PurpurWorldConfig { +@@ -1909,6 +1951,7 @@ public class PurpurWorldConfig { witherMaxHealth = getDouble("mobs.wither.attributes.max_health", witherMaxHealth); witherHealthRegenAmount = (float) getDouble("mobs.wither.health-regen-amount", witherHealthRegenAmount); witherHealthRegenDelay = getInt("mobs.wither.health-regen-delay", witherHealthRegenDelay); @@ -680,7 +680,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 } public boolean witherSkeletonRidable = false; -@@ -1945,6 +1988,7 @@ public class PurpurWorldConfig { +@@ -1980,6 +2023,7 @@ public class PurpurWorldConfig { public double zombieJockeyChance = 0.05D; public boolean zombieJockeyTryExistingChickens = true; public boolean zombieAggressiveTowardsVillagerWhenLagging = true; @@ -688,7 +688,7 @@ index c93c78b1d4d6816794c5a8a97f1d4f04823c7fd8..23d4b864bffe8ccb313882c4a59c03a4 private void zombieSettings() { zombieRidable = getBoolean("mobs.zombie.ridable", zombieRidable); zombieRidableInWater = getBoolean("mobs.zombie.ridable-in-water", zombieRidableInWater); -@@ -1960,6 +2004,7 @@ public class PurpurWorldConfig { +@@ -1995,6 +2039,7 @@ public class PurpurWorldConfig { zombieJockeyChance = getDouble("mobs.zombie.jockey.chance", zombieJockeyChance); zombieJockeyTryExistingChickens = getBoolean("mobs.zombie.jockey.try-existing-chickens", zombieJockeyTryExistingChickens); zombieAggressiveTowardsVillagerWhenLagging = getBoolean("mobs.zombie.aggressive-towards-villager-when-lagging", zombieAggressiveTowardsVillagerWhenLagging); diff --git a/patches/server/0137-Toggle-for-water-sensitive-mob-damage.patch b/patches/server/0137-Toggle-for-water-sensitive-mob-damage.patch index 57a7904ce..2ac6aab55 100644 --- a/patches/server/0137-Toggle-for-water-sensitive-mob-damage.patch +++ b/patches/server/0137-Toggle-for-water-sensitive-mob-damage.patch @@ -37,7 +37,7 @@ index 007c945725721ddb8a3dc4b8085e8c68da741b93..53ef2004d1b6acaf27fef9a658fff99b @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 374a026de1fec53ba3433e528d03ad103fa25f86..15b8992ef9f77153885cb27e305e854f8d775864 100644 +index f9ae9bf91026adcb205302e0f902dda44febb744..6bcdc433ab80be133cfb56beda8b01d995ace7af 100644 --- a/src/main/java/net/minecraft/world/entity/animal/Bee.java +++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java @@ -176,7 +176,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal { @@ -571,10 +571,10 @@ index d655bd2ecce01a54695d135b12b2f930fa368ffe..a9e07815fdde8509267c48d41d0e5fd5 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 3dfb7f3d11b69e08682d8b955adde3576c3ce6a1..4af8c387f47017e453e74a86a53726386ed2d1b9 100644 +index 2207c5a71b8a3c7c0c68388ec744c5272d10ab36..1329de5d3e6294d2eb7b6852b8cad19f0f4dba77 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 -@@ -222,6 +222,11 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -234,6 +234,11 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob public void initAttributes() { this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(this.level.purpurConfig.witherMaxHealth); } @@ -1197,18 +1197,16 @@ index 8756e0d8d0077308f5fb74bf45fe093d0f043c99..6dd8856816bebb2766203589048cc68b @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0b1882205 100644 +index 3fb8b19465851ba32c89282f80256c0c63312550..ae397e14d579d4039d9a8b70a29d96b8a9cf944e 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -544,6 +544,7 @@ public class PurpurWorldConfig { - useNightVisionWhenRiding = getBoolean("ridable-settings.use-night-vision", useNightVisionWhenRiding); - } - -+ public boolean axolotlTakeDamageFromWater = false; - public boolean axolotlRidable = false; +@@ -557,11 +557,13 @@ public class PurpurWorldConfig { public boolean axolotlControllable = true; public double axolotlMaxHealth = 14.0D; -@@ -553,6 +554,7 @@ public class PurpurWorldConfig { + public int axolotlBreedingTicks = 6000; ++ public boolean axolotlTakeDamageFromWater = false; + private void axolotlSettings() { + axolotlRidable = getBoolean("mobs.axolotl.ridable", axolotlRidable); axolotlControllable = getBoolean("mobs.axolotl.controllable", axolotlControllable); axolotlMaxHealth = getDouble("mobs.axolotl.attributes.max_health", axolotlMaxHealth); axolotlBreedingTicks = getInt("mobs.axolotl.breeding-delay-ticks", axolotlBreedingTicks); @@ -1216,7 +1214,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean batRidable = false; -@@ -567,6 +569,7 @@ public class PurpurWorldConfig { +@@ -576,6 +578,7 @@ public class PurpurWorldConfig { public double batArmor = 0.0D; public double batArmorToughness = 0.0D; public double batAttackKnockback = 0.0D; @@ -1224,7 +1222,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void batSettings() { batRidable = getBoolean("mobs.bat.ridable", batRidable); batRidableInWater = getBoolean("mobs.bat.ridable-in-water", batRidableInWater); -@@ -578,6 +581,7 @@ public class PurpurWorldConfig { +@@ -587,6 +590,7 @@ public class PurpurWorldConfig { set("mobs.bat.attributes.max_health", oldValue); } batMaxHealth = getDouble("mobs.bat.attributes.max_health", batMaxHealth); @@ -1232,7 +1230,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean beeRidable = false; -@@ -586,6 +590,7 @@ public class PurpurWorldConfig { +@@ -595,6 +599,7 @@ public class PurpurWorldConfig { public double beeMaxY = 320D; public double beeMaxHealth = 10.0D; public int beeBreedingTicks = 6000; @@ -1240,7 +1238,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void beeSettings() { beeRidable = getBoolean("mobs.bee.ridable", beeRidable); beeRidableInWater = getBoolean("mobs.bee.ridable-in-water", beeRidableInWater); -@@ -598,6 +603,7 @@ public class PurpurWorldConfig { +@@ -607,6 +612,7 @@ public class PurpurWorldConfig { } beeMaxHealth = getDouble("mobs.bee.attributes.max_health", beeMaxHealth); beeBreedingTicks = getInt("mobs.bee.breeding-delay-ticks", beeBreedingTicks); @@ -1248,7 +1246,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean blazeRidable = false; -@@ -605,6 +611,7 @@ public class PurpurWorldConfig { +@@ -614,6 +620,7 @@ public class PurpurWorldConfig { public boolean blazeControllable = true; public double blazeMaxY = 320D; public double blazeMaxHealth = 20.0D; @@ -1256,7 +1254,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void blazeSettings() { blazeRidable = getBoolean("mobs.blaze.ridable", blazeRidable); blazeRidableInWater = getBoolean("mobs.blaze.ridable-in-water", blazeRidableInWater); -@@ -616,6 +623,7 @@ public class PurpurWorldConfig { +@@ -625,6 +632,7 @@ public class PurpurWorldConfig { set("mobs.blaze.attributes.max_health", oldValue); } blazeMaxHealth = getDouble("mobs.blaze.attributes.max_health", blazeMaxHealth); @@ -1264,7 +1262,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean catRidable = false; -@@ -627,6 +635,7 @@ public class PurpurWorldConfig { +@@ -636,6 +644,7 @@ public class PurpurWorldConfig { public int catSpawnVillageScanRange = 48; public int catBreedingTicks = 6000; public DyeColor catDefaultCollarColor = DyeColor.RED; @@ -1272,7 +1270,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void catSettings() { catRidable = getBoolean("mobs.cat.ridable", catRidable); catRidableInWater = getBoolean("mobs.cat.ridable-in-water", catRidableInWater); -@@ -646,12 +655,14 @@ public class PurpurWorldConfig { +@@ -655,12 +664,14 @@ public class PurpurWorldConfig { } catch (IllegalArgumentException ignore) { catDefaultCollarColor = DyeColor.RED; } @@ -1287,7 +1285,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void caveSpiderSettings() { caveSpiderRidable = getBoolean("mobs.cave_spider.ridable", caveSpiderRidable); caveSpiderRidableInWater = getBoolean("mobs.cave_spider.ridable-in-water", caveSpiderRidableInWater); -@@ -662,6 +673,7 @@ public class PurpurWorldConfig { +@@ -671,6 +682,7 @@ public class PurpurWorldConfig { set("mobs.cave_spider.attributes.max_health", oldValue); } caveSpiderMaxHealth = getDouble("mobs.cave_spider.attributes.max_health", caveSpiderMaxHealth); @@ -1295,7 +1293,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean chickenRidable = false; -@@ -670,6 +682,7 @@ public class PurpurWorldConfig { +@@ -679,6 +691,7 @@ public class PurpurWorldConfig { public double chickenMaxHealth = 4.0D; public boolean chickenRetaliate = false; public int chickenBreedingTicks = 6000; @@ -1303,7 +1301,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void chickenSettings() { chickenRidable = getBoolean("mobs.chicken.ridable", chickenRidable); chickenRidableInWater = getBoolean("mobs.chicken.ridable-in-water", chickenRidableInWater); -@@ -682,11 +695,13 @@ public class PurpurWorldConfig { +@@ -691,11 +704,13 @@ public class PurpurWorldConfig { chickenMaxHealth = getDouble("mobs.chicken.attributes.max_health", chickenMaxHealth); chickenRetaliate = getBoolean("mobs.chicken.retaliate", chickenRetaliate); chickenBreedingTicks = getInt("mobs.chicken.breeding-delay-ticks", chickenBreedingTicks); @@ -1317,7 +1315,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void codSettings() { codRidable = getBoolean("mobs.cod.ridable", codRidable); codControllable = getBoolean("mobs.cod.controllable", codControllable); -@@ -696,6 +711,7 @@ public class PurpurWorldConfig { +@@ -705,6 +720,7 @@ public class PurpurWorldConfig { set("mobs.cod.attributes.max_health", oldValue); } codMaxHealth = getDouble("mobs.cod.attributes.max_health", codMaxHealth); @@ -1325,7 +1323,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean cowRidable = false; -@@ -704,6 +720,7 @@ public class PurpurWorldConfig { +@@ -713,6 +729,7 @@ public class PurpurWorldConfig { public double cowMaxHealth = 10.0D; public int cowFeedMushrooms = 0; public int cowBreedingTicks = 6000; @@ -1333,7 +1331,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void cowSettings() { cowRidable = getBoolean("mobs.cow.ridable", cowRidable); cowRidableInWater = getBoolean("mobs.cow.ridable-in-water", cowRidableInWater); -@@ -716,6 +733,7 @@ public class PurpurWorldConfig { +@@ -725,6 +742,7 @@ public class PurpurWorldConfig { cowMaxHealth = getDouble("mobs.cow.attributes.max_health", cowMaxHealth); cowFeedMushrooms = getInt("mobs.cow.feed-mushrooms-for-mooshroom", cowFeedMushrooms); cowBreedingTicks = getInt("mobs.cow.breeding-delay-ticks", cowBreedingTicks); @@ -1341,7 +1339,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean creeperRidable = false; -@@ -725,6 +743,7 @@ public class PurpurWorldConfig { +@@ -734,6 +752,7 @@ public class PurpurWorldConfig { public double creeperChargedChance = 0.0D; public boolean creeperAllowGriefing = true; public boolean creeperBypassMobGriefing = false; @@ -1349,7 +1347,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void creeperSettings() { creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable); creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater); -@@ -738,6 +757,7 @@ public class PurpurWorldConfig { +@@ -747,6 +766,7 @@ public class PurpurWorldConfig { creeperChargedChance = getDouble("mobs.creeper.naturally-charged-chance", creeperChargedChance); creeperAllowGriefing = getBoolean("mobs.creeper.allow-griefing", creeperAllowGriefing); creeperBypassMobGriefing = getBoolean("mobs.creeper.bypass-mob-griefing", creeperBypassMobGriefing); @@ -1357,7 +1355,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean dolphinRidable = false; -@@ -747,6 +767,7 @@ public class PurpurWorldConfig { +@@ -756,6 +776,7 @@ public class PurpurWorldConfig { public float dolphinSpitDamage = 2.0F; public double dolphinMaxHealth = 10.0D; public boolean dolphinDisableTreasureSearching = false; @@ -1365,7 +1363,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void dolphinSettings() { dolphinRidable = getBoolean("mobs.dolphin.ridable", dolphinRidable); dolphinControllable = getBoolean("mobs.dolphin.controllable", dolphinControllable); -@@ -760,6 +781,7 @@ public class PurpurWorldConfig { +@@ -769,6 +790,7 @@ public class PurpurWorldConfig { } dolphinMaxHealth = getDouble("mobs.dolphin.attributes.max_health", dolphinMaxHealth); dolphinDisableTreasureSearching = getBoolean("mobs.dolphin.disable-treasure-searching", dolphinDisableTreasureSearching); @@ -1373,7 +1371,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean donkeyRidableInWater = false; -@@ -770,6 +792,7 @@ public class PurpurWorldConfig { +@@ -779,6 +801,7 @@ public class PurpurWorldConfig { public double donkeyMovementSpeedMin = 0.175D; public double donkeyMovementSpeedMax = 0.175D; public int donkeyBreedingTicks = 6000; @@ -1381,7 +1379,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void donkeySettings() { donkeyRidableInWater = getBoolean("mobs.donkey.ridable-in-water", donkeyRidableInWater); if (PurpurConfig.version < 10) { -@@ -786,6 +809,7 @@ public class PurpurWorldConfig { +@@ -795,6 +818,7 @@ public class PurpurWorldConfig { donkeyMovementSpeedMin = getDouble("mobs.donkey.attributes.movement_speed.min", donkeyMovementSpeedMin); donkeyMovementSpeedMax = getDouble("mobs.donkey.attributes.movement_speed.max", donkeyMovementSpeedMax); donkeyBreedingTicks = getInt("mobs.donkey.breeding-delay-ticks", donkeyBreedingTicks); @@ -1389,7 +1387,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean drownedRidable = false; -@@ -796,6 +820,7 @@ public class PurpurWorldConfig { +@@ -805,6 +829,7 @@ public class PurpurWorldConfig { public boolean drownedJockeyOnlyBaby = true; public double drownedJockeyChance = 0.05D; public boolean drownedJockeyTryExistingChickens = true; @@ -1397,7 +1395,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void drownedSettings() { drownedRidable = getBoolean("mobs.drowned.ridable", drownedRidable); drownedRidableInWater = getBoolean("mobs.drowned.ridable-in-water", drownedRidableInWater); -@@ -810,11 +835,13 @@ public class PurpurWorldConfig { +@@ -819,11 +844,13 @@ public class PurpurWorldConfig { drownedJockeyOnlyBaby = getBoolean("mobs.drowned.jockey.only-babies", drownedJockeyOnlyBaby); drownedJockeyChance = getDouble("mobs.drowned.jockey.chance", drownedJockeyChance); drownedJockeyTryExistingChickens = getBoolean("mobs.drowned.jockey.try-existing-chickens", drownedJockeyTryExistingChickens); @@ -1411,7 +1409,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void elderGuardianSettings() { elderGuardianRidable = getBoolean("mobs.elder_guardian.ridable", elderGuardianRidable); elderGuardianControllable = getBoolean("mobs.elder_guardian.controllable", elderGuardianControllable); -@@ -824,6 +851,7 @@ public class PurpurWorldConfig { +@@ -833,6 +860,7 @@ public class PurpurWorldConfig { set("mobs.elder_guardian.attributes.max_health", oldValue); } elderGuardianMaxHealth = getDouble("mobs.elder_guardian.attributes.max_health", elderGuardianMaxHealth); @@ -1419,7 +1417,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean enderDragonRidable = false; -@@ -833,6 +861,7 @@ public class PurpurWorldConfig { +@@ -842,6 +870,7 @@ public class PurpurWorldConfig { public double enderDragonMaxHealth = 200.0D; public boolean enderDragonAlwaysDropsFullExp = false; public boolean enderDragonBypassMobGriefing = false; @@ -1427,7 +1425,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void enderDragonSettings() { enderDragonRidable = getBoolean("mobs.ender_dragon.ridable", enderDragonRidable); enderDragonRidableInWater = getBoolean("mobs.ender_dragon.ridable-in-water", enderDragonRidableInWater); -@@ -850,6 +879,7 @@ public class PurpurWorldConfig { +@@ -859,6 +888,7 @@ public class PurpurWorldConfig { enderDragonMaxHealth = getDouble("mobs.ender_dragon.attributes.max_health", enderDragonMaxHealth); enderDragonAlwaysDropsFullExp = getBoolean("mobs.ender_dragon.always-drop-full-exp", enderDragonAlwaysDropsFullExp); enderDragonBypassMobGriefing = getBoolean("mobs.ender_dragon.bypass-mob-griefing", enderDragonBypassMobGriefing); @@ -1435,7 +1433,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean endermanRidable = false; -@@ -859,6 +889,7 @@ public class PurpurWorldConfig { +@@ -868,6 +898,7 @@ public class PurpurWorldConfig { public boolean endermanAllowGriefing = true; public boolean endermanDespawnEvenWithBlock = false; public boolean endermanBypassMobGriefing = false; @@ -1443,7 +1441,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void endermanSettings() { endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable); endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater); -@@ -872,12 +903,14 @@ public class PurpurWorldConfig { +@@ -881,12 +912,14 @@ public class PurpurWorldConfig { endermanAllowGriefing = getBoolean("mobs.enderman.allow-griefing", endermanAllowGriefing); endermanDespawnEvenWithBlock = getBoolean("mobs.enderman.can-despawn-with-held-block", endermanDespawnEvenWithBlock); endermanBypassMobGriefing = getBoolean("mobs.enderman.bypass-mob-griefing", endermanBypassMobGriefing); @@ -1458,7 +1456,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void endermiteSettings() { endermiteRidable = getBoolean("mobs.endermite.ridable", endermiteRidable); endermiteRidableInWater = getBoolean("mobs.endermite.ridable-in-water", endermiteRidableInWater); -@@ -888,6 +921,7 @@ public class PurpurWorldConfig { +@@ -897,6 +930,7 @@ public class PurpurWorldConfig { set("mobs.endermite.attributes.max_health", oldValue); } endermiteMaxHealth = getDouble("mobs.endermite.attributes.max_health", endermiteMaxHealth); @@ -1466,7 +1464,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean evokerRidable = false; -@@ -895,6 +929,7 @@ public class PurpurWorldConfig { +@@ -904,6 +938,7 @@ public class PurpurWorldConfig { public boolean evokerControllable = true; public double evokerMaxHealth = 24.0D; public boolean evokerBypassMobGriefing = false; @@ -1474,7 +1472,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void evokerSettings() { evokerRidable = getBoolean("mobs.evoker.ridable", evokerRidable); evokerRidableInWater = getBoolean("mobs.evoker.ridable-in-water", evokerRidableInWater); -@@ -906,6 +941,7 @@ public class PurpurWorldConfig { +@@ -915,6 +950,7 @@ public class PurpurWorldConfig { } evokerMaxHealth = getDouble("mobs.evoker.attributes.max_health", evokerMaxHealth); evokerBypassMobGriefing = getBoolean("mobs.evoker.bypass-mob-griefing", evokerBypassMobGriefing); @@ -1482,7 +1480,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean foxRidable = false; -@@ -915,6 +951,7 @@ public class PurpurWorldConfig { +@@ -924,6 +960,7 @@ public class PurpurWorldConfig { public boolean foxTypeChangesWithTulips = false; public int foxBreedingTicks = 6000; public boolean foxBypassMobGriefing = false; @@ -1490,15 +1488,15 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void foxSettings() { foxRidable = getBoolean("mobs.fox.ridable", foxRidable); foxRidableInWater = getBoolean("mobs.fox.ridable-in-water", foxRidableInWater); -@@ -928,6 +965,7 @@ public class PurpurWorldConfig { +@@ -937,6 +974,7 @@ public class PurpurWorldConfig { foxTypeChangesWithTulips = getBoolean("mobs.fox.tulips-change-type", foxTypeChangesWithTulips); foxBreedingTicks = getInt("mobs.fox.breeding-delay-ticks", foxBreedingTicks); foxBypassMobGriefing = getBoolean("mobs.fox.bypass-mob-griefing", foxBypassMobGriefing); + foxTakeDamageFromWater = getBoolean("mobs.fox.takes-damage-from-water", foxTakeDamageFromWater); } - public int frogBreedingTicks = 6000; -@@ -940,6 +978,7 @@ public class PurpurWorldConfig { + public boolean frogRidable = false; +@@ -957,6 +995,7 @@ public class PurpurWorldConfig { public boolean ghastControllable = true; public double ghastMaxY = 320D; public double ghastMaxHealth = 10.0D; @@ -1506,7 +1504,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void ghastSettings() { ghastRidable = getBoolean("mobs.ghast.ridable", ghastRidable); ghastRidableInWater = getBoolean("mobs.ghast.ridable-in-water", ghastRidableInWater); -@@ -951,6 +990,7 @@ public class PurpurWorldConfig { +@@ -968,6 +1007,7 @@ public class PurpurWorldConfig { set("mobs.ghast.attributes.max_health", oldValue); } ghastMaxHealth = getDouble("mobs.ghast.attributes.max_health", ghastMaxHealth); @@ -1514,7 +1512,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean giantRidable = false; -@@ -963,6 +1003,7 @@ public class PurpurWorldConfig { +@@ -980,6 +1020,7 @@ public class PurpurWorldConfig { public float giantJumpHeight = 1.0F; public boolean giantHaveAI = false; public boolean giantHaveHostileAI = false; @@ -1522,7 +1520,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void giantSettings() { giantRidable = getBoolean("mobs.giant.ridable", giantRidable); giantRidableInWater = getBoolean("mobs.giant.ridable-in-water", giantRidableInWater); -@@ -983,17 +1024,20 @@ public class PurpurWorldConfig { +@@ -1000,17 +1041,20 @@ public class PurpurWorldConfig { giantJumpHeight = (float) getDouble("mobs.giant.jump-height", giantJumpHeight); giantHaveAI = getBoolean("mobs.giant.have-ai", giantHaveAI); giantHaveHostileAI = getBoolean("mobs.giant.have-hostile-ai", giantHaveHostileAI); @@ -1543,7 +1541,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean goatRidable = false; -@@ -1001,17 +1045,20 @@ public class PurpurWorldConfig { +@@ -1018,17 +1062,20 @@ public class PurpurWorldConfig { public boolean goatControllable = true; public double goatMaxHealth = 10.0D; public int goatBreedingTicks = 6000; @@ -1564,7 +1562,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void guardianSettings() { guardianRidable = getBoolean("mobs.guardian.ridable", guardianRidable); guardianControllable = getBoolean("mobs.guardian.controllable", guardianControllable); -@@ -1021,6 +1068,7 @@ public class PurpurWorldConfig { +@@ -1038,6 +1085,7 @@ public class PurpurWorldConfig { set("mobs.guardian.attributes.max_health", oldValue); } guardianMaxHealth = getDouble("mobs.guardian.attributes.max_health", guardianMaxHealth); @@ -1572,7 +1570,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean hoglinRidable = false; -@@ -1028,6 +1076,7 @@ public class PurpurWorldConfig { +@@ -1045,6 +1093,7 @@ public class PurpurWorldConfig { public boolean hoglinControllable = true; public double hoglinMaxHealth = 40.0D; public int hoglinBreedingTicks = 6000; @@ -1580,7 +1578,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void hoglinSettings() { hoglinRidable = getBoolean("mobs.hoglin.ridable", hoglinRidable); hoglinRidableInWater = getBoolean("mobs.hoglin.ridable-in-water", hoglinRidableInWater); -@@ -1039,6 +1088,7 @@ public class PurpurWorldConfig { +@@ -1056,6 +1105,7 @@ public class PurpurWorldConfig { } hoglinMaxHealth = getDouble("mobs.hoglin.attributes.max_health", hoglinMaxHealth); hoglinBreedingTicks = getInt("mobs.hoglin.breeding-delay-ticks", hoglinBreedingTicks); @@ -1588,7 +1586,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean horseRidableInWater = false; -@@ -1049,6 +1099,7 @@ public class PurpurWorldConfig { +@@ -1066,6 +1116,7 @@ public class PurpurWorldConfig { public double horseMovementSpeedMin = 0.1125D; public double horseMovementSpeedMax = 0.3375D; public int horseBreedingTicks = 6000; @@ -1596,7 +1594,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void horseSettings() { horseRidableInWater = getBoolean("mobs.horse.ridable-in-water", horseRidableInWater); if (PurpurConfig.version < 10) { -@@ -1065,6 +1116,7 @@ public class PurpurWorldConfig { +@@ -1082,6 +1133,7 @@ public class PurpurWorldConfig { horseMovementSpeedMin = getDouble("mobs.horse.attributes.movement_speed.min", horseMovementSpeedMin); horseMovementSpeedMax = getDouble("mobs.horse.attributes.movement_speed.max", horseMovementSpeedMax); horseBreedingTicks = getInt("mobs.horse.breeding-delay-ticks", horseBreedingTicks); @@ -1604,7 +1602,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean huskRidable = false; -@@ -1075,6 +1127,7 @@ public class PurpurWorldConfig { +@@ -1092,6 +1144,7 @@ public class PurpurWorldConfig { public boolean huskJockeyOnlyBaby = true; public double huskJockeyChance = 0.05D; public boolean huskJockeyTryExistingChickens = true; @@ -1612,7 +1610,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void huskSettings() { huskRidable = getBoolean("mobs.husk.ridable", huskRidable); huskRidableInWater = getBoolean("mobs.husk.ridable-in-water", huskRidableInWater); -@@ -1089,6 +1142,7 @@ public class PurpurWorldConfig { +@@ -1106,6 +1159,7 @@ public class PurpurWorldConfig { huskJockeyOnlyBaby = getBoolean("mobs.husk.jockey.only-babies", huskJockeyOnlyBaby); huskJockeyChance = getDouble("mobs.husk.jockey.chance", huskJockeyChance); huskJockeyTryExistingChickens = getBoolean("mobs.husk.jockey.try-existing-chickens", huskJockeyTryExistingChickens); @@ -1620,7 +1618,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean illusionerRidable = false; -@@ -1097,6 +1151,7 @@ public class PurpurWorldConfig { +@@ -1114,6 +1168,7 @@ public class PurpurWorldConfig { public double illusionerMovementSpeed = 0.5D; public double illusionerFollowRange = 18.0D; public double illusionerMaxHealth = 32.0D; @@ -1628,7 +1626,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void illusionerSettings() { illusionerRidable = getBoolean("mobs.illusioner.ridable", illusionerRidable); illusionerRidableInWater = getBoolean("mobs.illusioner.ridable-in-water", illusionerRidableInWater); -@@ -1113,6 +1168,7 @@ public class PurpurWorldConfig { +@@ -1130,6 +1185,7 @@ public class PurpurWorldConfig { set("mobs.illusioner.attributes.max_health", oldValue); } illusionerMaxHealth = getDouble("mobs.illusioner.attributes.max_health", illusionerMaxHealth); @@ -1636,7 +1634,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean ironGolemRidable = false; -@@ -1120,6 +1176,7 @@ public class PurpurWorldConfig { +@@ -1137,6 +1193,7 @@ public class PurpurWorldConfig { public boolean ironGolemControllable = true; public boolean ironGolemCanSwim = false; public double ironGolemMaxHealth = 100.0D; @@ -1644,7 +1642,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void ironGolemSettings() { ironGolemRidable = getBoolean("mobs.iron_golem.ridable", ironGolemRidable); ironGolemRidableInWater = getBoolean("mobs.iron_golem.ridable-in-water", ironGolemRidableInWater); -@@ -1131,6 +1188,7 @@ public class PurpurWorldConfig { +@@ -1148,6 +1205,7 @@ public class PurpurWorldConfig { set("mobs.iron_golem.attributes.max_health", oldValue); } ironGolemMaxHealth = getDouble("mobs.iron_golem.attributes.max_health", ironGolemMaxHealth); @@ -1652,7 +1650,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean llamaRidable = false; -@@ -1143,6 +1201,7 @@ public class PurpurWorldConfig { +@@ -1160,6 +1218,7 @@ public class PurpurWorldConfig { public double llamaMovementSpeedMin = 0.175D; public double llamaMovementSpeedMax = 0.175D; public int llamaBreedingTicks = 6000; @@ -1660,7 +1658,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void llamaSettings() { llamaRidable = getBoolean("mobs.llama.ridable", llamaRidable); llamaRidableInWater = getBoolean("mobs.llama.ridable-in-water", llamaRidableInWater); -@@ -1161,6 +1220,7 @@ public class PurpurWorldConfig { +@@ -1178,6 +1237,7 @@ public class PurpurWorldConfig { llamaMovementSpeedMin = getDouble("mobs.llama.attributes.movement_speed.min", llamaMovementSpeedMin); llamaMovementSpeedMax = getDouble("mobs.llama.attributes.movement_speed.max", llamaMovementSpeedMax); llamaBreedingTicks = getInt("mobs.llama.breeding-delay-ticks", llamaBreedingTicks); @@ -1668,7 +1666,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean magmaCubeRidable = false; -@@ -1170,6 +1230,7 @@ public class PurpurWorldConfig { +@@ -1187,6 +1247,7 @@ public class PurpurWorldConfig { public String magmaCubeAttackDamage = "size"; public Map magmaCubeMaxHealthCache = new HashMap<>(); public Map magmaCubeAttackDamageCache = new HashMap<>(); @@ -1676,7 +1674,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void magmaCubeSettings() { magmaCubeRidable = getBoolean("mobs.magma_cube.ridable", magmaCubeRidable); magmaCubeRidableInWater = getBoolean("mobs.magma_cube.ridable-in-water", magmaCubeRidableInWater); -@@ -1183,6 +1244,7 @@ public class PurpurWorldConfig { +@@ -1200,6 +1261,7 @@ public class PurpurWorldConfig { magmaCubeAttackDamage = getString("mobs.magma_cube.attributes.attack_damage", magmaCubeAttackDamage); magmaCubeMaxHealthCache.clear(); magmaCubeAttackDamageCache.clear(); @@ -1684,7 +1682,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean mooshroomRidable = false; -@@ -1190,6 +1252,7 @@ public class PurpurWorldConfig { +@@ -1207,6 +1269,7 @@ public class PurpurWorldConfig { public boolean mooshroomControllable = true; public double mooshroomMaxHealth = 10.0D; public int mooshroomBreedingTicks = 6000; @@ -1692,7 +1690,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void mooshroomSettings() { mooshroomRidable = getBoolean("mobs.mooshroom.ridable", mooshroomRidable); mooshroomRidableInWater = getBoolean("mobs.mooshroom.ridable-in-water", mooshroomRidableInWater); -@@ -1201,6 +1264,7 @@ public class PurpurWorldConfig { +@@ -1218,6 +1281,7 @@ public class PurpurWorldConfig { } mooshroomMaxHealth = getDouble("mobs.mooshroom.attributes.max_health", mooshroomMaxHealth); mooshroomBreedingTicks = getInt("mobs.mooshroom.breeding-delay-ticks", mooshroomBreedingTicks); @@ -1700,7 +1698,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean muleRidableInWater = false; -@@ -1211,6 +1275,7 @@ public class PurpurWorldConfig { +@@ -1228,6 +1292,7 @@ public class PurpurWorldConfig { public double muleMovementSpeedMin = 0.175D; public double muleMovementSpeedMax = 0.175D; public int muleBreedingTicks = 6000; @@ -1708,7 +1706,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void muleSettings() { muleRidableInWater = getBoolean("mobs.mule.ridable-in-water", muleRidableInWater); if (PurpurConfig.version < 10) { -@@ -1227,6 +1292,7 @@ public class PurpurWorldConfig { +@@ -1244,6 +1309,7 @@ public class PurpurWorldConfig { muleMovementSpeedMin = getDouble("mobs.mule.attributes.movement_speed.min", muleMovementSpeedMin); muleMovementSpeedMax = getDouble("mobs.mule.attributes.movement_speed.max", muleMovementSpeedMax); muleBreedingTicks = getInt("mobs.mule.breeding-delay-ticks", muleBreedingTicks); @@ -1716,7 +1714,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean ocelotRidable = false; -@@ -1234,6 +1300,7 @@ public class PurpurWorldConfig { +@@ -1251,6 +1317,7 @@ public class PurpurWorldConfig { public boolean ocelotControllable = true; public double ocelotMaxHealth = 10.0D; public int ocelotBreedingTicks = 6000; @@ -1724,7 +1722,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void ocelotSettings() { ocelotRidable = getBoolean("mobs.ocelot.ridable", ocelotRidable); ocelotRidableInWater = getBoolean("mobs.ocelot.ridable-in-water", ocelotRidableInWater); -@@ -1245,6 +1312,7 @@ public class PurpurWorldConfig { +@@ -1262,6 +1329,7 @@ public class PurpurWorldConfig { } ocelotMaxHealth = getDouble("mobs.ocelot.attributes.max_health", ocelotMaxHealth); ocelotBreedingTicks = getInt("mobs.ocelot.breeding-delay-ticks", ocelotBreedingTicks); @@ -1732,7 +1730,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean pandaRidable = false; -@@ -1252,6 +1320,7 @@ public class PurpurWorldConfig { +@@ -1269,6 +1337,7 @@ public class PurpurWorldConfig { public boolean pandaControllable = true; public double pandaMaxHealth = 20.0D; public int pandaBreedingTicks = 6000; @@ -1740,7 +1738,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void pandaSettings() { pandaRidable = getBoolean("mobs.panda.ridable", pandaRidable); pandaRidableInWater = getBoolean("mobs.panda.ridable-in-water", pandaRidableInWater); -@@ -1263,6 +1332,7 @@ public class PurpurWorldConfig { +@@ -1280,6 +1349,7 @@ public class PurpurWorldConfig { } pandaMaxHealth = getDouble("mobs.panda.attributes.max_health", pandaMaxHealth); pandaBreedingTicks = getInt("mobs.panda.breeding-delay-ticks", pandaBreedingTicks); @@ -1748,7 +1746,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean parrotRidable = false; -@@ -1270,6 +1340,7 @@ public class PurpurWorldConfig { +@@ -1287,6 +1357,7 @@ public class PurpurWorldConfig { public boolean parrotControllable = true; public double parrotMaxY = 320D; public double parrotMaxHealth = 6.0D; @@ -1756,7 +1754,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void parrotSettings() { parrotRidable = getBoolean("mobs.parrot.ridable", parrotRidable); parrotRidableInWater = getBoolean("mobs.parrot.ridable-in-water", parrotRidableInWater); -@@ -1281,6 +1352,7 @@ public class PurpurWorldConfig { +@@ -1298,6 +1369,7 @@ public class PurpurWorldConfig { set("mobs.parrot.attributes.max_health", oldValue); } parrotMaxHealth = getDouble("mobs.parrot.attributes.max_health", parrotMaxHealth); @@ -1764,7 +1762,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean phantomRidable = false; -@@ -1313,6 +1385,7 @@ public class PurpurWorldConfig { +@@ -1330,6 +1402,7 @@ public class PurpurWorldConfig { public boolean phantomIgnorePlayersWithTorch = false; public boolean phantomBurnInDaylight = true; public boolean phantomFlamesOnSwoop = false; @@ -1772,7 +1770,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void phantomSettings() { phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable); phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater); -@@ -1353,6 +1426,7 @@ public class PurpurWorldConfig { +@@ -1370,6 +1443,7 @@ public class PurpurWorldConfig { phantomBurnInDaylight = getBoolean("mobs.phantom.burn-in-daylight", phantomBurnInDaylight); phantomIgnorePlayersWithTorch = getBoolean("mobs.phantom.ignore-players-with-torch", phantomIgnorePlayersWithTorch); phantomFlamesOnSwoop = getBoolean("mobs.phantom.flames-on-swoop", phantomFlamesOnSwoop); @@ -1780,7 +1778,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean pigRidable = false; -@@ -1361,6 +1435,7 @@ public class PurpurWorldConfig { +@@ -1378,6 +1452,7 @@ public class PurpurWorldConfig { public double pigMaxHealth = 10.0D; public boolean pigGiveSaddleBack = false; public int pigBreedingTicks = 6000; @@ -1788,7 +1786,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void pigSettings() { pigRidable = getBoolean("mobs.pig.ridable", pigRidable); pigRidableInWater = getBoolean("mobs.pig.ridable-in-water", pigRidableInWater); -@@ -1373,6 +1448,7 @@ public class PurpurWorldConfig { +@@ -1390,6 +1465,7 @@ public class PurpurWorldConfig { pigMaxHealth = getDouble("mobs.pig.attributes.max_health", pigMaxHealth); pigGiveSaddleBack = getBoolean("mobs.pig.give-saddle-back", pigGiveSaddleBack); pigBreedingTicks = getInt("mobs.pig.breeding-delay-ticks", pigBreedingTicks); @@ -1796,7 +1794,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean piglinRidable = false; -@@ -1380,6 +1456,7 @@ public class PurpurWorldConfig { +@@ -1397,6 +1473,7 @@ public class PurpurWorldConfig { public boolean piglinControllable = true; public double piglinMaxHealth = 16.0D; public boolean piglinBypassMobGriefing = false; @@ -1804,7 +1802,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void piglinSettings() { piglinRidable = getBoolean("mobs.piglin.ridable", piglinRidable); piglinRidableInWater = getBoolean("mobs.piglin.ridable-in-water", piglinRidableInWater); -@@ -1391,12 +1468,14 @@ public class PurpurWorldConfig { +@@ -1408,12 +1485,14 @@ public class PurpurWorldConfig { } piglinMaxHealth = getDouble("mobs.piglin.attributes.max_health", piglinMaxHealth); piglinBypassMobGriefing = getBoolean("mobs.piglin.bypass-mob-griefing", piglinBypassMobGriefing); @@ -1819,7 +1817,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void piglinBruteSettings() { piglinBruteRidable = getBoolean("mobs.piglin_brute.ridable", piglinBruteRidable); piglinBruteRidableInWater = getBoolean("mobs.piglin_brute.ridable-in-water", piglinBruteRidableInWater); -@@ -1407,6 +1486,7 @@ public class PurpurWorldConfig { +@@ -1424,6 +1503,7 @@ public class PurpurWorldConfig { set("mobs.piglin_brute.attributes.max_health", oldValue); } piglinBruteMaxHealth = getDouble("mobs.piglin_brute.attributes.max_health", piglinBruteMaxHealth); @@ -1827,7 +1825,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean pillagerRidable = false; -@@ -1414,6 +1494,7 @@ public class PurpurWorldConfig { +@@ -1431,6 +1511,7 @@ public class PurpurWorldConfig { public boolean pillagerControllable = true; public double pillagerMaxHealth = 24.0D; public boolean pillagerBypassMobGriefing = false; @@ -1835,7 +1833,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void pillagerSettings() { pillagerRidable = getBoolean("mobs.pillager.ridable", pillagerRidable); pillagerRidableInWater = getBoolean("mobs.pillager.ridable-in-water", pillagerRidableInWater); -@@ -1425,6 +1506,7 @@ public class PurpurWorldConfig { +@@ -1442,6 +1523,7 @@ public class PurpurWorldConfig { } pillagerMaxHealth = getDouble("mobs.pillager.attributes.max_health", pillagerMaxHealth); pillagerBypassMobGriefing = getBoolean("mobs.pillager.bypass-mob-griefing", pillagerBypassMobGriefing); @@ -1843,7 +1841,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean polarBearRidable = false; -@@ -1434,6 +1516,7 @@ public class PurpurWorldConfig { +@@ -1451,6 +1533,7 @@ public class PurpurWorldConfig { public String polarBearBreedableItemString = ""; public Item polarBearBreedableItem = null; public int polarBearBreedingTicks = 6000; @@ -1851,7 +1849,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void polarBearSettings() { polarBearRidable = getBoolean("mobs.polar_bear.ridable", polarBearRidable); polarBearRidableInWater = getBoolean("mobs.polar_bear.ridable-in-water", polarBearRidableInWater); -@@ -1448,11 +1531,13 @@ public class PurpurWorldConfig { +@@ -1465,11 +1548,13 @@ public class PurpurWorldConfig { Item item = Registry.ITEM.get(new ResourceLocation(polarBearBreedableItemString)); if (item != Items.AIR) polarBearBreedableItem = item; polarBearBreedingTicks = getInt("mobs.polar_bear.breeding-delay-ticks", polarBearBreedingTicks); @@ -1865,7 +1863,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void pufferfishSettings() { pufferfishRidable = getBoolean("mobs.pufferfish.ridable", pufferfishRidable); pufferfishControllable = getBoolean("mobs.pufferfish.controllable", pufferfishControllable); -@@ -1462,6 +1547,7 @@ public class PurpurWorldConfig { +@@ -1479,6 +1564,7 @@ public class PurpurWorldConfig { set("mobs.pufferfish.attributes.max_health", oldValue); } pufferfishMaxHealth = getDouble("mobs.pufferfish.attributes.max_health", pufferfishMaxHealth); @@ -1873,7 +1871,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean rabbitRidable = false; -@@ -1472,6 +1558,7 @@ public class PurpurWorldConfig { +@@ -1489,6 +1575,7 @@ public class PurpurWorldConfig { public double rabbitNaturalKiller = 0.0D; public int rabbitBreedingTicks = 6000; public boolean rabbitBypassMobGriefing = false; @@ -1881,7 +1879,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void rabbitSettings() { rabbitRidable = getBoolean("mobs.rabbit.ridable", rabbitRidable); rabbitRidableInWater = getBoolean("mobs.rabbit.ridable-in-water", rabbitRidableInWater); -@@ -1486,6 +1573,7 @@ public class PurpurWorldConfig { +@@ -1503,6 +1590,7 @@ public class PurpurWorldConfig { rabbitNaturalKiller = getDouble("mobs.rabbit.spawn-killer-rabbit-chance", rabbitNaturalKiller); rabbitBreedingTicks = getInt("mobs.rabbit.breeding-delay-ticks", rabbitBreedingTicks); rabbitBypassMobGriefing = getBoolean("mobs.rabbit.bypass-mob-griefing", rabbitBypassMobGriefing); @@ -1889,7 +1887,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean ravagerRidable = false; -@@ -1493,6 +1581,7 @@ public class PurpurWorldConfig { +@@ -1510,6 +1598,7 @@ public class PurpurWorldConfig { public boolean ravagerControllable = true; public double ravagerMaxHealth = 100.0D; public boolean ravagerBypassMobGriefing = false; @@ -1897,7 +1895,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void ravagerSettings() { ravagerRidable = getBoolean("mobs.ravager.ridable", ravagerRidable); ravagerRidableInWater = getBoolean("mobs.ravager.ridable-in-water", ravagerRidableInWater); -@@ -1504,11 +1593,13 @@ public class PurpurWorldConfig { +@@ -1521,11 +1610,13 @@ public class PurpurWorldConfig { } ravagerMaxHealth = getDouble("mobs.ravager.attributes.max_health", ravagerMaxHealth); ravagerBypassMobGriefing = getBoolean("mobs.ravager.bypass-mob-griefing", ravagerBypassMobGriefing); @@ -1911,7 +1909,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void salmonSettings() { salmonRidable = getBoolean("mobs.salmon.ridable", salmonRidable); salmonControllable = getBoolean("mobs.salmon.controllable", salmonControllable); -@@ -1518,6 +1609,7 @@ public class PurpurWorldConfig { +@@ -1535,6 +1626,7 @@ public class PurpurWorldConfig { set("mobs.salmon.attributes.max_health", oldValue); } salmonMaxHealth = getDouble("mobs.salmon.attributes.max_health", salmonMaxHealth); @@ -1919,7 +1917,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean sheepRidable = false; -@@ -1526,6 +1618,7 @@ public class PurpurWorldConfig { +@@ -1543,6 +1635,7 @@ public class PurpurWorldConfig { public double sheepMaxHealth = 8.0D; public int sheepBreedingTicks = 6000; public boolean sheepBypassMobGriefing = false; @@ -1927,7 +1925,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void sheepSettings() { sheepRidable = getBoolean("mobs.sheep.ridable", sheepRidable); sheepRidableInWater = getBoolean("mobs.sheep.ridable-in-water", sheepRidableInWater); -@@ -1538,12 +1631,14 @@ public class PurpurWorldConfig { +@@ -1555,12 +1648,14 @@ public class PurpurWorldConfig { sheepMaxHealth = getDouble("mobs.sheep.attributes.max_health", sheepMaxHealth); sheepBreedingTicks = getInt("mobs.sheep.breeding-delay-ticks", sheepBreedingTicks); sheepBypassMobGriefing = getBoolean("mobs.sheep.bypass-mob-griefing", sheepBypassMobGriefing); @@ -1942,7 +1940,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void shulkerSettings() { shulkerRidable = getBoolean("mobs.shulker.ridable", shulkerRidable); shulkerRidableInWater = getBoolean("mobs.shulker.ridable-in-water", shulkerRidableInWater); -@@ -1554,6 +1649,7 @@ public class PurpurWorldConfig { +@@ -1571,6 +1666,7 @@ public class PurpurWorldConfig { set("mobs.shulker.attributes.max_health", oldValue); } shulkerMaxHealth = getDouble("mobs.shulker.attributes.max_health", shulkerMaxHealth); @@ -1950,7 +1948,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean silverfishRidable = false; -@@ -1561,6 +1657,7 @@ public class PurpurWorldConfig { +@@ -1578,6 +1674,7 @@ public class PurpurWorldConfig { public boolean silverfishControllable = true; public double silverfishMaxHealth = 8.0D; public boolean silverfishBypassMobGriefing = false; @@ -1958,7 +1956,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void silverfishSettings() { silverfishRidable = getBoolean("mobs.silverfish.ridable", silverfishRidable); silverfishRidableInWater = getBoolean("mobs.silverfish.ridable-in-water", silverfishRidableInWater); -@@ -1572,12 +1669,14 @@ public class PurpurWorldConfig { +@@ -1589,12 +1686,14 @@ public class PurpurWorldConfig { } silverfishMaxHealth = getDouble("mobs.silverfish.attributes.max_health", silverfishMaxHealth); silverfishBypassMobGriefing = getBoolean("mobs.silverfish.bypass-mob-griefing", silverfishBypassMobGriefing); @@ -1973,7 +1971,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void skeletonSettings() { skeletonRidable = getBoolean("mobs.skeleton.ridable", skeletonRidable); skeletonRidableInWater = getBoolean("mobs.skeleton.ridable-in-water", skeletonRidableInWater); -@@ -1588,6 +1687,7 @@ public class PurpurWorldConfig { +@@ -1605,6 +1704,7 @@ public class PurpurWorldConfig { set("mobs.skeleton.attributes.max_health", oldValue); } skeletonMaxHealth = getDouble("mobs.skeleton.attributes.max_health", skeletonMaxHealth); @@ -1981,7 +1979,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean skeletonHorseRidableInWater = true; -@@ -1598,6 +1698,7 @@ public class PurpurWorldConfig { +@@ -1615,6 +1715,7 @@ public class PurpurWorldConfig { public double skeletonHorseJumpStrengthMax = 1.0D; public double skeletonHorseMovementSpeedMin = 0.2D; public double skeletonHorseMovementSpeedMax = 0.2D; @@ -1989,7 +1987,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void skeletonHorseSettings() { skeletonHorseRidableInWater = getBoolean("mobs.skeleton_horse.ridable-in-water", skeletonHorseRidableInWater); skeletonHorseCanSwim = getBoolean("mobs.skeleton_horse.can-swim", skeletonHorseCanSwim); -@@ -1613,6 +1714,7 @@ public class PurpurWorldConfig { +@@ -1630,6 +1731,7 @@ public class PurpurWorldConfig { skeletonHorseJumpStrengthMax = getDouble("mobs.skeleton_horse.attributes.jump_strength.max", skeletonHorseJumpStrengthMax); skeletonHorseMovementSpeedMin = getDouble("mobs.skeleton_horse.attributes.movement_speed.min", skeletonHorseMovementSpeedMin); skeletonHorseMovementSpeedMax = getDouble("mobs.skeleton_horse.attributes.movement_speed.max", skeletonHorseMovementSpeedMax); @@ -1997,7 +1995,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean slimeRidable = false; -@@ -1622,6 +1724,7 @@ public class PurpurWorldConfig { +@@ -1639,6 +1741,7 @@ public class PurpurWorldConfig { public String slimeAttackDamage = "size"; public Map slimeMaxHealthCache = new HashMap<>(); public Map slimeAttackDamageCache = new HashMap<>(); @@ -2005,7 +2003,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void slimeSettings() { slimeRidable = getBoolean("mobs.slime.ridable", slimeRidable); slimeRidableInWater = getBoolean("mobs.slime.ridable-in-water", slimeRidableInWater); -@@ -1635,6 +1738,7 @@ public class PurpurWorldConfig { +@@ -1652,6 +1755,7 @@ public class PurpurWorldConfig { slimeAttackDamage = getString("mobs.slime.attributes.attack_damage", slimeAttackDamage); slimeMaxHealthCache.clear(); slimeAttackDamageCache.clear(); @@ -2013,7 +2011,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean snowGolemRidable = false; -@@ -1649,6 +1753,7 @@ public class PurpurWorldConfig { +@@ -1666,6 +1770,7 @@ public class PurpurWorldConfig { public float snowGolemSnowBallModifier = 10.0F; public double snowGolemAttackDistance = 1.25D; public boolean snowGolemBypassMobGriefing = false; @@ -2021,7 +2019,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void snowGolemSettings() { snowGolemRidable = getBoolean("mobs.snow_golem.ridable", snowGolemRidable); snowGolemRidableInWater = getBoolean("mobs.snow_golem.ridable-in-water", snowGolemRidableInWater); -@@ -1667,6 +1772,7 @@ public class PurpurWorldConfig { +@@ -1684,6 +1789,7 @@ public class PurpurWorldConfig { snowGolemSnowBallModifier = (float) getDouble("mobs.snow_golem.snow-ball-modifier", snowGolemSnowBallModifier); snowGolemAttackDistance = getDouble("mobs.snow_golem.attack-distance", snowGolemAttackDistance); snowGolemBypassMobGriefing = getBoolean("mobs.snow_golem.bypass-mob-griefing", snowGolemBypassMobGriefing); @@ -2029,7 +2027,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean squidRidable = false; -@@ -1675,6 +1781,7 @@ public class PurpurWorldConfig { +@@ -1692,6 +1798,7 @@ public class PurpurWorldConfig { public boolean squidImmuneToEAR = true; public double squidOffsetWaterCheck = 0.0D; public boolean squidsCanFly = false; @@ -2037,7 +2035,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void squidSettings() { squidRidable = getBoolean("mobs.squid.ridable", squidRidable); squidControllable = getBoolean("mobs.squid.controllable", squidControllable); -@@ -1687,12 +1794,14 @@ public class PurpurWorldConfig { +@@ -1704,12 +1811,14 @@ public class PurpurWorldConfig { squidImmuneToEAR = getBoolean("mobs.squid.immune-to-EAR", squidImmuneToEAR); squidOffsetWaterCheck = getDouble("mobs.squid.water-offset-check", squidOffsetWaterCheck); squidsCanFly = getBoolean("mobs.squid.can-fly", squidsCanFly); @@ -2052,7 +2050,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void spiderSettings() { spiderRidable = getBoolean("mobs.spider.ridable", spiderRidable); spiderRidableInWater = getBoolean("mobs.spider.ridable-in-water", spiderRidableInWater); -@@ -1703,12 +1812,14 @@ public class PurpurWorldConfig { +@@ -1720,12 +1829,14 @@ public class PurpurWorldConfig { set("mobs.spider.attributes.max_health", oldValue); } spiderMaxHealth = getDouble("mobs.spider.attributes.max_health", spiderMaxHealth); @@ -2067,7 +2065,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void straySettings() { strayRidable = getBoolean("mobs.stray.ridable", strayRidable); strayRidableInWater = getBoolean("mobs.stray.ridable-in-water", strayRidableInWater); -@@ -1719,6 +1830,7 @@ public class PurpurWorldConfig { +@@ -1736,6 +1847,7 @@ public class PurpurWorldConfig { set("mobs.stray.attributes.max_health", oldValue); } strayMaxHealth = getDouble("mobs.stray.attributes.max_health", strayMaxHealth); @@ -2075,7 +2073,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean striderRidable = false; -@@ -1727,6 +1839,7 @@ public class PurpurWorldConfig { +@@ -1744,6 +1856,7 @@ public class PurpurWorldConfig { public double striderMaxHealth = 20.0D; public int striderBreedingTicks = 6000; public boolean striderGiveSaddleBack = false; @@ -2083,15 +2081,15 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void striderSettings() { striderRidable = getBoolean("mobs.strider.ridable", striderRidable); striderRidableInWater = getBoolean("mobs.strider.ridable-in-water", striderRidableInWater); -@@ -1739,6 +1852,7 @@ public class PurpurWorldConfig { +@@ -1756,6 +1869,7 @@ public class PurpurWorldConfig { striderMaxHealth = getDouble("mobs.strider.attributes.max_health", striderMaxHealth); striderBreedingTicks = getInt("mobs.strider.breeding-delay-ticks", striderBreedingTicks); striderGiveSaddleBack = getBoolean("mobs.strider.give-saddle-back", striderGiveSaddleBack); + striderTakeDamageFromWater = getBoolean("mobs.strider.takes-damage-from-water", striderTakeDamageFromWater); } - public boolean traderLlamaRidable = false; -@@ -1751,6 +1865,7 @@ public class PurpurWorldConfig { + public boolean tadpoleRidable = false; +@@ -1777,6 +1891,7 @@ public class PurpurWorldConfig { public double traderLlamaMovementSpeedMin = 0.175D; public double traderLlamaMovementSpeedMax = 0.175D; public int traderLlamaBreedingTicks = 6000; @@ -2099,7 +2097,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void traderLlamaSettings() { traderLlamaRidable = getBoolean("mobs.trader_llama.ridable", traderLlamaRidable); traderLlamaRidableInWater = getBoolean("mobs.trader_llama.ridable-in-water", traderLlamaRidableInWater); -@@ -1769,11 +1884,13 @@ public class PurpurWorldConfig { +@@ -1795,11 +1910,13 @@ public class PurpurWorldConfig { traderLlamaMovementSpeedMin = getDouble("mobs.trader_llama.attributes.movement_speed.min", traderLlamaMovementSpeedMin); traderLlamaMovementSpeedMax = getDouble("mobs.trader_llama.attributes.movement_speed.max", traderLlamaMovementSpeedMax); traderLlamaBreedingTicks = getInt("mobs.trader_llama.breeding-delay-ticks", traderLlamaBreedingTicks); @@ -2113,7 +2111,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void tropicalFishSettings() { tropicalFishRidable = getBoolean("mobs.tropical_fish.ridable", tropicalFishRidable); tropicalFishControllable = getBoolean("mobs.tropical_fish.controllable", tropicalFishControllable); -@@ -1783,6 +1900,7 @@ public class PurpurWorldConfig { +@@ -1809,6 +1926,7 @@ public class PurpurWorldConfig { set("mobs.tropical_fish.attributes.max_health", oldValue); } tropicalFishMaxHealth = getDouble("mobs.tropical_fish.attributes.max_health", tropicalFishMaxHealth); @@ -2121,7 +2119,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean turtleRidable = false; -@@ -1790,6 +1908,7 @@ public class PurpurWorldConfig { +@@ -1816,6 +1934,7 @@ public class PurpurWorldConfig { public boolean turtleControllable = true; public double turtleMaxHealth = 30.0D; public int turtleBreedingTicks = 6000; @@ -2129,7 +2127,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void turtleSettings() { turtleRidable = getBoolean("mobs.turtle.ridable", turtleRidable); turtleRidableInWater = getBoolean("mobs.turtle.ridable-in-water", turtleRidableInWater); -@@ -1801,6 +1920,7 @@ public class PurpurWorldConfig { +@@ -1827,6 +1946,7 @@ public class PurpurWorldConfig { } turtleMaxHealth = getDouble("mobs.turtle.attributes.max_health", turtleMaxHealth); turtleBreedingTicks = getInt("mobs.turtle.breeding-delay-ticks", turtleBreedingTicks); @@ -2137,7 +2135,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean vexRidable = false; -@@ -1808,6 +1928,7 @@ public class PurpurWorldConfig { +@@ -1834,6 +1954,7 @@ public class PurpurWorldConfig { public boolean vexControllable = true; public double vexMaxY = 320D; public double vexMaxHealth = 14.0D; @@ -2145,7 +2143,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void vexSettings() { vexRidable = getBoolean("mobs.vex.ridable", vexRidable); vexRidableInWater = getBoolean("mobs.vex.ridable-in-water", vexRidableInWater); -@@ -1819,6 +1940,7 @@ public class PurpurWorldConfig { +@@ -1845,6 +1966,7 @@ public class PurpurWorldConfig { set("mobs.vex.attributes.max_health", oldValue); } vexMaxHealth = getDouble("mobs.vex.attributes.max_health", vexMaxHealth); @@ -2153,7 +2151,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean villagerRidable = false; -@@ -1834,6 +1956,7 @@ public class PurpurWorldConfig { +@@ -1860,6 +1982,7 @@ public class PurpurWorldConfig { public boolean villagerClericsFarmWarts = false; public boolean villagerClericFarmersThrowWarts = true; public boolean villagerBypassMobGriefing = false; @@ -2161,7 +2159,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -1853,6 +1976,7 @@ public class PurpurWorldConfig { +@@ -1879,6 +2002,7 @@ public class PurpurWorldConfig { villagerClericsFarmWarts = getBoolean("mobs.villager.clerics-farm-warts", villagerClericsFarmWarts); villagerClericFarmersThrowWarts = getBoolean("mobs.villager.cleric-wart-farmers-throw-warts-at-villagers", villagerClericFarmersThrowWarts); villagerBypassMobGriefing = getBoolean("mobs.villager.bypass-mob-griefing", villagerBypassMobGriefing); @@ -2169,7 +2167,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean vindicatorRidable = false; -@@ -1860,6 +1984,7 @@ public class PurpurWorldConfig { +@@ -1886,6 +2010,7 @@ public class PurpurWorldConfig { public boolean vindicatorControllable = true; public double vindicatorMaxHealth = 24.0D; public double vindicatorJohnnySpawnChance = 0D; @@ -2177,7 +2175,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void vindicatorSettings() { vindicatorRidable = getBoolean("mobs.vindicator.ridable", vindicatorRidable); vindicatorRidableInWater = getBoolean("mobs.vindicator.ridable-in-water", vindicatorRidableInWater); -@@ -1871,6 +1996,7 @@ public class PurpurWorldConfig { +@@ -1897,6 +2022,7 @@ public class PurpurWorldConfig { } vindicatorMaxHealth = getDouble("mobs.vindicator.attributes.max_health", vindicatorMaxHealth); vindicatorJohnnySpawnChance = getDouble("mobs.vindicator.johnny.spawn-chance", vindicatorJohnnySpawnChance); @@ -2185,7 +2183,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean wanderingTraderRidable = false; -@@ -1879,6 +2005,7 @@ public class PurpurWorldConfig { +@@ -1905,6 +2031,7 @@ public class PurpurWorldConfig { public double wanderingTraderMaxHealth = 20.0D; public boolean wanderingTraderFollowEmeraldBlock = false; public boolean wanderingTraderCanBeLeashed = false; @@ -2193,14 +2191,15 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void wanderingTraderSettings() { wanderingTraderRidable = getBoolean("mobs.wandering_trader.ridable", wanderingTraderRidable); wanderingTraderRidableInWater = getBoolean("mobs.wandering_trader.ridable-in-water", wanderingTraderRidableInWater); -@@ -1891,12 +2018,14 @@ public class PurpurWorldConfig { +@@ -1917,6 +2044,7 @@ public class PurpurWorldConfig { wanderingTraderMaxHealth = getDouble("mobs.wandering_trader.attributes.max_health", wanderingTraderMaxHealth); wanderingTraderFollowEmeraldBlock = getBoolean("mobs.wandering_trader.follow-emerald-blocks", wanderingTraderFollowEmeraldBlock); wanderingTraderCanBeLeashed = getBoolean("mobs.wandering_trader.can-be-leashed", wanderingTraderCanBeLeashed); + wanderingTraderTakeDamageFromWater = getBoolean("mobs.wandering_trader.takes-damage-from-water", wanderingTraderTakeDamageFromWater); } - public boolean witchRidable = false; + public boolean wardenRidable = false; +@@ -1932,6 +2060,7 @@ public class PurpurWorldConfig { public boolean witchRidableInWater = false; public boolean witchControllable = true; public double witchMaxHealth = 26.0D; @@ -2208,7 +2207,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void witchSettings() { witchRidable = getBoolean("mobs.witch.ridable", witchRidable); witchRidableInWater = getBoolean("mobs.witch.ridable-in-water", witchRidableInWater); -@@ -1907,6 +2036,7 @@ public class PurpurWorldConfig { +@@ -1942,6 +2071,7 @@ public class PurpurWorldConfig { set("mobs.witch.attributes.max_health", oldValue); } witchMaxHealth = getDouble("mobs.witch.attributes.max_health", witchMaxHealth); @@ -2216,7 +2215,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean witherRidable = false; -@@ -1917,6 +2047,7 @@ public class PurpurWorldConfig { +@@ -1952,6 +2082,7 @@ public class PurpurWorldConfig { public float witherHealthRegenAmount = 1.0f; public int witherHealthRegenDelay = 20; public boolean witherBypassMobGriefing = false; @@ -2224,7 +2223,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void witherSettings() { witherRidable = getBoolean("mobs.wither.ridable", witherRidable); witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater); -@@ -1935,12 +2066,14 @@ public class PurpurWorldConfig { +@@ -1970,12 +2101,14 @@ public class PurpurWorldConfig { witherHealthRegenAmount = (float) getDouble("mobs.wither.health-regen-amount", witherHealthRegenAmount); witherHealthRegenDelay = getInt("mobs.wither.health-regen-delay", witherHealthRegenDelay); witherBypassMobGriefing = getBoolean("mobs.wither.bypass-mob-griefing", witherBypassMobGriefing); @@ -2239,7 +2238,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void witherSkeletonSettings() { witherSkeletonRidable = getBoolean("mobs.wither_skeleton.ridable", witherSkeletonRidable); witherSkeletonRidableInWater = getBoolean("mobs.wither_skeleton.ridable-in-water", witherSkeletonRidableInWater); -@@ -1951,6 +2084,7 @@ public class PurpurWorldConfig { +@@ -1986,6 +2119,7 @@ public class PurpurWorldConfig { set("mobs.wither_skeleton.attributes.max_health", oldValue); } witherSkeletonMaxHealth = getDouble("mobs.wither_skeleton.attributes.max_health", witherSkeletonMaxHealth); @@ -2247,7 +2246,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean wolfRidable = false; -@@ -1961,6 +2095,7 @@ public class PurpurWorldConfig { +@@ -1996,6 +2130,7 @@ public class PurpurWorldConfig { public boolean wolfMilkCuresRabies = true; public double wolfNaturalRabid = 0.0D; public int wolfBreedingTicks = 6000; @@ -2255,7 +2254,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void wolfSettings() { wolfRidable = getBoolean("mobs.wolf.ridable", wolfRidable); wolfRidableInWater = getBoolean("mobs.wolf.ridable-in-water", wolfRidableInWater); -@@ -1979,12 +2114,14 @@ public class PurpurWorldConfig { +@@ -2014,12 +2149,14 @@ public class PurpurWorldConfig { wolfMilkCuresRabies = getBoolean("mobs.wolf.milk-cures-rabid-wolves", wolfMilkCuresRabies); wolfNaturalRabid = getDouble("mobs.wolf.spawn-rabid-chance", wolfNaturalRabid); wolfBreedingTicks = getInt("mobs.wolf.breeding-delay-ticks", wolfBreedingTicks); @@ -2270,7 +2269,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void zoglinSettings() { zoglinRidable = getBoolean("mobs.zoglin.ridable", zoglinRidable); zoglinRidableInWater = getBoolean("mobs.zoglin.ridable-in-water", zoglinRidableInWater); -@@ -1995,6 +2132,7 @@ public class PurpurWorldConfig { +@@ -2030,6 +2167,7 @@ public class PurpurWorldConfig { set("mobs.zoglin.attributes.max_health", oldValue); } zoglinMaxHealth = getDouble("mobs.zoglin.attributes.max_health", zoglinMaxHealth); @@ -2278,7 +2277,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean zombieRidable = false; -@@ -2007,6 +2145,7 @@ public class PurpurWorldConfig { +@@ -2042,6 +2180,7 @@ public class PurpurWorldConfig { public boolean zombieJockeyTryExistingChickens = true; public boolean zombieAggressiveTowardsVillagerWhenLagging = true; public boolean zombieBypassMobGriefing = false; @@ -2286,7 +2285,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void zombieSettings() { zombieRidable = getBoolean("mobs.zombie.ridable", zombieRidable); zombieRidableInWater = getBoolean("mobs.zombie.ridable-in-water", zombieRidableInWater); -@@ -2023,6 +2162,7 @@ public class PurpurWorldConfig { +@@ -2058,6 +2197,7 @@ public class PurpurWorldConfig { zombieJockeyTryExistingChickens = getBoolean("mobs.zombie.jockey.try-existing-chickens", zombieJockeyTryExistingChickens); zombieAggressiveTowardsVillagerWhenLagging = getBoolean("mobs.zombie.aggressive-towards-villager-when-lagging", zombieAggressiveTowardsVillagerWhenLagging); zombieBypassMobGriefing = getBoolean("mobs.zombie.bypass-mob-griefing", zombieBypassMobGriefing); @@ -2294,7 +2293,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean zombieHorseRidableInWater = false; -@@ -2034,6 +2174,7 @@ public class PurpurWorldConfig { +@@ -2069,6 +2209,7 @@ public class PurpurWorldConfig { public double zombieHorseMovementSpeedMin = 0.2D; public double zombieHorseMovementSpeedMax = 0.2D; public double zombieHorseSpawnChance = 0.0D; @@ -2302,7 +2301,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void zombieHorseSettings() { zombieHorseRidableInWater = getBoolean("mobs.zombie_horse.ridable-in-water", zombieHorseRidableInWater); zombieHorseCanSwim = getBoolean("mobs.zombie_horse.can-swim", zombieHorseCanSwim); -@@ -2050,6 +2191,7 @@ public class PurpurWorldConfig { +@@ -2085,6 +2226,7 @@ public class PurpurWorldConfig { zombieHorseMovementSpeedMin = getDouble("mobs.zombie_horse.attributes.movement_speed.min", zombieHorseMovementSpeedMin); zombieHorseMovementSpeedMax = getDouble("mobs.zombie_horse.attributes.movement_speed.max", zombieHorseMovementSpeedMax); zombieHorseSpawnChance = getDouble("mobs.zombie_horse.spawn-chance", zombieHorseSpawnChance); @@ -2310,7 +2309,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean zombieVillagerRidable = false; -@@ -2060,6 +2202,7 @@ public class PurpurWorldConfig { +@@ -2095,6 +2237,7 @@ public class PurpurWorldConfig { public boolean zombieVillagerJockeyOnlyBaby = true; public double zombieVillagerJockeyChance = 0.05D; public boolean zombieVillagerJockeyTryExistingChickens = true; @@ -2318,7 +2317,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void zombieVillagerSettings() { zombieVillagerRidable = getBoolean("mobs.zombie_villager.ridable", zombieVillagerRidable); zombieVillagerRidableInWater = getBoolean("mobs.zombie_villager.ridable-in-water", zombieVillagerRidableInWater); -@@ -2074,6 +2217,7 @@ public class PurpurWorldConfig { +@@ -2109,6 +2252,7 @@ public class PurpurWorldConfig { zombieVillagerJockeyOnlyBaby = getBoolean("mobs.zombie_villager.jockey.only-babies", zombieVillagerJockeyOnlyBaby); zombieVillagerJockeyChance = getDouble("mobs.zombie_villager.jockey.chance", zombieVillagerJockeyChance); zombieVillagerJockeyTryExistingChickens = getBoolean("mobs.zombie_villager.jockey.try-existing-chickens", zombieVillagerJockeyTryExistingChickens); @@ -2326,7 +2325,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 } public boolean zombifiedPiglinRidable = false; -@@ -2085,6 +2229,7 @@ public class PurpurWorldConfig { +@@ -2120,6 +2264,7 @@ public class PurpurWorldConfig { public double zombifiedPiglinJockeyChance = 0.05D; public boolean zombifiedPiglinJockeyTryExistingChickens = true; public boolean zombifiedPiglinCountAsPlayerKillWhenAngry = true; @@ -2334,7 +2333,7 @@ index 6bff04132db715bb0ec443d79b90a7a3d213958d..715c00cd6f48089a6cacf726b70ffed0 private void zombifiedPiglinSettings() { zombifiedPiglinRidable = getBoolean("mobs.zombified_piglin.ridable", zombifiedPiglinRidable); zombifiedPiglinRidableInWater = getBoolean("mobs.zombified_piglin.ridable-in-water", zombifiedPiglinRidableInWater); -@@ -2100,5 +2245,6 @@ public class PurpurWorldConfig { +@@ -2135,5 +2280,6 @@ public class PurpurWorldConfig { zombifiedPiglinJockeyChance = getDouble("mobs.zombified_piglin.jockey.chance", zombifiedPiglinJockeyChance); zombifiedPiglinJockeyTryExistingChickens = getBoolean("mobs.zombified_piglin.jockey.try-existing-chickens", zombifiedPiglinJockeyTryExistingChickens); zombifiedPiglinCountAsPlayerKillWhenAngry = getBoolean("mobs.zombified_piglin.count-as-player-kill-when-angry", zombifiedPiglinCountAsPlayerKillWhenAngry); diff --git a/patches/server/0140-Configs-for-if-Wither-Ender-Dragon-can-ride-vehicles.patch b/patches/server/0140-Configs-for-if-Wither-Ender-Dragon-can-ride-vehicles.patch index 5c13f51f2..c859fc3f2 100644 --- a/patches/server/0140-Configs-for-if-Wither-Ender-Dragon-can-ride-vehicles.patch +++ b/patches/server/0140-Configs-for-if-Wither-Ender-Dragon-can-ride-vehicles.patch @@ -17,10 +17,10 @@ index a9e07815fdde8509267c48d41d0e5fd5a38a93da..41a0dfd14b970b3f36ac7cc134226a79 } 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 4af8c387f47017e453e74a86a53726386ed2d1b9..fd5d0a75ea5e30df4f606bc4756a32ecbbe9abad 100644 +index 1329de5d3e6294d2eb7b6852b8cad19f0f4dba77..6818618cd2f702e894ac4098b4eb5afc7664408e 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 -@@ -737,6 +737,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -749,6 +749,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob @Override protected boolean canRide(Entity entity) { @@ -29,10 +29,10 @@ index 4af8c387f47017e453e74a86a53726386ed2d1b9..fd5d0a75ea5e30df4f606bc4756a32ec } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 8966f9c8429fdc36bb3f83ac807cf77a591cf7a1..20dcbe4466151b55cae1af92c7c5131dc52d188f 100644 +index a03de24458a11d5a09b30d7211eab9556d5d034f..64d115cd17f9239b34d1d4f91a77c33f28da79d5 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -893,6 +893,7 @@ public class PurpurWorldConfig { +@@ -902,6 +902,7 @@ public class PurpurWorldConfig { public boolean enderDragonAlwaysDropsFullExp = false; public boolean enderDragonBypassMobGriefing = false; public boolean enderDragonTakeDamageFromWater = false; @@ -40,7 +40,7 @@ index 8966f9c8429fdc36bb3f83ac807cf77a591cf7a1..20dcbe4466151b55cae1af92c7c5131d private void enderDragonSettings() { enderDragonRidable = getBoolean("mobs.ender_dragon.ridable", enderDragonRidable); enderDragonRidableInWater = getBoolean("mobs.ender_dragon.ridable-in-water", enderDragonRidableInWater); -@@ -911,6 +912,7 @@ public class PurpurWorldConfig { +@@ -920,6 +921,7 @@ public class PurpurWorldConfig { enderDragonAlwaysDropsFullExp = getBoolean("mobs.ender_dragon.always-drop-full-exp", enderDragonAlwaysDropsFullExp); enderDragonBypassMobGriefing = getBoolean("mobs.ender_dragon.bypass-mob-griefing", enderDragonBypassMobGriefing); enderDragonTakeDamageFromWater = getBoolean("mobs.ender_dragon.takes-damage-from-water", enderDragonTakeDamageFromWater); @@ -48,7 +48,7 @@ index 8966f9c8429fdc36bb3f83ac807cf77a591cf7a1..20dcbe4466151b55cae1af92c7c5131d } public boolean endermanRidable = false; -@@ -2079,6 +2081,7 @@ public class PurpurWorldConfig { +@@ -2114,6 +2116,7 @@ public class PurpurWorldConfig { public int witherHealthRegenDelay = 20; public boolean witherBypassMobGriefing = false; public boolean witherTakeDamageFromWater = false; @@ -56,7 +56,7 @@ index 8966f9c8429fdc36bb3f83ac807cf77a591cf7a1..20dcbe4466151b55cae1af92c7c5131d private void witherSettings() { witherRidable = getBoolean("mobs.wither.ridable", witherRidable); witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater); -@@ -2098,6 +2101,7 @@ public class PurpurWorldConfig { +@@ -2133,6 +2136,7 @@ public class PurpurWorldConfig { witherHealthRegenDelay = getInt("mobs.wither.health-regen-delay", witherHealthRegenDelay); witherBypassMobGriefing = getBoolean("mobs.wither.bypass-mob-griefing", witherBypassMobGriefing); witherTakeDamageFromWater = getBoolean("mobs.wither.takes-damage-from-water", witherTakeDamageFromWater); diff --git a/patches/server/0146-Config-Enderman-aggressiveness-towards-Endermites.patch b/patches/server/0146-Config-Enderman-aggressiveness-towards-Endermites.patch index 15fcba2d0..9a0e7846d 100644 --- a/patches/server/0146-Config-Enderman-aggressiveness-towards-Endermites.patch +++ b/patches/server/0146-Config-Enderman-aggressiveness-towards-Endermites.patch @@ -18,10 +18,10 @@ index 6c9b3bb54b163cb2a6c05993e792558e983feecc..99e4c23140b85d37c7b266c2fcf57c94 } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index d3ee82025c0e15398ff670951300d0d4ed2dec86..7b00b367c895e200f11a99d4e2a0953defd8eb04 100644 +index 9d33d2e2d9135586149497e48c1581e2ccef61f4..2f72f95cb086ef641710022cffa9a6396842b13c 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -939,6 +939,8 @@ public class PurpurWorldConfig { +@@ -948,6 +948,8 @@ public class PurpurWorldConfig { public boolean endermanDespawnEvenWithBlock = false; public boolean endermanBypassMobGriefing = false; public boolean endermanTakeDamageFromWater = true; @@ -30,7 +30,7 @@ index d3ee82025c0e15398ff670951300d0d4ed2dec86..7b00b367c895e200f11a99d4e2a0953d private void endermanSettings() { endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable); endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater); -@@ -948,11 +950,17 @@ public class PurpurWorldConfig { +@@ -957,11 +959,17 @@ public class PurpurWorldConfig { set("mobs.enderman.attributes.max-health", null); set("mobs.enderman.attributes.max_health", oldValue); } diff --git a/patches/server/0147-Config-to-ignore-Dragon-Head-wearers-and-stare-aggro.patch b/patches/server/0147-Config-to-ignore-Dragon-Head-wearers-and-stare-aggro.patch index a449269e4..720980474 100644 --- a/patches/server/0147-Config-to-ignore-Dragon-Head-wearers-and-stare-aggro.patch +++ b/patches/server/0147-Config-to-ignore-Dragon-Head-wearers-and-stare-aggro.patch @@ -20,10 +20,10 @@ index 99e4c23140b85d37c7b266c2fcf57c94fd19ec7c..b0c4c90ab2d532a60911d53ac4764dcf } else { Vec3 vec3d = player.getViewVector(1.0F).normalize(); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 7b00b367c895e200f11a99d4e2a0953defd8eb04..a5c25519d6a2fd11f957c425c6142195034e0e17 100644 +index 2f72f95cb086ef641710022cffa9a6396842b13c..ba7ecc009bd808d2c93017d2bdc1511f01291bcb 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -941,6 +941,8 @@ public class PurpurWorldConfig { +@@ -950,6 +950,8 @@ public class PurpurWorldConfig { public boolean endermanTakeDamageFromWater = true; public boolean endermanAggroEndermites = true; public boolean endermanAggroEndermitesOnlyIfPlayerSpawned = false; @@ -32,7 +32,7 @@ index 7b00b367c895e200f11a99d4e2a0953defd8eb04..a5c25519d6a2fd11f957c425c6142195 private void endermanSettings() { endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable); endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater); -@@ -961,6 +963,8 @@ public class PurpurWorldConfig { +@@ -970,6 +972,8 @@ public class PurpurWorldConfig { endermanTakeDamageFromWater = getBoolean("mobs.enderman.takes-damage-from-water", endermanTakeDamageFromWater); endermanAggroEndermites = getBoolean("mobs.enderman.aggressive-towards-endermites", endermanAggroEndermites); endermanAggroEndermitesOnlyIfPlayerSpawned = getBoolean("mobs.enderman.aggressive-towards-endermites-only-spawned-by-player-thrown-ender-pearls", endermanAggroEndermitesOnlyIfPlayerSpawned); diff --git a/patches/server/0149-Config-to-disable-Llama-caravans.patch b/patches/server/0149-Config-to-disable-Llama-caravans.patch index f94b60537..2cae1209c 100644 --- a/patches/server/0149-Config-to-disable-Llama-caravans.patch +++ b/patches/server/0149-Config-to-disable-Llama-caravans.patch @@ -32,10 +32,10 @@ index 708f0bccffc05fac0d711df13dd1b5e173ff6109..b7b8d7587018759fc418043694abd38f this.caravanHead.caravanTail = this; } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 09a3e905b95bcbd25795208b29e5b03d529cfa15..e455de3e0e8c9777eaf2925fdcc08dbb1aef5863 100644 +index 593675412750aa4aa5a9a59d034911008612f191..04b3db1368a5e1a689df7f21a57af3795e650a6b 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1265,6 +1265,7 @@ public class PurpurWorldConfig { +@@ -1282,6 +1282,7 @@ public class PurpurWorldConfig { public double llamaMovementSpeedMax = 0.175D; public int llamaBreedingTicks = 6000; public boolean llamaTakeDamageFromWater = false; @@ -43,7 +43,7 @@ index 09a3e905b95bcbd25795208b29e5b03d529cfa15..e455de3e0e8c9777eaf2925fdcc08dbb private void llamaSettings() { llamaRidable = getBoolean("mobs.llama.ridable", llamaRidable); llamaRidableInWater = getBoolean("mobs.llama.ridable-in-water", llamaRidableInWater); -@@ -1284,6 +1285,7 @@ public class PurpurWorldConfig { +@@ -1301,6 +1302,7 @@ public class PurpurWorldConfig { llamaMovementSpeedMax = getDouble("mobs.llama.attributes.movement_speed.max", llamaMovementSpeedMax); llamaBreedingTicks = getInt("mobs.llama.breeding-delay-ticks", llamaBreedingTicks); llamaTakeDamageFromWater = getBoolean("mobs.llama.takes-damage-from-water", llamaTakeDamageFromWater); diff --git a/patches/server/0150-Config-to-make-Creepers-explode-on-death.patch b/patches/server/0150-Config-to-make-Creepers-explode-on-death.patch index a7679e0cb..c54048cf6 100644 --- a/patches/server/0150-Config-to-make-Creepers-explode-on-death.patch +++ b/patches/server/0150-Config-to-make-Creepers-explode-on-death.patch @@ -50,10 +50,10 @@ index fa4d5579dcdaad04fa2e6cd9ae47af1154739121..bd58b7d364b5e0361e7b8c67d1b26b7f private void spawnLingeringCloud() { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index b43dff5223728fe1f16fef4ccd1720d57be610c3..24940550e9f0778630d9f1ffa80638d39b94bb10 100644 +index 04b3db1368a5e1a689df7f21a57af3795e650a6b..dd47a7aa6c6dca97cad00c0226e93a78f596114d 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -793,6 +793,7 @@ public class PurpurWorldConfig { +@@ -802,6 +802,7 @@ public class PurpurWorldConfig { public boolean creeperAllowGriefing = true; public boolean creeperBypassMobGriefing = false; public boolean creeperTakeDamageFromWater = false; @@ -61,7 +61,7 @@ index b43dff5223728fe1f16fef4ccd1720d57be610c3..24940550e9f0778630d9f1ffa80638d3 private void creeperSettings() { creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable); creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater); -@@ -807,6 +808,7 @@ public class PurpurWorldConfig { +@@ -816,6 +817,7 @@ public class PurpurWorldConfig { creeperAllowGriefing = getBoolean("mobs.creeper.allow-griefing", creeperAllowGriefing); creeperBypassMobGriefing = getBoolean("mobs.creeper.bypass-mob-griefing", creeperBypassMobGriefing); creeperTakeDamageFromWater = getBoolean("mobs.creeper.takes-damage-from-water", creeperTakeDamageFromWater); diff --git a/patches/server/0151-Configurable-ravager-griefable-blocks-list.patch b/patches/server/0151-Configurable-ravager-griefable-blocks-list.patch index 188e7a6d3..fe1f3f0e7 100644 --- a/patches/server/0151-Configurable-ravager-griefable-blocks-list.patch +++ b/patches/server/0151-Configurable-ravager-griefable-blocks-list.patch @@ -31,10 +31,10 @@ index a68bf10353e5c19adfa86c2dd6290f2386af9a9d..38bc19edc2dcfa33b3191cfa3b69f00d } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 06091698c5c40e5555a3c306306cb2fc23c1772c..ae1fc28c2a2244068997f4094d356a75abd3b52e 100644 +index dd47a7aa6c6dca97cad00c0226e93a78f596114d..36cc2736e023a6c0273a511be6a11aaecb5a140a 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1649,6 +1649,7 @@ public class PurpurWorldConfig { +@@ -1666,6 +1666,7 @@ public class PurpurWorldConfig { public double ravagerMaxHealth = 100.0D; public boolean ravagerBypassMobGriefing = false; public boolean ravagerTakeDamageFromWater = false; @@ -42,7 +42,7 @@ index 06091698c5c40e5555a3c306306cb2fc23c1772c..ae1fc28c2a2244068997f4094d356a75 private void ravagerSettings() { ravagerRidable = getBoolean("mobs.ravager.ridable", ravagerRidable); ravagerRidableInWater = getBoolean("mobs.ravager.ridable-in-water", ravagerRidableInWater); -@@ -1661,6 +1662,23 @@ public class PurpurWorldConfig { +@@ -1678,6 +1679,23 @@ public class PurpurWorldConfig { ravagerMaxHealth = getDouble("mobs.ravager.attributes.max_health", ravagerMaxHealth); ravagerBypassMobGriefing = getBoolean("mobs.ravager.bypass-mob-griefing", ravagerBypassMobGriefing); ravagerTakeDamageFromWater = getBoolean("mobs.ravager.takes-damage-from-water", ravagerTakeDamageFromWater); diff --git a/patches/server/0154-Add-config-for-villager-trading.patch b/patches/server/0154-Add-config-for-villager-trading.patch index b53eec83b..5c1144e27 100644 --- a/patches/server/0154-Add-config-for-villager-trading.patch +++ b/patches/server/0154-Add-config-for-villager-trading.patch @@ -31,10 +31,10 @@ index 6dd8856816bebb2766203589048cc68b3f5c8f5c..8d6930868a42b9fc98d7672bff433ec5 this.openTradingScreen(player, this.getDisplayName(), 1); } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ea1a37575f69472f504fd688b8568f4a8d6fc6cc..bed116f39309d6aa7f34ba7a5e939d294a5ff5c1 100644 +index f07c2a1a3cfa05e500e581297e663c7e00dc7496..fd22332802f798142d25b90b324741ca4319ae16 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2049,6 +2049,7 @@ public class PurpurWorldConfig { +@@ -2075,6 +2075,7 @@ public class PurpurWorldConfig { public boolean villagerClericFarmersThrowWarts = true; public boolean villagerBypassMobGriefing = false; public boolean villagerTakeDamageFromWater = false; @@ -42,7 +42,7 @@ index ea1a37575f69472f504fd688b8568f4a8d6fc6cc..bed116f39309d6aa7f34ba7a5e939d29 private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -2069,6 +2070,7 @@ public class PurpurWorldConfig { +@@ -2095,6 +2096,7 @@ public class PurpurWorldConfig { villagerClericFarmersThrowWarts = getBoolean("mobs.villager.cleric-wart-farmers-throw-warts-at-villagers", villagerClericFarmersThrowWarts); villagerBypassMobGriefing = getBoolean("mobs.villager.bypass-mob-griefing", villagerBypassMobGriefing); villagerTakeDamageFromWater = getBoolean("mobs.villager.takes-damage-from-water", villagerTakeDamageFromWater); @@ -50,7 +50,7 @@ index ea1a37575f69472f504fd688b8568f4a8d6fc6cc..bed116f39309d6aa7f34ba7a5e939d29 } public boolean vindicatorRidable = false; -@@ -2098,6 +2100,7 @@ public class PurpurWorldConfig { +@@ -2124,6 +2126,7 @@ public class PurpurWorldConfig { public boolean wanderingTraderFollowEmeraldBlock = false; public boolean wanderingTraderCanBeLeashed = false; public boolean wanderingTraderTakeDamageFromWater = false; @@ -58,11 +58,11 @@ index ea1a37575f69472f504fd688b8568f4a8d6fc6cc..bed116f39309d6aa7f34ba7a5e939d29 private void wanderingTraderSettings() { wanderingTraderRidable = getBoolean("mobs.wandering_trader.ridable", wanderingTraderRidable); wanderingTraderRidableInWater = getBoolean("mobs.wandering_trader.ridable-in-water", wanderingTraderRidableInWater); -@@ -2111,6 +2114,7 @@ public class PurpurWorldConfig { +@@ -2137,6 +2140,7 @@ public class PurpurWorldConfig { wanderingTraderFollowEmeraldBlock = getBoolean("mobs.wandering_trader.follow-emerald-blocks", wanderingTraderFollowEmeraldBlock); 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); } - public boolean witchRidable = false; + public boolean wardenRidable = false; diff --git a/patches/server/0165-Piglin-portal-spawn-modifier.patch b/patches/server/0165-Piglin-portal-spawn-modifier.patch index 4982bb4e0..fbc6eac2f 100644 --- a/patches/server/0165-Piglin-portal-spawn-modifier.patch +++ b/patches/server/0165-Piglin-portal-spawn-modifier.patch @@ -31,10 +31,10 @@ index 65fa00b3d4d35a4125f8de444e77ac54e9e28551..dd9badfb2879def258bf725a5d802f7d pos = pos.below(); } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ef7da953b0f6c40628a4911356a6ffddccef4bc5..4380ec78f5ca862c82e32b3b277e5e31003b5ab9 100644 +index e87624e72af07eae74763130b60d18bc746c4f55..9ffa0e46acc4d9ba325433b0fecc813280ae9afe 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1593,6 +1593,7 @@ public class PurpurWorldConfig { +@@ -1610,6 +1610,7 @@ public class PurpurWorldConfig { public double piglinMaxHealth = 16.0D; public boolean piglinBypassMobGriefing = false; public boolean piglinTakeDamageFromWater = false; @@ -42,7 +42,7 @@ index ef7da953b0f6c40628a4911356a6ffddccef4bc5..4380ec78f5ca862c82e32b3b277e5e31 private void piglinSettings() { piglinRidable = getBoolean("mobs.piglin.ridable", piglinRidable); piglinRidableInWater = getBoolean("mobs.piglin.ridable-in-water", piglinRidableInWater); -@@ -1605,6 +1606,7 @@ public class PurpurWorldConfig { +@@ -1622,6 +1623,7 @@ public class PurpurWorldConfig { piglinMaxHealth = getDouble("mobs.piglin.attributes.max_health", piglinMaxHealth); piglinBypassMobGriefing = getBoolean("mobs.piglin.bypass-mob-griefing", piglinBypassMobGriefing); piglinTakeDamageFromWater = getBoolean("mobs.piglin.takes-damage-from-water", piglinTakeDamageFromWater); diff --git a/patches/server/0167-Config-for-wither-explosion-radius.patch b/patches/server/0167-Config-for-wither-explosion-radius.patch index 2324aacfc..475e116e2 100644 --- a/patches/server/0167-Config-for-wither-explosion-radius.patch +++ b/patches/server/0167-Config-for-wither-explosion-radius.patch @@ -18,10 +18,10 @@ index a66e9826b8283366cec5adb54f79efee47d9df22..6cf8b12e94c17a8111eef5cc0157e4df if (!event.isCancelled()) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 4380ec78f5ca862c82e32b3b277e5e31003b5ab9..96eb9e664308b05194df76efc961619ed52efb48 100644 +index 9ffa0e46acc4d9ba325433b0fecc813280ae9afe..ada571cec108251e891bd80aeab1a115ed50415f 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2209,6 +2209,7 @@ public class PurpurWorldConfig { +@@ -2244,6 +2244,7 @@ public class PurpurWorldConfig { public boolean witherBypassMobGriefing = false; public boolean witherTakeDamageFromWater = false; public boolean witherCanRideVehicles = false; @@ -29,7 +29,7 @@ index 4380ec78f5ca862c82e32b3b277e5e31003b5ab9..96eb9e664308b05194df76efc961619e private void witherSettings() { witherRidable = getBoolean("mobs.wither.ridable", witherRidable); witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater); -@@ -2229,6 +2230,7 @@ public class PurpurWorldConfig { +@@ -2264,6 +2265,7 @@ public class PurpurWorldConfig { witherBypassMobGriefing = getBoolean("mobs.wither.bypass-mob-griefing", witherBypassMobGriefing); witherTakeDamageFromWater = getBoolean("mobs.wither.takes-damage-from-water", witherTakeDamageFromWater); witherCanRideVehicles = getBoolean("mobs.wither.can-ride-vehicles", witherCanRideVehicles); diff --git a/patches/server/0174-Config-for-health-to-impact-Creeper-explosion-radius.patch b/patches/server/0174-Config-for-health-to-impact-Creeper-explosion-radius.patch index 82b6327be..4e1ae6929 100644 --- a/patches/server/0174-Config-for-health-to-impact-Creeper-explosion-radius.patch +++ b/patches/server/0174-Config-for-health-to-impact-Creeper-explosion-radius.patch @@ -21,10 +21,10 @@ index bd58b7d364b5e0361e7b8c67d1b26b7f8d3906d3..b19e130b56839c261dd71bbf62b052ed if (!event.isCancelled()) { this.dead = true; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ed7006fd22c9a9bbb519e75f8d4578b9bab3831e..1d6f9204cc25eb882db5da5dbd1f67ef257a07ed 100644 +index 9b4560b61f61d7693477a7b25356532f8082060b..77c18bfec6f035d24059e5591fa8eea6f84cb2b9 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -885,6 +885,7 @@ public class PurpurWorldConfig { +@@ -894,6 +894,7 @@ public class PurpurWorldConfig { public boolean creeperBypassMobGriefing = false; public boolean creeperTakeDamageFromWater = false; public boolean creeperExplodeWhenKilled = false; @@ -32,7 +32,7 @@ index ed7006fd22c9a9bbb519e75f8d4578b9bab3831e..1d6f9204cc25eb882db5da5dbd1f67ef private void creeperSettings() { creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable); creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater); -@@ -900,6 +901,7 @@ public class PurpurWorldConfig { +@@ -909,6 +910,7 @@ public class PurpurWorldConfig { creeperBypassMobGriefing = getBoolean("mobs.creeper.bypass-mob-griefing", creeperBypassMobGriefing); creeperTakeDamageFromWater = getBoolean("mobs.creeper.takes-damage-from-water", creeperTakeDamageFromWater); creeperExplodeWhenKilled = getBoolean("mobs.creeper.explode-when-killed", creeperExplodeWhenKilled); diff --git a/patches/server/0175-Iron-golem-calm-anger-options.patch b/patches/server/0175-Iron-golem-calm-anger-options.patch index 34bd1c769..5ed0c71e1 100644 --- a/patches/server/0175-Iron-golem-calm-anger-options.patch +++ b/patches/server/0175-Iron-golem-calm-anger-options.patch @@ -26,10 +26,10 @@ index e3d725e656bc5ffc5fc92133794a80799fb21c48..fdad66c329ff8945a76a944deca7751a } } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 388f02553244beee6c4c4ee91dcac9349c403366..123e54b6f3fd1d40c35672bb35db9b9dd983a6cd 100644 +index 77c18bfec6f035d24059e5591fa8eea6f84cb2b9..8a83080a5530824ef94c0fb68a10528fe91025b2 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1335,6 +1335,8 @@ public class PurpurWorldConfig { +@@ -1352,6 +1352,8 @@ public class PurpurWorldConfig { public boolean ironGolemCanSwim = false; public double ironGolemMaxHealth = 100.0D; public boolean ironGolemTakeDamageFromWater = false; @@ -38,7 +38,7 @@ index 388f02553244beee6c4c4ee91dcac9349c403366..123e54b6f3fd1d40c35672bb35db9b9d private void ironGolemSettings() { ironGolemRidable = getBoolean("mobs.iron_golem.ridable", ironGolemRidable); ironGolemRidableInWater = getBoolean("mobs.iron_golem.ridable-in-water", ironGolemRidableInWater); -@@ -1347,6 +1349,8 @@ public class PurpurWorldConfig { +@@ -1364,6 +1366,8 @@ public class PurpurWorldConfig { } ironGolemMaxHealth = getDouble("mobs.iron_golem.attributes.max_health", ironGolemMaxHealth); ironGolemTakeDamageFromWater = getBoolean("mobs.iron_golem.takes-damage-from-water", ironGolemTakeDamageFromWater); diff --git a/patches/server/0176-Breedable-parrots.patch b/patches/server/0176-Breedable-parrots.patch index 6152db0c1..7e79eeeaa 100644 --- a/patches/server/0176-Breedable-parrots.patch +++ b/patches/server/0176-Breedable-parrots.patch @@ -50,10 +50,10 @@ index 11291851f11127f6781b3c77c0d59534606eb9dd..4f4df0f5459e3f62db4b15c57a536dc2 @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 123e54b6f3fd1d40c35672bb35db9b9dd983a6cd..03973a312dcb53e427b238d710939f4e5dfa6cb0 100644 +index 8a83080a5530824ef94c0fb68a10528fe91025b2..326af738e7475d9d78fb2bb6a877b86e895b0e48 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1505,6 +1505,7 @@ public class PurpurWorldConfig { +@@ -1522,6 +1522,7 @@ public class PurpurWorldConfig { public double parrotMaxY = 320D; public double parrotMaxHealth = 6.0D; public boolean parrotTakeDamageFromWater = false; @@ -61,7 +61,7 @@ index 123e54b6f3fd1d40c35672bb35db9b9dd983a6cd..03973a312dcb53e427b238d710939f4e private void parrotSettings() { parrotRidable = getBoolean("mobs.parrot.ridable", parrotRidable); parrotRidableInWater = getBoolean("mobs.parrot.ridable-in-water", parrotRidableInWater); -@@ -1517,6 +1518,7 @@ public class PurpurWorldConfig { +@@ -1534,6 +1535,7 @@ public class PurpurWorldConfig { } parrotMaxHealth = getDouble("mobs.parrot.attributes.max_health", parrotMaxHealth); parrotTakeDamageFromWater = getBoolean("mobs.parrot.takes-damage-from-water", parrotTakeDamageFromWater); diff --git a/patches/server/0183-Bee-can-work-when-raining-or-at-night.patch b/patches/server/0183-Bee-can-work-when-raining-or-at-night.patch index 4b09cdc50..9cdf7d6ff 100644 --- a/patches/server/0183-Bee-can-work-when-raining-or-at-night.patch +++ b/patches/server/0183-Bee-can-work-when-raining-or-at-night.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Bee can work when raining or at night 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 15b8992ef9f77153885cb27e305e854f8d775864..e8302e054b74ba6793b4b0928f0e87edb645d450 100644 +index 6bcdc433ab80be133cfb56beda8b01d995ace7af..a51fd1e4e6fb816f544112249e7f7192b334b255 100644 --- a/src/main/java/net/minecraft/world/entity/animal/Bee.java +++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java @@ -410,7 +410,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal { @@ -31,10 +31,10 @@ index a16a1df28258d605cf5908dbe19bda5d71ad4f45..7b82842b97ce795745cf6ee6399f618c return false; } else { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 93ae0620013ceef2f52ecd57a97e6397dcbc8e96..15796f7fac9105433fc4bbae688d5683e9c3ba40 100644 +index b7967ccd13ff0bfb5ac687a57de4409d05d30bd7..0576d3523a90c835a99485306ed032b0f28d6fd8 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -745,6 +745,8 @@ public class PurpurWorldConfig { +@@ -754,6 +754,8 @@ public class PurpurWorldConfig { public double beeMaxHealth = 10.0D; public int beeBreedingTicks = 6000; public boolean beeTakeDamageFromWater = false; @@ -43,7 +43,7 @@ index 93ae0620013ceef2f52ecd57a97e6397dcbc8e96..15796f7fac9105433fc4bbae688d5683 private void beeSettings() { beeRidable = getBoolean("mobs.bee.ridable", beeRidable); beeRidableInWater = getBoolean("mobs.bee.ridable-in-water", beeRidableInWater); -@@ -758,6 +760,8 @@ public class PurpurWorldConfig { +@@ -767,6 +769,8 @@ public class PurpurWorldConfig { beeMaxHealth = getDouble("mobs.bee.attributes.max_health", beeMaxHealth); beeBreedingTicks = getInt("mobs.bee.breeding-delay-ticks", beeBreedingTicks); beeTakeDamageFromWater = getBoolean("mobs.bee.takes-damage-from-water", beeTakeDamageFromWater); diff --git a/patches/server/0194-Shulker-spawn-from-bullet-options.patch b/patches/server/0194-Shulker-spawn-from-bullet-options.patch index 719c1e16b..5e78b3131 100644 --- a/patches/server/0194-Shulker-spawn-from-bullet-options.patch +++ b/patches/server/0194-Shulker-spawn-from-bullet-options.patch @@ -61,10 +61,10 @@ index 2d3dbc228a6a7b88167a36ba739d9eb2f03472ba..7621978ab3d90d58e8b7c6807e0e0519 + // Purpur end } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index a05880bdf671404b961e5a8ac32867324b454a01..b4d23c22c746a3b136cf76de94610852c37b2b75 100644 +index 3f027244cc41ce2ab28425b92b15ba752d1d77e0..fd2d7270179fa111ea1dbf2f9f8447cd459b33e0 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1881,6 +1881,11 @@ public class PurpurWorldConfig { +@@ -1898,6 +1898,11 @@ public class PurpurWorldConfig { public boolean shulkerControllable = true; public double shulkerMaxHealth = 30.0D; public boolean shulkerTakeDamageFromWater = false; @@ -76,7 +76,7 @@ index a05880bdf671404b961e5a8ac32867324b454a01..b4d23c22c746a3b136cf76de94610852 private void shulkerSettings() { shulkerRidable = getBoolean("mobs.shulker.ridable", shulkerRidable); shulkerRidableInWater = getBoolean("mobs.shulker.ridable-in-water", shulkerRidableInWater); -@@ -1892,6 +1897,11 @@ public class PurpurWorldConfig { +@@ -1909,6 +1914,11 @@ public class PurpurWorldConfig { } shulkerMaxHealth = getDouble("mobs.shulker.attributes.max_health", shulkerMaxHealth); shulkerTakeDamageFromWater = getBoolean("mobs.shulker.takes-damage-from-water", shulkerTakeDamageFromWater); diff --git a/patches/server/0196-Option-to-make-drowned-break-doors.patch b/patches/server/0196-Option-to-make-drowned-break-doors.patch index 296a9b336..5e21126b9 100644 --- a/patches/server/0196-Option-to-make-drowned-break-doors.patch +++ b/patches/server/0196-Option-to-make-drowned-break-doors.patch @@ -34,10 +34,10 @@ index 037d77b47d0be69dfeda01f4a0d52ad72aea2c8d..6e0a575a95ac0bcbc9e3909178ea566a @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 18e8f9a54235be5d887dacf7db05a6ddc240c78e..cf3987ea985f5868f3904bed0a8f23ecbc978e02 100644 +index 72712004bd5d176e0b7857de5b07487c088259fb..bcbfa86ea0df23d72c3117b9039f29907ff06a40 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1023,6 +1023,7 @@ public class PurpurWorldConfig { +@@ -1032,6 +1032,7 @@ public class PurpurWorldConfig { public double drownedJockeyChance = 0.05D; public boolean drownedJockeyTryExistingChickens = true; public boolean drownedTakeDamageFromWater = false; @@ -45,7 +45,7 @@ index 18e8f9a54235be5d887dacf7db05a6ddc240c78e..cf3987ea985f5868f3904bed0a8f23ec private void drownedSettings() { drownedRidable = getBoolean("mobs.drowned.ridable", drownedRidable); drownedRidableInWater = getBoolean("mobs.drowned.ridable-in-water", drownedRidableInWater); -@@ -1038,6 +1039,7 @@ public class PurpurWorldConfig { +@@ -1047,6 +1048,7 @@ public class PurpurWorldConfig { drownedJockeyChance = getDouble("mobs.drowned.jockey.chance", drownedJockeyChance); drownedJockeyTryExistingChickens = getBoolean("mobs.drowned.jockey.try-existing-chickens", drownedJockeyTryExistingChickens); drownedTakeDamageFromWater = getBoolean("mobs.drowned.takes-damage-from-water", drownedTakeDamageFromWater); diff --git a/patches/server/0197-Configurable-hunger-starvation-damage.patch b/patches/server/0197-Configurable-hunger-starvation-damage.patch index 1adcfe402..01b3d16a8 100644 --- a/patches/server/0197-Configurable-hunger-starvation-damage.patch +++ b/patches/server/0197-Configurable-hunger-starvation-damage.patch @@ -18,10 +18,10 @@ index 65421cfff05c0493f5fef1bdff03172c9e33f33e..63584faeec4e5013be7a377e3203ec16 this.tickTimer = 0; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index c0098675938664fde92daa9a279c283ca8c865a2..fa879cf3370a8c58f13ba801fbb4b238407738d5 100644 +index bcbfa86ea0df23d72c3117b9039f29907ff06a40..901da4d174761d3fded38c9228d738934f338998 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2511,4 +2511,9 @@ public class PurpurWorldConfig { +@@ -2546,4 +2546,9 @@ public class PurpurWorldConfig { zombifiedPiglinCountAsPlayerKillWhenAngry = getBoolean("mobs.zombified_piglin.count-as-player-kill-when-angry", zombifiedPiglinCountAsPlayerKillWhenAngry); zombifiedPiglinTakeDamageFromWater = getBoolean("mobs.zombified_piglin.takes-damage-from-water", zombifiedPiglinTakeDamageFromWater); } diff --git a/patches/server/0204-Summoner-API.patch b/patches/server/0204-Summoner-API.patch index 59dd9ce17..9a3dc0aee 100644 --- a/patches/server/0204-Summoner-API.patch +++ b/patches/server/0204-Summoner-API.patch @@ -93,7 +93,7 @@ index 069f90f113aeaa61236c86a07463c4190fc36c4e..a407254b527b9d39c03d1ceb5f685868 } 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 fd5d0a75ea5e30df4f606bc4756a32ecbbe9abad..bb62e4750e1a59d33803b516d7118f92c612c85e 100644 +index 6818618cd2f702e894ac4098b4eb5afc7664408e..01397e9daf03a308707cc7e2bb85db68137d3021 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 @@ -85,6 +85,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob @@ -104,7 +104,7 @@ index fd5d0a75ea5e30df4f606bc4756a32ecbbe9abad..bb62e4750e1a59d33803b516d7118f92 // Paper start private boolean canPortal = false; -@@ -227,6 +228,15 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -239,6 +240,15 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob public boolean isSensitiveToWater() { return this.level.purpurConfig.witherTakeDamageFromWater; } @@ -120,7 +120,7 @@ index fd5d0a75ea5e30df4f606bc4756a32ecbbe9abad..bb62e4750e1a59d33803b516d7118f92 // Purpur end @Override -@@ -255,6 +265,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -267,6 +277,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob public void addAdditionalSaveData(CompoundTag nbt) { super.addAdditionalSaveData(nbt); nbt.putInt("Invul", this.getInvulnerableTicks()); @@ -128,7 +128,7 @@ index fd5d0a75ea5e30df4f606bc4756a32ecbbe9abad..bb62e4750e1a59d33803b516d7118f92 } @Override -@@ -264,6 +275,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -276,6 +287,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob if (this.hasCustomName()) { this.bossEvent.setName(this.getDisplayName()); } diff --git a/patches/server/0207-Silk-touchable-budding-amethyst.patch b/patches/server/0207-Silk-touchable-budding-amethyst.patch index fce5891db..ee15f95de 100644 --- a/patches/server/0207-Silk-touchable-budding-amethyst.patch +++ b/patches/server/0207-Silk-touchable-budding-amethyst.patch @@ -24,7 +24,7 @@ index bedccb8717d08d5a60058445b04ddff149e7d36c..5293ffca3da94c9c485a87d1232b6a90 + // Purpur end } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 2bcb5506cd509eb4afd68bc80eeea2e45cc8c329..a76d99dd6036cb7708a37d54153ff45b9e06f947 100644 +index 159e6247d6499cba126b7010e7b61164bf0d6d0f..98bfdf9f8845ed919f2f6f062d4fc2eff95ddbe7 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java @@ -691,6 +691,11 @@ public class PurpurWorldConfig { @@ -39,7 +39,7 @@ index 2bcb5506cd509eb4afd68bc80eeea2e45cc8c329..a76d99dd6036cb7708a37d54153ff45b public boolean chestOpenWithBlockOnTop = false; private void chestSettings() { chestOpenWithBlockOnTop = getBoolean("blocks.chest.open-with-solid-block-on-top", chestOpenWithBlockOnTop); -@@ -2670,3 +2675,4 @@ public class PurpurWorldConfig { +@@ -2705,3 +2710,4 @@ public class PurpurWorldConfig { hungerStarvationDamage = (float) getDouble("hunger.starvation-damage", hungerStarvationDamage); } } diff --git a/patches/server/0210-Config-to-disable-Enderman-teleport-on-projectile-hi.patch b/patches/server/0210-Config-to-disable-Enderman-teleport-on-projectile-hi.patch index 1b2a49032..a411ca2a4 100644 --- a/patches/server/0210-Config-to-disable-Enderman-teleport-on-projectile-hi.patch +++ b/patches/server/0210-Config-to-disable-Enderman-teleport-on-projectile-hi.patch @@ -18,10 +18,10 @@ index b0c4c90ab2d532a60911d53ac4764dcf49fff6c8..372400d5ce38407b577e5ee403ce39fc boolean flag; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index fd141a7e78e8b59266e0a5b7969187c21ea0d3ae..d02663b591c7106205778f2cb5b84d376d798c43 100644 +index e125753d1d5d592b623f141d87966862b6d9846e..bdf2ebb27cc67da95930c9971de3cf2e66bb14d3 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1276,6 +1276,7 @@ public class PurpurWorldConfig { +@@ -1285,6 +1285,7 @@ public class PurpurWorldConfig { public boolean endermanAggroEndermitesOnlyIfPlayerSpawned = false; public boolean endermanIgnorePlayerDragonHead = false; public boolean endermanDisableStareAggro = false; @@ -29,7 +29,7 @@ index fd141a7e78e8b59266e0a5b7969187c21ea0d3ae..d02663b591c7106205778f2cb5b84d37 private void endermanSettings() { endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable); endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater); -@@ -1298,6 +1299,7 @@ public class PurpurWorldConfig { +@@ -1307,6 +1308,7 @@ public class PurpurWorldConfig { endermanAggroEndermitesOnlyIfPlayerSpawned = getBoolean("mobs.enderman.aggressive-towards-endermites-only-spawned-by-player-thrown-ender-pearls", endermanAggroEndermitesOnlyIfPlayerSpawned); endermanIgnorePlayerDragonHead = getBoolean("mobs.enderman.ignore-players-wearing-dragon-head", endermanIgnorePlayerDragonHead); endermanDisableStareAggro = getBoolean("mobs.enderman.disable-player-stare-aggression", endermanDisableStareAggro); diff --git a/patches/server/0212-Config-to-prevent-horses-from-standing-with-riders.patch b/patches/server/0212-Config-to-prevent-horses-from-standing-with-riders.patch index 90aab53d3..06dcca930 100644 --- a/patches/server/0212-Config-to-prevent-horses-from-standing-with-riders.patch +++ b/patches/server/0212-Config-to-prevent-horses-from-standing-with-riders.patch @@ -20,10 +20,10 @@ index a1ffa88c3796df2973a2fc0aeafda5f78208bf85..7466c437b2e996f16a08aaefc5c2b7cb } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ce692400f61838af8cf75e3c8b6f016ddc0f588b..d7241a6c5069023b75bfa813daccaf8e47c164e6 100644 +index 1686fb653f35cfd42364a61012b47724ccea115f..cbfaebf03d9de4086306e7feac0f894e2ec0a23f 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1498,6 +1498,7 @@ public class PurpurWorldConfig { +@@ -1515,6 +1515,7 @@ public class PurpurWorldConfig { public double horseMovementSpeedMax = 0.3375D; public int horseBreedingTicks = 6000; public boolean horseTakeDamageFromWater = false; @@ -31,7 +31,7 @@ index ce692400f61838af8cf75e3c8b6f016ddc0f588b..d7241a6c5069023b75bfa813daccaf8e private void horseSettings() { horseRidableInWater = getBoolean("mobs.horse.ridable-in-water", horseRidableInWater); if (PurpurConfig.version < 10) { -@@ -1515,6 +1516,7 @@ public class PurpurWorldConfig { +@@ -1532,6 +1533,7 @@ public class PurpurWorldConfig { horseMovementSpeedMax = getDouble("mobs.horse.attributes.movement_speed.max", horseMovementSpeedMax); horseBreedingTicks = getInt("mobs.horse.breeding-delay-ticks", horseBreedingTicks); horseTakeDamageFromWater = getBoolean("mobs.horse.takes-damage-from-water", horseTakeDamageFromWater); diff --git a/patches/server/0215-Customizeable-Zombie-Villager-curing-times.patch b/patches/server/0215-Customizeable-Zombie-Villager-curing-times.patch index d162f9bdc..269152c17 100644 --- a/patches/server/0215-Customizeable-Zombie-Villager-curing-times.patch +++ b/patches/server/0215-Customizeable-Zombie-Villager-curing-times.patch @@ -18,10 +18,10 @@ index c90cf19a4c29aa33c96a67bfab24cbbb56d783da..54b5749a5e40ed9042af1c4904afcdc4 return InteractionResult.SUCCESS; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 1ce0dd00d4b0bbd7e807cbf9ca3b31a3ef69f184..c9f3c7f10e61ca7c5b62a5a939d3422995a43680 100644 +index 994bf424da78ac632e7967b14c2dabda4d4be00a..eeb6d629c945b8c3066a344ddd19ce665a454fc1 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2656,6 +2656,8 @@ public class PurpurWorldConfig { +@@ -2691,6 +2691,8 @@ public class PurpurWorldConfig { public double zombieVillagerJockeyChance = 0.05D; public boolean zombieVillagerJockeyTryExistingChickens = true; public boolean zombieVillagerTakeDamageFromWater = false; @@ -30,7 +30,7 @@ index 1ce0dd00d4b0bbd7e807cbf9ca3b31a3ef69f184..c9f3c7f10e61ca7c5b62a5a939d34229 private void zombieVillagerSettings() { zombieVillagerRidable = getBoolean("mobs.zombie_villager.ridable", zombieVillagerRidable); zombieVillagerRidableInWater = getBoolean("mobs.zombie_villager.ridable-in-water", zombieVillagerRidableInWater); -@@ -2671,6 +2673,8 @@ public class PurpurWorldConfig { +@@ -2706,6 +2708,8 @@ public class PurpurWorldConfig { zombieVillagerJockeyChance = getDouble("mobs.zombie_villager.jockey.chance", zombieVillagerJockeyChance); zombieVillagerJockeyTryExistingChickens = getBoolean("mobs.zombie_villager.jockey.try-existing-chickens", zombieVillagerJockeyTryExistingChickens); zombieVillagerTakeDamageFromWater = getBoolean("mobs.zombie_villager.takes-damage-from-water", zombieVillagerTakeDamageFromWater); diff --git a/patches/server/0217-Toggle-for-Wither-s-spawn-sound.patch b/patches/server/0217-Toggle-for-Wither-s-spawn-sound.patch index 7b5fe8376..0058b2854 100644 --- a/patches/server/0217-Toggle-for-Wither-s-spawn-sound.patch +++ b/patches/server/0217-Toggle-for-Wither-s-spawn-sound.patch @@ -5,10 +5,10 @@ Subject: [PATCH] Toggle for Wither's spawn sound 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 bb62e4750e1a59d33803b516d7118f92c612c85e..5d567d97ce0be0728e538055ce6349a8861abddb 100644 +index 01397e9daf03a308707cc7e2bb85db68137d3021..0dd31e45252d54b8bfa3645b25c984de30934a0e 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 -@@ -418,7 +418,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -430,7 +430,7 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob } // CraftBukkit end @@ -18,10 +18,10 @@ index bb62e4750e1a59d33803b516d7118f92c612c85e..5d567d97ce0be0728e538055ce6349a8 // this.world.globalLevelEvent(1023, new BlockPosition(this), 0); //int viewDistance = ((ServerLevel) this.level).getCraftServer().getViewDistance() * 16; // Paper - updated to use worlds actual view distance incase we have to uncomment this due to removal of player view distance API diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 2f25da9749008a876fd489218adcf6548216b3e6..7dfee05a5143ca8ca2222248e3b2b641066a8c97 100644 +index 2bfd21b5dc2b96e68c90dff93ec34bb8c90da333..67f196626ee04c0366e3cd50413d4bb40016a870 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2501,6 +2501,7 @@ public class PurpurWorldConfig { +@@ -2536,6 +2536,7 @@ public class PurpurWorldConfig { public boolean witherTakeDamageFromWater = false; public boolean witherCanRideVehicles = false; public float witherExplosionRadius = 1.0F; @@ -29,7 +29,7 @@ index 2f25da9749008a876fd489218adcf6548216b3e6..7dfee05a5143ca8ca2222248e3b2b641 private void witherSettings() { witherRidable = getBoolean("mobs.wither.ridable", witherRidable); witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater); -@@ -2522,6 +2523,7 @@ public class PurpurWorldConfig { +@@ -2557,6 +2558,7 @@ public class PurpurWorldConfig { witherTakeDamageFromWater = getBoolean("mobs.wither.takes-damage-from-water", witherTakeDamageFromWater); witherCanRideVehicles = getBoolean("mobs.wither.can-ride-vehicles", witherCanRideVehicles); witherExplosionRadius = (float) getDouble("mobs.wither.explosion-radius", witherExplosionRadius); diff --git a/patches/server/0220-Conduit-behavior-configuration.patch b/patches/server/0220-Conduit-behavior-configuration.patch index 44b69d9b4..949b4b0e8 100644 --- a/patches/server/0220-Conduit-behavior-configuration.patch +++ b/patches/server/0220-Conduit-behavior-configuration.patch @@ -44,10 +44,10 @@ index 05eab04e4aec4151018f25b59f92ddbbb4c09f87..8db906e021ca57c7f2a1e7002647e5c5 } CraftEventFactory.blockDamage = null; diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 6b8b067c2554250049563c008dcf7f9b73ed89a8..660c326237efdb06d1610a9110fe3890f3f3e52c 100644 +index 0cff6adbaeba661cec9727cbbc32765dec33e3f3..1b2639f7d0995ef4cc1c02fbe02ce3d3711d348b 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2720,5 +2720,28 @@ public class PurpurWorldConfig { +@@ -2755,5 +2755,28 @@ public class PurpurWorldConfig { private void hungerSettings() { hungerStarvationDamage = (float) getDouble("hunger.starvation-damage", hungerStarvationDamage); } diff --git a/patches/server/0221-Cauldron-fill-chances.patch b/patches/server/0221-Cauldron-fill-chances.patch index 724b99804..8fe1f61e6 100644 --- a/patches/server/0221-Cauldron-fill-chances.patch +++ b/patches/server/0221-Cauldron-fill-chances.patch @@ -47,10 +47,10 @@ index ef15adf66ea994d15a7d2718dd3d22cd07c31f98..dd87e3efdeafb211c1e44f8dc3348830 if (dripChance < f1) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 660c326237efdb06d1610a9110fe3890f3f3e52c..65a0de10b7b263856bd475e92c8c05780e5be186 100644 +index 1b2639f7d0995ef4cc1c02fbe02ce3d3711d348b..35f5784bc147836f95e6136f1eed6ce228cfc920 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2743,5 +2743,16 @@ public class PurpurWorldConfig { +@@ -2778,5 +2778,16 @@ public class PurpurWorldConfig { }); conduitBlocks = conduitBlockList.toArray(Block[]::new); } diff --git a/patches/server/0223-Shulker-change-color-with-dye.patch b/patches/server/0223-Shulker-change-color-with-dye.patch index b5c433849..50508f349 100644 --- a/patches/server/0223-Shulker-change-color-with-dye.patch +++ b/patches/server/0223-Shulker-change-color-with-dye.patch @@ -47,10 +47,10 @@ index ada070d8e1a2d328c02455eb9e5ad056046bcd0a..691b59f784e34b061ea156a3236c09f2 @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index d6f587b981889684b9c3fcf1ed481d15c8e5fcf9..b8ae3b6b32741b8e756f74b2397423842494c4b1 100644 +index 80b9246d659543381ea378430c8bd154c9d92d72..c1d32420041d78aaf3ba5c5ba11191ed955578e1 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2090,6 +2090,7 @@ public class PurpurWorldConfig { +@@ -2107,6 +2107,7 @@ public class PurpurWorldConfig { public double shulkerSpawnFromBulletNearbyRange = 8.0D; public String shulkerSpawnFromBulletNearbyEquation = "(nearby - 1) / 5.0"; public boolean shulkerSpawnFromBulletRandomColor = false; @@ -58,7 +58,7 @@ index d6f587b981889684b9c3fcf1ed481d15c8e5fcf9..b8ae3b6b32741b8e756f74b239742384 private void shulkerSettings() { shulkerRidable = getBoolean("mobs.shulker.ridable", shulkerRidable); shulkerRidableInWater = getBoolean("mobs.shulker.ridable-in-water", shulkerRidableInWater); -@@ -2106,6 +2107,7 @@ public class PurpurWorldConfig { +@@ -2123,6 +2124,7 @@ public class PurpurWorldConfig { shulkerSpawnFromBulletNearbyRange = getDouble("mobs.shulker.spawn-from-bullet.nearby-range", shulkerSpawnFromBulletNearbyRange); shulkerSpawnFromBulletNearbyEquation = getString("mobs.shulker.spawn-from-bullet.nearby-equation", shulkerSpawnFromBulletNearbyEquation); shulkerSpawnFromBulletRandomColor = getBoolean("mobs.shulker.spawn-from-bullet.random-color", shulkerSpawnFromBulletRandomColor); diff --git a/patches/server/0229-Dolphins-naturally-aggressive-to-players-chance.patch b/patches/server/0229-Dolphins-naturally-aggressive-to-players-chance.patch index 72baf5f88..d22baabfb 100644 --- a/patches/server/0229-Dolphins-naturally-aggressive-to-players-chance.patch +++ b/patches/server/0229-Dolphins-naturally-aggressive-to-players-chance.patch @@ -47,10 +47,10 @@ index 1e95fa49a5dc8b756756924cbaf12d49ad33a274..89e3eec134868f727d776ee8144b2915 public static AttributeSupplier.Builder createAttributes() { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 58ba485716b6d2141a8aa202cbd049c1ba7a4a1d..e7757e0cf9f03b523ff60988998c018d13234633 100644 +index da7bace72794ae1188f18462f12e48a86b49ee5f..51c1560a9169f5faad90421134d33af13b272d50 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1182,6 +1182,7 @@ public class PurpurWorldConfig { +@@ -1191,6 +1191,7 @@ public class PurpurWorldConfig { public double dolphinMaxHealth = 10.0D; public boolean dolphinDisableTreasureSearching = false; public boolean dolphinTakeDamageFromWater = false; @@ -58,7 +58,7 @@ index 58ba485716b6d2141a8aa202cbd049c1ba7a4a1d..e7757e0cf9f03b523ff60988998c018d private void dolphinSettings() { dolphinRidable = getBoolean("mobs.dolphin.ridable", dolphinRidable); dolphinControllable = getBoolean("mobs.dolphin.controllable", dolphinControllable); -@@ -1196,6 +1197,7 @@ public class PurpurWorldConfig { +@@ -1205,6 +1206,7 @@ public class PurpurWorldConfig { dolphinMaxHealth = getDouble("mobs.dolphin.attributes.max_health", dolphinMaxHealth); dolphinDisableTreasureSearching = getBoolean("mobs.dolphin.disable-treasure-searching", dolphinDisableTreasureSearching); dolphinTakeDamageFromWater = getBoolean("mobs.dolphin.takes-damage-from-water", dolphinTakeDamageFromWater); diff --git a/patches/server/0230-Cows-naturally-aggressive-to-players-chance.patch b/patches/server/0230-Cows-naturally-aggressive-to-players-chance.patch index 270637025..e97e8be8c 100644 --- a/patches/server/0230-Cows-naturally-aggressive-to-players-chance.patch +++ b/patches/server/0230-Cows-naturally-aggressive-to-players-chance.patch @@ -59,10 +59,10 @@ index 00eec3f51e62858e7b85b3340e76bf66bfd4370f..b5002526f20fb8ae52783a6ba95ccd2d @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index e7757e0cf9f03b523ff60988998c018d13234633..302bcc8413d99be8d79c58c9ecabc5e2bd6e493b 100644 +index 51c1560a9169f5faad90421134d33af13b272d50..b88a695d1521ae3a2dbf1e1bba9f79a9e66abcda 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1131,7 +1131,14 @@ public class PurpurWorldConfig { +@@ -1140,7 +1140,14 @@ public class PurpurWorldConfig { public int cowFeedMushrooms = 0; public int cowBreedingTicks = 6000; public boolean cowTakeDamageFromWater = false; @@ -77,7 +77,7 @@ index e7757e0cf9f03b523ff60988998c018d13234633..302bcc8413d99be8d79c58c9ecabc5e2 cowRidable = getBoolean("mobs.cow.ridable", cowRidable); cowRidableInWater = getBoolean("mobs.cow.ridable-in-water", cowRidableInWater); cowControllable = getBoolean("mobs.cow.controllable", cowControllable); -@@ -1144,6 +1151,8 @@ public class PurpurWorldConfig { +@@ -1153,6 +1160,8 @@ public class PurpurWorldConfig { cowFeedMushrooms = getInt("mobs.cow.feed-mushrooms-for-mooshroom", cowFeedMushrooms); cowBreedingTicks = getInt("mobs.cow.breeding-delay-ticks", cowBreedingTicks); cowTakeDamageFromWater = getBoolean("mobs.cow.takes-damage-from-water", cowTakeDamageFromWater); diff --git a/patches/server/0232-Halloween-options-and-optimizations.patch b/patches/server/0232-Halloween-options-and-optimizations.patch index 1e7b7c708..3381a6092 100644 --- a/patches/server/0232-Halloween-options-and-optimizations.patch +++ b/patches/server/0232-Halloween-options-and-optimizations.patch @@ -60,10 +60,10 @@ index 0748babe61be5e5082132af6c4a3bc82612b70b3..5b7a6fa9692933ceb40c36e2c684a98d this.armorDropChances[EquipmentSlot.HEAD.getIndex()] = 0.0F; } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 7dc8ac8cd5b34a89595633ebbcbc9db006a37a56..72bd99b32cc56f78844cfe0903b644d0284037a1 100644 +index a7870ac5214814d5b109b1b9534adcac8f4ec671..07de23c955b523eb24b73062bed64484e63652e8 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1516,6 +1516,13 @@ public class PurpurWorldConfig { +@@ -1533,6 +1533,13 @@ public class PurpurWorldConfig { guardianTakeDamageFromWater = getBoolean("mobs.guardian.takes-damage-from-water", guardianTakeDamageFromWater); } diff --git a/patches/server/0237-Add-option-to-disable-zombie-villagers-cure.patch b/patches/server/0237-Add-option-to-disable-zombie-villagers-cure.patch index c005b3131..3678fb1b7 100644 --- a/patches/server/0237-Add-option-to-disable-zombie-villagers-cure.patch +++ b/patches/server/0237-Add-option-to-disable-zombie-villagers-cure.patch @@ -18,10 +18,10 @@ index 54b5749a5e40ed9042af1c4904afcdc4af157d82..07c2ea2d16c9df6107247507fcd09025 itemstack.shrink(1); } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 6395f1eac8250ccaf1606442173ae02f637fbd78..c1f7a9468bf6208ab6c8118515b4c007f038c2e1 100644 +index 15808105f0e0d233c6bb9b731100cd4aded944f4..65bcdead59468e94932866f4003d1b97b6288623 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2720,6 +2720,7 @@ public class PurpurWorldConfig { +@@ -2755,6 +2755,7 @@ public class PurpurWorldConfig { public boolean zombieVillagerTakeDamageFromWater = false; public int zombieVillagerCuringTimeMin = 3600; public int zombieVillagerCuringTimeMax = 6000; @@ -29,7 +29,7 @@ index 6395f1eac8250ccaf1606442173ae02f637fbd78..c1f7a9468bf6208ab6c8118515b4c007 private void zombieVillagerSettings() { zombieVillagerRidable = getBoolean("mobs.zombie_villager.ridable", zombieVillagerRidable); zombieVillagerRidableInWater = getBoolean("mobs.zombie_villager.ridable-in-water", zombieVillagerRidableInWater); -@@ -2737,6 +2738,7 @@ public class PurpurWorldConfig { +@@ -2772,6 +2773,7 @@ public class PurpurWorldConfig { zombieVillagerTakeDamageFromWater = getBoolean("mobs.zombie_villager.takes-damage-from-water", zombieVillagerTakeDamageFromWater); zombieVillagerCuringTimeMin = getInt("mobs.zombie_villager.curing_time.min", zombieVillagerCuringTimeMin); zombieVillagerCuringTimeMax = getInt("mobs.zombie_villager.curing_time.max", zombieVillagerCuringTimeMax); diff --git a/patches/server/0241-Mobs-always-drop-experience.patch b/patches/server/0241-Mobs-always-drop-experience.patch index e0b0cc7e9..5ea4063e5 100644 --- a/patches/server/0241-Mobs-always-drop-experience.patch +++ b/patches/server/0241-Mobs-always-drop-experience.patch @@ -37,7 +37,7 @@ index a851aaf84085c9bd79e933246bb2c79e435ab0f1..1436f9f62ce20b39c5ae2425c2fe47f5 @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 e8302e054b74ba6793b4b0928f0e87edb645d450..dcffd24a40766a18e9f70753dd95dff88330cb30 100644 +index a51fd1e4e6fb816f544112249e7f7192b334b255..4b9d13fb36d0e35f1cc7a5d95b26dc5f8ded0d6a 100644 --- a/src/main/java/net/minecraft/world/entity/animal/Bee.java +++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java @@ -229,6 +229,11 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal { @@ -549,10 +549,10 @@ index 6d1938f1cbad394f218b36ec8958d5e7ba6623f7..215c2a75fc53e558a5d804055138ee0f 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 5d567d97ce0be0728e538055ce6349a8861abddb..b5116c5450cc06492aceffa011b17246d8fc6cab 100644 +index 0dd31e45252d54b8bfa3645b25c984de30934a0e..f2dde5fadb829207bcd6167cb5da9b22a3917978 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 -@@ -237,6 +237,11 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob +@@ -249,6 +249,11 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob public void setSummoner(@Nullable java.util.UUID summoner) { this.summoner = summoner; } @@ -1157,13 +1157,13 @@ index 8d6930868a42b9fc98d7672bff433ec50d36999e..53bebecd30fee7613af73901b3aa9961 @Override diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6b5e61398 100644 +index e200eb02abaaff75195532193b5499e04545d18b..fe167bf81997f5657b0efcc01c302bcaa222d5fc 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1007,12 +1007,14 @@ public class PurpurWorldConfig { - public boolean axolotlControllable = true; +@@ -1016,12 +1016,14 @@ public class PurpurWorldConfig { public double axolotlMaxHealth = 14.0D; public int axolotlBreedingTicks = 6000; + public boolean axolotlTakeDamageFromWater = false; + public boolean axolotlAlwaysDropExp = false; private void axolotlSettings() { axolotlRidable = getBoolean("mobs.axolotl.ridable", axolotlRidable); @@ -1175,7 +1175,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean batRidable = false; -@@ -1028,6 +1030,7 @@ public class PurpurWorldConfig { +@@ -1037,6 +1039,7 @@ public class PurpurWorldConfig { public double batArmorToughness = 0.0D; public double batAttackKnockback = 0.0D; public boolean batTakeDamageFromWater = false; @@ -1183,7 +1183,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void batSettings() { batRidable = getBoolean("mobs.bat.ridable", batRidable); batRidableInWater = getBoolean("mobs.bat.ridable-in-water", batRidableInWater); -@@ -1040,6 +1043,7 @@ public class PurpurWorldConfig { +@@ -1049,6 +1052,7 @@ public class PurpurWorldConfig { } batMaxHealth = getDouble("mobs.bat.attributes.max_health", batMaxHealth); batTakeDamageFromWater = getBoolean("mobs.bat.takes-damage-from-water", batTakeDamageFromWater); @@ -1191,7 +1191,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean beeRidable = false; -@@ -1051,6 +1055,7 @@ public class PurpurWorldConfig { +@@ -1060,6 +1064,7 @@ public class PurpurWorldConfig { public boolean beeTakeDamageFromWater = false; public boolean beeCanWorkAtNight = false; public boolean beeCanWorkInRain = false; @@ -1199,7 +1199,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void beeSettings() { beeRidable = getBoolean("mobs.bee.ridable", beeRidable); beeRidableInWater = getBoolean("mobs.bee.ridable-in-water", beeRidableInWater); -@@ -1066,6 +1071,7 @@ public class PurpurWorldConfig { +@@ -1075,6 +1080,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); @@ -1207,7 +1207,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean blazeRidable = false; -@@ -1074,6 +1080,7 @@ public class PurpurWorldConfig { +@@ -1083,6 +1089,7 @@ public class PurpurWorldConfig { public double blazeMaxY = 320D; public double blazeMaxHealth = 20.0D; public boolean blazeTakeDamageFromWater = true; @@ -1215,7 +1215,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void blazeSettings() { blazeRidable = getBoolean("mobs.blaze.ridable", blazeRidable); blazeRidableInWater = getBoolean("mobs.blaze.ridable-in-water", blazeRidableInWater); -@@ -1086,6 +1093,7 @@ public class PurpurWorldConfig { +@@ -1095,6 +1102,7 @@ public class PurpurWorldConfig { } blazeMaxHealth = getDouble("mobs.blaze.attributes.max_health", blazeMaxHealth); blazeTakeDamageFromWater = getBoolean("mobs.blaze.takes-damage-from-water", blazeTakeDamageFromWater); @@ -1223,7 +1223,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean catRidable = false; -@@ -1098,6 +1106,7 @@ public class PurpurWorldConfig { +@@ -1107,6 +1115,7 @@ public class PurpurWorldConfig { public int catBreedingTicks = 6000; public DyeColor catDefaultCollarColor = DyeColor.RED; public boolean catTakeDamageFromWater = false; @@ -1231,7 +1231,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void catSettings() { catRidable = getBoolean("mobs.cat.ridable", catRidable); catRidableInWater = getBoolean("mobs.cat.ridable-in-water", catRidableInWater); -@@ -1118,6 +1127,7 @@ public class PurpurWorldConfig { +@@ -1127,6 +1136,7 @@ public class PurpurWorldConfig { catDefaultCollarColor = DyeColor.RED; } catTakeDamageFromWater = getBoolean("mobs.cat.takes-damage-from-water", catTakeDamageFromWater); @@ -1239,7 +1239,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean caveSpiderRidable = false; -@@ -1125,6 +1135,7 @@ public class PurpurWorldConfig { +@@ -1134,6 +1144,7 @@ public class PurpurWorldConfig { public boolean caveSpiderControllable = true; public double caveSpiderMaxHealth = 12.0D; public boolean caveSpiderTakeDamageFromWater = false; @@ -1247,7 +1247,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void caveSpiderSettings() { caveSpiderRidable = getBoolean("mobs.cave_spider.ridable", caveSpiderRidable); caveSpiderRidableInWater = getBoolean("mobs.cave_spider.ridable-in-water", caveSpiderRidableInWater); -@@ -1136,6 +1147,7 @@ public class PurpurWorldConfig { +@@ -1145,6 +1156,7 @@ public class PurpurWorldConfig { } caveSpiderMaxHealth = getDouble("mobs.cave_spider.attributes.max_health", caveSpiderMaxHealth); caveSpiderTakeDamageFromWater = getBoolean("mobs.cave_spider.takes-damage-from-water", caveSpiderTakeDamageFromWater); @@ -1255,7 +1255,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean chickenRidable = false; -@@ -1145,6 +1157,7 @@ public class PurpurWorldConfig { +@@ -1154,6 +1166,7 @@ public class PurpurWorldConfig { public boolean chickenRetaliate = false; public int chickenBreedingTicks = 6000; public boolean chickenTakeDamageFromWater = false; @@ -1263,7 +1263,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void chickenSettings() { chickenRidable = getBoolean("mobs.chicken.ridable", chickenRidable); chickenRidableInWater = getBoolean("mobs.chicken.ridable-in-water", chickenRidableInWater); -@@ -1158,12 +1171,14 @@ public class PurpurWorldConfig { +@@ -1167,12 +1180,14 @@ 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); @@ -1278,7 +1278,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void codSettings() { codRidable = getBoolean("mobs.cod.ridable", codRidable); codControllable = getBoolean("mobs.cod.controllable", codControllable); -@@ -1174,6 +1189,7 @@ public class PurpurWorldConfig { +@@ -1183,6 +1198,7 @@ public class PurpurWorldConfig { } codMaxHealth = getDouble("mobs.cod.attributes.max_health", codMaxHealth); codTakeDamageFromWater = getBoolean("mobs.cod.takes-damage-from-water", codTakeDamageFromWater); @@ -1286,7 +1286,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean cowRidable = false; -@@ -1185,6 +1201,7 @@ public class PurpurWorldConfig { +@@ -1194,6 +1210,7 @@ public class PurpurWorldConfig { public boolean cowTakeDamageFromWater = false; public double cowNaturallyAggressiveToPlayersChance = 0.0D; public double cowNaturallyAggressiveToPlayersDamage = 2.0D; @@ -1294,7 +1294,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void cowSettings() { if (PurpurConfig.version < 22) { double oldValue = getDouble("mobs.cow.naturally-aggressive-to-players-chance", cowNaturallyAggressiveToPlayersChance); -@@ -1205,6 +1222,7 @@ public class PurpurWorldConfig { +@@ -1214,6 +1231,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); @@ -1302,7 +1302,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean creeperRidable = false; -@@ -1217,6 +1235,7 @@ public class PurpurWorldConfig { +@@ -1226,6 +1244,7 @@ public class PurpurWorldConfig { public boolean creeperTakeDamageFromWater = false; public boolean creeperExplodeWhenKilled = false; public boolean creeperHealthRadius = false; @@ -1310,7 +1310,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void creeperSettings() { creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable); creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater); -@@ -1233,6 +1252,7 @@ public class PurpurWorldConfig { +@@ -1242,6 +1261,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); @@ -1318,7 +1318,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean dolphinRidable = false; -@@ -1244,6 +1264,7 @@ public class PurpurWorldConfig { +@@ -1253,6 +1273,7 @@ public class PurpurWorldConfig { public boolean dolphinDisableTreasureSearching = false; public boolean dolphinTakeDamageFromWater = false; public double dolphinNaturallyAggressiveToPlayersChance = 0.0D; @@ -1326,7 +1326,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void dolphinSettings() { dolphinRidable = getBoolean("mobs.dolphin.ridable", dolphinRidable); dolphinControllable = getBoolean("mobs.dolphin.controllable", dolphinControllable); -@@ -1259,6 +1280,7 @@ public class PurpurWorldConfig { +@@ -1268,6 +1289,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); @@ -1334,7 +1334,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean donkeyRidableInWater = false; -@@ -1270,6 +1292,7 @@ public class PurpurWorldConfig { +@@ -1279,6 +1301,7 @@ public class PurpurWorldConfig { public double donkeyMovementSpeedMax = 0.175D; public int donkeyBreedingTicks = 6000; public boolean donkeyTakeDamageFromWater = false; @@ -1342,7 +1342,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void donkeySettings() { donkeyRidableInWater = getBoolean("mobs.donkey.ridable-in-water", donkeyRidableInWater); if (PurpurConfig.version < 10) { -@@ -1287,6 +1310,7 @@ public class PurpurWorldConfig { +@@ -1296,6 +1319,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); @@ -1350,7 +1350,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean drownedRidable = false; -@@ -1299,6 +1323,7 @@ public class PurpurWorldConfig { +@@ -1308,6 +1332,7 @@ public class PurpurWorldConfig { public boolean drownedJockeyTryExistingChickens = true; public boolean drownedTakeDamageFromWater = false; public boolean drownedBreakDoors = false; @@ -1358,7 +1358,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void drownedSettings() { drownedRidable = getBoolean("mobs.drowned.ridable", drownedRidable); drownedRidableInWater = getBoolean("mobs.drowned.ridable-in-water", drownedRidableInWater); -@@ -1315,12 +1340,14 @@ public class PurpurWorldConfig { +@@ -1324,12 +1349,14 @@ 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); @@ -1373,7 +1373,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void elderGuardianSettings() { elderGuardianRidable = getBoolean("mobs.elder_guardian.ridable", elderGuardianRidable); elderGuardianControllable = getBoolean("mobs.elder_guardian.controllable", elderGuardianControllable); -@@ -1331,6 +1358,7 @@ public class PurpurWorldConfig { +@@ -1340,6 +1367,7 @@ public class PurpurWorldConfig { } elderGuardianMaxHealth = getDouble("mobs.elder_guardian.attributes.max_health", elderGuardianMaxHealth); elderGuardianTakeDamageFromWater = getBoolean("mobs.elder_guardian.takes-damage-from-water", elderGuardianTakeDamageFromWater); @@ -1381,7 +1381,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean enderDragonRidable = false; -@@ -1376,6 +1404,7 @@ public class PurpurWorldConfig { +@@ -1385,6 +1413,7 @@ public class PurpurWorldConfig { public boolean endermanIgnorePlayerDragonHead = false; public boolean endermanDisableStareAggro = false; public boolean endermanIgnoreProjectiles = false; @@ -1389,7 +1389,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void endermanSettings() { endermanRidable = getBoolean("mobs.enderman.ridable", endermanRidable); endermanRidableInWater = getBoolean("mobs.enderman.ridable-in-water", endermanRidableInWater); -@@ -1399,6 +1428,7 @@ public class PurpurWorldConfig { +@@ -1408,6 +1437,7 @@ 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); @@ -1397,7 +1397,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean endermiteRidable = false; -@@ -1406,6 +1436,7 @@ public class PurpurWorldConfig { +@@ -1415,6 +1445,7 @@ public class PurpurWorldConfig { public boolean endermiteControllable = true; public double endermiteMaxHealth = 8.0D; public boolean endermiteTakeDamageFromWater = false; @@ -1405,7 +1405,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void endermiteSettings() { endermiteRidable = getBoolean("mobs.endermite.ridable", endermiteRidable); endermiteRidableInWater = getBoolean("mobs.endermite.ridable-in-water", endermiteRidableInWater); -@@ -1417,6 +1448,7 @@ public class PurpurWorldConfig { +@@ -1426,6 +1457,7 @@ public class PurpurWorldConfig { } endermiteMaxHealth = getDouble("mobs.endermite.attributes.max_health", endermiteMaxHealth); endermiteTakeDamageFromWater = getBoolean("mobs.endermite.takes-damage-from-water", endermiteTakeDamageFromWater); @@ -1413,7 +1413,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean evokerRidable = false; -@@ -1425,6 +1457,7 @@ public class PurpurWorldConfig { +@@ -1434,6 +1466,7 @@ public class PurpurWorldConfig { public double evokerMaxHealth = 24.0D; public boolean evokerBypassMobGriefing = false; public boolean evokerTakeDamageFromWater = false; @@ -1421,7 +1421,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void evokerSettings() { evokerRidable = getBoolean("mobs.evoker.ridable", evokerRidable); evokerRidableInWater = getBoolean("mobs.evoker.ridable-in-water", evokerRidableInWater); -@@ -1437,6 +1470,7 @@ public class PurpurWorldConfig { +@@ -1446,6 +1479,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); @@ -1429,7 +1429,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean foxRidable = false; -@@ -1447,6 +1481,7 @@ public class PurpurWorldConfig { +@@ -1456,6 +1490,7 @@ public class PurpurWorldConfig { public int foxBreedingTicks = 6000; public boolean foxBypassMobGriefing = false; public boolean foxTakeDamageFromWater = false; @@ -1437,15 +1437,15 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void foxSettings() { foxRidable = getBoolean("mobs.fox.ridable", foxRidable); foxRidableInWater = getBoolean("mobs.fox.ridable-in-water", foxRidableInWater); -@@ -1461,6 +1496,7 @@ public class PurpurWorldConfig { +@@ -1470,6 +1505,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 int frogBreedingTicks = 6000; -@@ -1474,6 +1510,7 @@ public class PurpurWorldConfig { + public boolean frogRidable = false; +@@ -1491,6 +1527,7 @@ public class PurpurWorldConfig { public double ghastMaxY = 320D; public double ghastMaxHealth = 10.0D; public boolean ghastTakeDamageFromWater = false; @@ -1453,7 +1453,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void ghastSettings() { ghastRidable = getBoolean("mobs.ghast.ridable", ghastRidable); ghastRidableInWater = getBoolean("mobs.ghast.ridable-in-water", ghastRidableInWater); -@@ -1486,6 +1523,7 @@ public class PurpurWorldConfig { +@@ -1503,6 +1540,7 @@ public class PurpurWorldConfig { } ghastMaxHealth = getDouble("mobs.ghast.attributes.max_health", ghastMaxHealth); ghastTakeDamageFromWater = getBoolean("mobs.ghast.takes-damage-from-water", ghastTakeDamageFromWater); @@ -1461,7 +1461,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean giantRidable = false; -@@ -1499,6 +1537,7 @@ public class PurpurWorldConfig { +@@ -1516,6 +1554,7 @@ public class PurpurWorldConfig { public boolean giantHaveAI = false; public boolean giantHaveHostileAI = false; public boolean giantTakeDamageFromWater = false; @@ -1469,7 +1469,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void giantSettings() { giantRidable = getBoolean("mobs.giant.ridable", giantRidable); giantRidableInWater = getBoolean("mobs.giant.ridable-in-water", giantRidableInWater); -@@ -1520,6 +1559,7 @@ public class PurpurWorldConfig { +@@ -1537,6 +1576,7 @@ 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); @@ -1477,7 +1477,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean glowSquidRidable = false; -@@ -1527,12 +1567,14 @@ public class PurpurWorldConfig { +@@ -1544,12 +1584,14 @@ public class PurpurWorldConfig { public double glowSquidMaxHealth = 10.0D; public boolean glowSquidsCanFly = false; public boolean glowSquidTakeDamageFromWater = false; @@ -1492,7 +1492,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean goatRidable = false; -@@ -1541,6 +1583,7 @@ public class PurpurWorldConfig { +@@ -1558,6 +1600,7 @@ public class PurpurWorldConfig { public double goatMaxHealth = 10.0D; public int goatBreedingTicks = 6000; public boolean goatTakeDamageFromWater = false; @@ -1500,7 +1500,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void goatSettings() { goatRidable = getBoolean("mobs.goat.ridable", goatRidable); goatRidableInWater = getBoolean("mobs.goat.ridable-in-water", goatRidableInWater); -@@ -1548,12 +1591,14 @@ public class PurpurWorldConfig { +@@ -1565,12 +1608,14 @@ public class PurpurWorldConfig { 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); @@ -1515,7 +1515,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void guardianSettings() { guardianRidable = getBoolean("mobs.guardian.ridable", guardianRidable); guardianControllable = getBoolean("mobs.guardian.controllable", guardianControllable); -@@ -1564,6 +1609,7 @@ public class PurpurWorldConfig { +@@ -1581,6 +1626,7 @@ public class PurpurWorldConfig { } guardianMaxHealth = getDouble("mobs.guardian.attributes.max_health", guardianMaxHealth); guardianTakeDamageFromWater = getBoolean("mobs.guardian.takes-damage-from-water", guardianTakeDamageFromWater); @@ -1523,7 +1523,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean forceHalloweenSeason = false; -@@ -1579,6 +1625,7 @@ public class PurpurWorldConfig { +@@ -1596,6 +1642,7 @@ public class PurpurWorldConfig { public double hoglinMaxHealth = 40.0D; public int hoglinBreedingTicks = 6000; public boolean hoglinTakeDamageFromWater = false; @@ -1531,7 +1531,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void hoglinSettings() { hoglinRidable = getBoolean("mobs.hoglin.ridable", hoglinRidable); hoglinRidableInWater = getBoolean("mobs.hoglin.ridable-in-water", hoglinRidableInWater); -@@ -1591,6 +1638,7 @@ public class PurpurWorldConfig { +@@ -1608,6 +1655,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); @@ -1539,7 +1539,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean horseRidableInWater = false; -@@ -1603,6 +1651,7 @@ public class PurpurWorldConfig { +@@ -1620,6 +1668,7 @@ public class PurpurWorldConfig { public int horseBreedingTicks = 6000; public boolean horseTakeDamageFromWater = false; public boolean horseStandWithRider = true; @@ -1547,7 +1547,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void horseSettings() { horseRidableInWater = getBoolean("mobs.horse.ridable-in-water", horseRidableInWater); if (PurpurConfig.version < 10) { -@@ -1621,6 +1670,7 @@ public class PurpurWorldConfig { +@@ -1638,6 +1687,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); @@ -1555,7 +1555,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean huskRidable = false; -@@ -1632,6 +1682,7 @@ public class PurpurWorldConfig { +@@ -1649,6 +1699,7 @@ public class PurpurWorldConfig { public double huskJockeyChance = 0.05D; public boolean huskJockeyTryExistingChickens = true; public boolean huskTakeDamageFromWater = false; @@ -1563,7 +1563,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void huskSettings() { huskRidable = getBoolean("mobs.husk.ridable", huskRidable); huskRidableInWater = getBoolean("mobs.husk.ridable-in-water", huskRidableInWater); -@@ -1647,6 +1698,7 @@ public class PurpurWorldConfig { +@@ -1664,6 +1715,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); @@ -1571,7 +1571,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean illusionerRidable = false; -@@ -1656,6 +1708,7 @@ public class PurpurWorldConfig { +@@ -1673,6 +1725,7 @@ public class PurpurWorldConfig { public double illusionerFollowRange = 18.0D; public double illusionerMaxHealth = 32.0D; public boolean illusionerTakeDamageFromWater = false; @@ -1579,7 +1579,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void illusionerSettings() { illusionerRidable = getBoolean("mobs.illusioner.ridable", illusionerRidable); illusionerRidableInWater = getBoolean("mobs.illusioner.ridable-in-water", illusionerRidableInWater); -@@ -1673,6 +1726,7 @@ public class PurpurWorldConfig { +@@ -1690,6 +1743,7 @@ public class PurpurWorldConfig { } illusionerMaxHealth = getDouble("mobs.illusioner.attributes.max_health", illusionerMaxHealth); illusionerTakeDamageFromWater = getBoolean("mobs.illusioner.takes-damage-from-water", illusionerTakeDamageFromWater); @@ -1587,7 +1587,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean ironGolemRidable = false; -@@ -1683,6 +1737,7 @@ public class PurpurWorldConfig { +@@ -1700,6 +1754,7 @@ public class PurpurWorldConfig { public boolean ironGolemTakeDamageFromWater = false; public boolean ironGolemPoppyCalm = false; public boolean ironGolemHealCalm = false; @@ -1595,7 +1595,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void ironGolemSettings() { ironGolemRidable = getBoolean("mobs.iron_golem.ridable", ironGolemRidable); ironGolemRidableInWater = getBoolean("mobs.iron_golem.ridable-in-water", ironGolemRidableInWater); -@@ -1697,6 +1752,7 @@ public class PurpurWorldConfig { +@@ -1714,6 +1769,7 @@ public class PurpurWorldConfig { ironGolemTakeDamageFromWater = getBoolean("mobs.iron_golem.takes-damage-from-water", ironGolemTakeDamageFromWater); ironGolemPoppyCalm = getBoolean("mobs.iron_golem.poppy-calms-anger", ironGolemPoppyCalm); ironGolemHealCalm = getBoolean("mobs.iron_golem.healing-calms-anger", ironGolemHealCalm); @@ -1603,7 +1603,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean llamaRidable = false; -@@ -1711,6 +1767,7 @@ public class PurpurWorldConfig { +@@ -1728,6 +1784,7 @@ public class PurpurWorldConfig { public int llamaBreedingTicks = 6000; public boolean llamaTakeDamageFromWater = false; public boolean llamaJoinCaravans = true; @@ -1611,7 +1611,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void llamaSettings() { llamaRidable = getBoolean("mobs.llama.ridable", llamaRidable); llamaRidableInWater = getBoolean("mobs.llama.ridable-in-water", llamaRidableInWater); -@@ -1731,6 +1788,7 @@ public class PurpurWorldConfig { +@@ -1748,6 +1805,7 @@ 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); @@ -1619,7 +1619,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean magmaCubeRidable = false; -@@ -1741,6 +1799,7 @@ public class PurpurWorldConfig { +@@ -1758,6 +1816,7 @@ public class PurpurWorldConfig { public Map magmaCubeMaxHealthCache = new HashMap<>(); public Map magmaCubeAttackDamageCache = new HashMap<>(); public boolean magmaCubeTakeDamageFromWater = false; @@ -1627,7 +1627,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void magmaCubeSettings() { magmaCubeRidable = getBoolean("mobs.magma_cube.ridable", magmaCubeRidable); magmaCubeRidableInWater = getBoolean("mobs.magma_cube.ridable-in-water", magmaCubeRidableInWater); -@@ -1755,6 +1814,7 @@ public class PurpurWorldConfig { +@@ -1772,6 +1831,7 @@ public class PurpurWorldConfig { magmaCubeMaxHealthCache.clear(); magmaCubeAttackDamageCache.clear(); magmaCubeTakeDamageFromWater = getBoolean("mobs.magma_cube.takes-damage-from-water", magmaCubeTakeDamageFromWater); @@ -1635,7 +1635,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean mooshroomRidable = false; -@@ -1763,6 +1823,7 @@ public class PurpurWorldConfig { +@@ -1780,6 +1840,7 @@ public class PurpurWorldConfig { public double mooshroomMaxHealth = 10.0D; public int mooshroomBreedingTicks = 6000; public boolean mooshroomTakeDamageFromWater = false; @@ -1643,7 +1643,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void mooshroomSettings() { mooshroomRidable = getBoolean("mobs.mooshroom.ridable", mooshroomRidable); mooshroomRidableInWater = getBoolean("mobs.mooshroom.ridable-in-water", mooshroomRidableInWater); -@@ -1775,6 +1836,7 @@ public class PurpurWorldConfig { +@@ -1792,6 +1853,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); @@ -1651,7 +1651,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean muleRidableInWater = false; -@@ -1786,6 +1848,7 @@ public class PurpurWorldConfig { +@@ -1803,6 +1865,7 @@ public class PurpurWorldConfig { public double muleMovementSpeedMax = 0.175D; public int muleBreedingTicks = 6000; public boolean muleTakeDamageFromWater = false; @@ -1659,7 +1659,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void muleSettings() { muleRidableInWater = getBoolean("mobs.mule.ridable-in-water", muleRidableInWater); if (PurpurConfig.version < 10) { -@@ -1803,6 +1866,7 @@ public class PurpurWorldConfig { +@@ -1820,6 +1883,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); @@ -1667,7 +1667,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean ocelotRidable = false; -@@ -1811,6 +1875,7 @@ public class PurpurWorldConfig { +@@ -1828,6 +1892,7 @@ public class PurpurWorldConfig { public double ocelotMaxHealth = 10.0D; public int ocelotBreedingTicks = 6000; public boolean ocelotTakeDamageFromWater = false; @@ -1675,7 +1675,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void ocelotSettings() { ocelotRidable = getBoolean("mobs.ocelot.ridable", ocelotRidable); ocelotRidableInWater = getBoolean("mobs.ocelot.ridable-in-water", ocelotRidableInWater); -@@ -1823,6 +1888,7 @@ public class PurpurWorldConfig { +@@ -1840,6 +1905,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); @@ -1683,7 +1683,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean pandaRidable = false; -@@ -1831,6 +1897,7 @@ public class PurpurWorldConfig { +@@ -1848,6 +1914,7 @@ public class PurpurWorldConfig { public double pandaMaxHealth = 20.0D; public int pandaBreedingTicks = 6000; public boolean pandaTakeDamageFromWater = false; @@ -1691,7 +1691,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void pandaSettings() { pandaRidable = getBoolean("mobs.panda.ridable", pandaRidable); pandaRidableInWater = getBoolean("mobs.panda.ridable-in-water", pandaRidableInWater); -@@ -1843,6 +1910,7 @@ public class PurpurWorldConfig { +@@ -1860,6 +1927,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); @@ -1699,7 +1699,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean parrotRidable = false; -@@ -1852,6 +1920,7 @@ public class PurpurWorldConfig { +@@ -1869,6 +1937,7 @@ public class PurpurWorldConfig { public double parrotMaxHealth = 6.0D; public boolean parrotTakeDamageFromWater = false; public boolean parrotBreedable = false; @@ -1707,7 +1707,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void parrotSettings() { parrotRidable = getBoolean("mobs.parrot.ridable", parrotRidable); parrotRidableInWater = getBoolean("mobs.parrot.ridable-in-water", parrotRidableInWater); -@@ -1865,6 +1934,7 @@ public class PurpurWorldConfig { +@@ -1882,6 +1951,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); @@ -1715,7 +1715,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean phantomRidable = false; -@@ -1898,6 +1968,7 @@ public class PurpurWorldConfig { +@@ -1915,6 +1985,7 @@ public class PurpurWorldConfig { public boolean phantomBurnInDaylight = true; public boolean phantomFlamesOnSwoop = false; public boolean phantomTakeDamageFromWater = false; @@ -1723,7 +1723,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void phantomSettings() { phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable); phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater); -@@ -1939,6 +2010,7 @@ public class PurpurWorldConfig { +@@ -1956,6 +2027,7 @@ public class PurpurWorldConfig { phantomIgnorePlayersWithTorch = getBoolean("mobs.phantom.ignore-players-with-torch", phantomIgnorePlayersWithTorch); phantomFlamesOnSwoop = getBoolean("mobs.phantom.flames-on-swoop", phantomFlamesOnSwoop); phantomTakeDamageFromWater = getBoolean("mobs.phantom.takes-damage-from-water", phantomTakeDamageFromWater); @@ -1731,7 +1731,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean pigRidable = false; -@@ -1948,6 +2020,7 @@ public class PurpurWorldConfig { +@@ -1965,6 +2037,7 @@ public class PurpurWorldConfig { public boolean pigGiveSaddleBack = false; public int pigBreedingTicks = 6000; public boolean pigTakeDamageFromWater = false; @@ -1739,7 +1739,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void pigSettings() { pigRidable = getBoolean("mobs.pig.ridable", pigRidable); pigRidableInWater = getBoolean("mobs.pig.ridable-in-water", pigRidableInWater); -@@ -1961,6 +2034,7 @@ public class PurpurWorldConfig { +@@ -1978,6 +2051,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); @@ -1747,7 +1747,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean piglinRidable = false; -@@ -1970,6 +2044,7 @@ public class PurpurWorldConfig { +@@ -1987,6 +2061,7 @@ public class PurpurWorldConfig { public boolean piglinBypassMobGriefing = false; public boolean piglinTakeDamageFromWater = false; public int piglinPortalSpawnModifier = 2000; @@ -1755,7 +1755,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void piglinSettings() { piglinRidable = getBoolean("mobs.piglin.ridable", piglinRidable); piglinRidableInWater = getBoolean("mobs.piglin.ridable-in-water", piglinRidableInWater); -@@ -1983,6 +2058,7 @@ public class PurpurWorldConfig { +@@ -2000,6 +2075,7 @@ 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); @@ -1763,7 +1763,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean piglinBruteRidable = false; -@@ -1990,6 +2066,7 @@ public class PurpurWorldConfig { +@@ -2007,6 +2083,7 @@ public class PurpurWorldConfig { public boolean piglinBruteControllable = true; public double piglinBruteMaxHealth = 50.0D; public boolean piglinBruteTakeDamageFromWater = false; @@ -1771,7 +1771,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void piglinBruteSettings() { piglinBruteRidable = getBoolean("mobs.piglin_brute.ridable", piglinBruteRidable); piglinBruteRidableInWater = getBoolean("mobs.piglin_brute.ridable-in-water", piglinBruteRidableInWater); -@@ -2001,6 +2078,7 @@ public class PurpurWorldConfig { +@@ -2018,6 +2095,7 @@ public class PurpurWorldConfig { } piglinBruteMaxHealth = getDouble("mobs.piglin_brute.attributes.max_health", piglinBruteMaxHealth); piglinBruteTakeDamageFromWater = getBoolean("mobs.piglin_brute.takes-damage-from-water", piglinBruteTakeDamageFromWater); @@ -1779,7 +1779,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean pillagerRidable = false; -@@ -2009,6 +2087,7 @@ public class PurpurWorldConfig { +@@ -2026,6 +2104,7 @@ public class PurpurWorldConfig { public double pillagerMaxHealth = 24.0D; public boolean pillagerBypassMobGriefing = false; public boolean pillagerTakeDamageFromWater = false; @@ -1787,7 +1787,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void pillagerSettings() { pillagerRidable = getBoolean("mobs.pillager.ridable", pillagerRidable); pillagerRidableInWater = getBoolean("mobs.pillager.ridable-in-water", pillagerRidableInWater); -@@ -2021,6 +2100,7 @@ public class PurpurWorldConfig { +@@ -2038,6 +2117,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); @@ -1795,7 +1795,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean polarBearRidable = false; -@@ -2031,6 +2111,7 @@ public class PurpurWorldConfig { +@@ -2048,6 +2128,7 @@ public class PurpurWorldConfig { public Item polarBearBreedableItem = null; public int polarBearBreedingTicks = 6000; public boolean polarBearTakeDamageFromWater = false; @@ -1803,7 +1803,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void polarBearSettings() { polarBearRidable = getBoolean("mobs.polar_bear.ridable", polarBearRidable); polarBearRidableInWater = getBoolean("mobs.polar_bear.ridable-in-water", polarBearRidableInWater); -@@ -2046,12 +2127,14 @@ public class PurpurWorldConfig { +@@ -2063,12 +2144,14 @@ 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); @@ -1818,7 +1818,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void pufferfishSettings() { pufferfishRidable = getBoolean("mobs.pufferfish.ridable", pufferfishRidable); pufferfishControllable = getBoolean("mobs.pufferfish.controllable", pufferfishControllable); -@@ -2062,6 +2145,7 @@ public class PurpurWorldConfig { +@@ -2079,6 +2162,7 @@ public class PurpurWorldConfig { } pufferfishMaxHealth = getDouble("mobs.pufferfish.attributes.max_health", pufferfishMaxHealth); pufferfishTakeDamageFromWater = getBoolean("mobs.pufferfish.takes-damage-from-water", pufferfishTakeDamageFromWater); @@ -1826,7 +1826,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean rabbitRidable = false; -@@ -2073,6 +2157,7 @@ public class PurpurWorldConfig { +@@ -2090,6 +2174,7 @@ public class PurpurWorldConfig { public int rabbitBreedingTicks = 6000; public boolean rabbitBypassMobGriefing = false; public boolean rabbitTakeDamageFromWater = false; @@ -1834,7 +1834,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void rabbitSettings() { rabbitRidable = getBoolean("mobs.rabbit.ridable", rabbitRidable); rabbitRidableInWater = getBoolean("mobs.rabbit.ridable-in-water", rabbitRidableInWater); -@@ -2088,6 +2173,7 @@ public class PurpurWorldConfig { +@@ -2105,6 +2190,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); @@ -1842,7 +1842,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean ravagerRidable = false; -@@ -2097,6 +2183,7 @@ public class PurpurWorldConfig { +@@ -2114,6 +2200,7 @@ public class PurpurWorldConfig { public boolean ravagerBypassMobGriefing = false; public boolean ravagerTakeDamageFromWater = false; public List ravagerGriefableBlocks = new ArrayList<>(); @@ -1850,7 +1850,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void ravagerSettings() { ravagerRidable = getBoolean("mobs.ravager.ridable", ravagerRidable); ravagerRidableInWater = getBoolean("mobs.ravager.ridable-in-water", ravagerRidableInWater); -@@ -2126,12 +2213,14 @@ public class PurpurWorldConfig { +@@ -2143,12 +2230,14 @@ public class PurpurWorldConfig { ravagerGriefableBlocks.add(block); } }); @@ -1865,7 +1865,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void salmonSettings() { salmonRidable = getBoolean("mobs.salmon.ridable", salmonRidable); salmonControllable = getBoolean("mobs.salmon.controllable", salmonControllable); -@@ -2142,6 +2231,7 @@ public class PurpurWorldConfig { +@@ -2159,6 +2248,7 @@ public class PurpurWorldConfig { } salmonMaxHealth = getDouble("mobs.salmon.attributes.max_health", salmonMaxHealth); salmonTakeDamageFromWater = getBoolean("mobs.salmon.takes-damage-from-water", salmonTakeDamageFromWater); @@ -1873,7 +1873,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean sheepRidable = false; -@@ -2151,6 +2241,7 @@ public class PurpurWorldConfig { +@@ -2168,6 +2258,7 @@ public class PurpurWorldConfig { public int sheepBreedingTicks = 6000; public boolean sheepBypassMobGriefing = false; public boolean sheepTakeDamageFromWater = false; @@ -1881,7 +1881,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void sheepSettings() { sheepRidable = getBoolean("mobs.sheep.ridable", sheepRidable); sheepRidableInWater = getBoolean("mobs.sheep.ridable-in-water", sheepRidableInWater); -@@ -2164,6 +2255,7 @@ public class PurpurWorldConfig { +@@ -2181,6 +2272,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); @@ -1889,7 +1889,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean shulkerRidable = false; -@@ -2177,6 +2269,7 @@ public class PurpurWorldConfig { +@@ -2194,6 +2286,7 @@ public class PurpurWorldConfig { public String shulkerSpawnFromBulletNearbyEquation = "(nearby - 1) / 5.0"; public boolean shulkerSpawnFromBulletRandomColor = false; public boolean shulkerChangeColorWithDye = false; @@ -1897,7 +1897,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void shulkerSettings() { shulkerRidable = getBoolean("mobs.shulker.ridable", shulkerRidable); shulkerRidableInWater = getBoolean("mobs.shulker.ridable-in-water", shulkerRidableInWater); -@@ -2194,6 +2287,7 @@ public class PurpurWorldConfig { +@@ -2211,6 +2304,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); @@ -1905,7 +1905,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean silverfishRidable = false; -@@ -2202,6 +2296,7 @@ public class PurpurWorldConfig { +@@ -2219,6 +2313,7 @@ public class PurpurWorldConfig { public double silverfishMaxHealth = 8.0D; public boolean silverfishBypassMobGriefing = false; public boolean silverfishTakeDamageFromWater = false; @@ -1913,7 +1913,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void silverfishSettings() { silverfishRidable = getBoolean("mobs.silverfish.ridable", silverfishRidable); silverfishRidableInWater = getBoolean("mobs.silverfish.ridable-in-water", silverfishRidableInWater); -@@ -2214,6 +2309,7 @@ public class PurpurWorldConfig { +@@ -2231,6 +2326,7 @@ 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); @@ -1921,7 +1921,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean skeletonRidable = false; -@@ -2221,6 +2317,7 @@ public class PurpurWorldConfig { +@@ -2238,6 +2334,7 @@ public class PurpurWorldConfig { public boolean skeletonControllable = true; public double skeletonMaxHealth = 20.0D; public boolean skeletonTakeDamageFromWater = false; @@ -1929,7 +1929,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void skeletonSettings() { skeletonRidable = getBoolean("mobs.skeleton.ridable", skeletonRidable); skeletonRidableInWater = getBoolean("mobs.skeleton.ridable-in-water", skeletonRidableInWater); -@@ -2232,6 +2329,7 @@ public class PurpurWorldConfig { +@@ -2249,6 +2346,7 @@ public class PurpurWorldConfig { } skeletonMaxHealth = getDouble("mobs.skeleton.attributes.max_health", skeletonMaxHealth); skeletonTakeDamageFromWater = getBoolean("mobs.skeleton.takes-damage-from-water", skeletonTakeDamageFromWater); @@ -1937,7 +1937,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean skeletonHorseRidableInWater = true; -@@ -2243,6 +2341,7 @@ public class PurpurWorldConfig { +@@ -2260,6 +2358,7 @@ public class PurpurWorldConfig { public double skeletonHorseMovementSpeedMin = 0.2D; public double skeletonHorseMovementSpeedMax = 0.2D; public boolean skeletonHorseTakeDamageFromWater = false; @@ -1945,7 +1945,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void skeletonHorseSettings() { skeletonHorseRidableInWater = getBoolean("mobs.skeleton_horse.ridable-in-water", skeletonHorseRidableInWater); skeletonHorseCanSwim = getBoolean("mobs.skeleton_horse.can-swim", skeletonHorseCanSwim); -@@ -2259,6 +2358,7 @@ public class PurpurWorldConfig { +@@ -2276,6 +2375,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); @@ -1953,7 +1953,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean slimeRidable = false; -@@ -2269,6 +2369,7 @@ public class PurpurWorldConfig { +@@ -2286,6 +2386,7 @@ public class PurpurWorldConfig { public Map slimeMaxHealthCache = new HashMap<>(); public Map slimeAttackDamageCache = new HashMap<>(); public boolean slimeTakeDamageFromWater = false; @@ -1961,7 +1961,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void slimeSettings() { slimeRidable = getBoolean("mobs.slime.ridable", slimeRidable); slimeRidableInWater = getBoolean("mobs.slime.ridable-in-water", slimeRidableInWater); -@@ -2283,6 +2384,7 @@ public class PurpurWorldConfig { +@@ -2300,6 +2401,7 @@ public class PurpurWorldConfig { slimeMaxHealthCache.clear(); slimeAttackDamageCache.clear(); slimeTakeDamageFromWater = getBoolean("mobs.slime.takes-damage-from-water", slimeTakeDamageFromWater); @@ -1969,7 +1969,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean snowGolemRidable = false; -@@ -2298,6 +2400,7 @@ public class PurpurWorldConfig { +@@ -2315,6 +2417,7 @@ public class PurpurWorldConfig { public double snowGolemAttackDistance = 1.25D; public boolean snowGolemBypassMobGriefing = false; public boolean snowGolemTakeDamageFromWater = true; @@ -1977,7 +1977,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void snowGolemSettings() { snowGolemRidable = getBoolean("mobs.snow_golem.ridable", snowGolemRidable); snowGolemRidableInWater = getBoolean("mobs.snow_golem.ridable-in-water", snowGolemRidableInWater); -@@ -2317,6 +2420,7 @@ public class PurpurWorldConfig { +@@ -2334,6 +2437,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); @@ -1985,7 +1985,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean squidRidable = false; -@@ -2326,6 +2430,7 @@ public class PurpurWorldConfig { +@@ -2343,6 +2447,7 @@ public class PurpurWorldConfig { public double squidOffsetWaterCheck = 0.0D; public boolean squidsCanFly = false; public boolean squidTakeDamageFromWater = false; @@ -1993,7 +1993,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void squidSettings() { squidRidable = getBoolean("mobs.squid.ridable", squidRidable); squidControllable = getBoolean("mobs.squid.controllable", squidControllable); -@@ -2339,6 +2444,7 @@ public class PurpurWorldConfig { +@@ -2356,6 +2461,7 @@ 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); @@ -2001,7 +2001,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean spiderRidable = false; -@@ -2346,6 +2452,7 @@ public class PurpurWorldConfig { +@@ -2363,6 +2469,7 @@ public class PurpurWorldConfig { public boolean spiderControllable = true; public double spiderMaxHealth = 16.0D; public boolean spiderTakeDamageFromWater = false; @@ -2009,7 +2009,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void spiderSettings() { spiderRidable = getBoolean("mobs.spider.ridable", spiderRidable); spiderRidableInWater = getBoolean("mobs.spider.ridable-in-water", spiderRidableInWater); -@@ -2357,6 +2464,7 @@ public class PurpurWorldConfig { +@@ -2374,6 +2481,7 @@ public class PurpurWorldConfig { } spiderMaxHealth = getDouble("mobs.spider.attributes.max_health", spiderMaxHealth); spiderTakeDamageFromWater = getBoolean("mobs.spider.takes-damage-from-water", spiderTakeDamageFromWater); @@ -2017,7 +2017,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean strayRidable = false; -@@ -2364,6 +2472,7 @@ public class PurpurWorldConfig { +@@ -2381,6 +2489,7 @@ public class PurpurWorldConfig { public boolean strayControllable = true; public double strayMaxHealth = 20.0D; public boolean strayTakeDamageFromWater = false; @@ -2025,7 +2025,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void straySettings() { strayRidable = getBoolean("mobs.stray.ridable", strayRidable); strayRidableInWater = getBoolean("mobs.stray.ridable-in-water", strayRidableInWater); -@@ -2375,6 +2484,7 @@ public class PurpurWorldConfig { +@@ -2392,6 +2501,7 @@ public class PurpurWorldConfig { } strayMaxHealth = getDouble("mobs.stray.attributes.max_health", strayMaxHealth); strayTakeDamageFromWater = getBoolean("mobs.stray.takes-damage-from-water", strayTakeDamageFromWater); @@ -2033,7 +2033,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean striderRidable = false; -@@ -2384,6 +2494,7 @@ public class PurpurWorldConfig { +@@ -2401,6 +2511,7 @@ public class PurpurWorldConfig { public int striderBreedingTicks = 6000; public boolean striderGiveSaddleBack = false; public boolean striderTakeDamageFromWater = true; @@ -2041,15 +2041,15 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void striderSettings() { striderRidable = getBoolean("mobs.strider.ridable", striderRidable); striderRidableInWater = getBoolean("mobs.strider.ridable-in-water", striderRidableInWater); -@@ -2397,6 +2508,7 @@ public class PurpurWorldConfig { +@@ -2414,6 +2525,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; -@@ -2410,6 +2522,7 @@ public class PurpurWorldConfig { + public boolean tadpoleRidable = false; +@@ -2436,6 +2548,7 @@ public class PurpurWorldConfig { public double traderLlamaMovementSpeedMax = 0.175D; public int traderLlamaBreedingTicks = 6000; public boolean traderLlamaTakeDamageFromWater = false; @@ -2057,7 +2057,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void traderLlamaSettings() { traderLlamaRidable = getBoolean("mobs.trader_llama.ridable", traderLlamaRidable); traderLlamaRidableInWater = getBoolean("mobs.trader_llama.ridable-in-water", traderLlamaRidableInWater); -@@ -2429,12 +2542,14 @@ public class PurpurWorldConfig { +@@ -2455,12 +2568,14 @@ 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); @@ -2072,7 +2072,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void tropicalFishSettings() { tropicalFishRidable = getBoolean("mobs.tropical_fish.ridable", tropicalFishRidable); tropicalFishControllable = getBoolean("mobs.tropical_fish.controllable", tropicalFishControllable); -@@ -2445,6 +2560,7 @@ public class PurpurWorldConfig { +@@ -2471,6 +2586,7 @@ public class PurpurWorldConfig { } tropicalFishMaxHealth = getDouble("mobs.tropical_fish.attributes.max_health", tropicalFishMaxHealth); tropicalFishTakeDamageFromWater = getBoolean("mobs.tropical_fish.takes-damage-from-water", tropicalFishTakeDamageFromWater); @@ -2080,7 +2080,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean turtleRidable = false; -@@ -2453,6 +2569,7 @@ public class PurpurWorldConfig { +@@ -2479,6 +2595,7 @@ public class PurpurWorldConfig { public double turtleMaxHealth = 30.0D; public int turtleBreedingTicks = 6000; public boolean turtleTakeDamageFromWater = false; @@ -2088,7 +2088,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void turtleSettings() { turtleRidable = getBoolean("mobs.turtle.ridable", turtleRidable); turtleRidableInWater = getBoolean("mobs.turtle.ridable-in-water", turtleRidableInWater); -@@ -2465,6 +2582,7 @@ public class PurpurWorldConfig { +@@ -2491,6 +2608,7 @@ public class PurpurWorldConfig { turtleMaxHealth = getDouble("mobs.turtle.attributes.max_health", turtleMaxHealth); turtleBreedingTicks = getInt("mobs.turtle.breeding-delay-ticks", turtleBreedingTicks); turtleTakeDamageFromWater = getBoolean("mobs.turtle.takes-damage-from-water", turtleTakeDamageFromWater); @@ -2096,7 +2096,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean vexRidable = false; -@@ -2473,6 +2591,7 @@ public class PurpurWorldConfig { +@@ -2499,6 +2617,7 @@ public class PurpurWorldConfig { public double vexMaxY = 320D; public double vexMaxHealth = 14.0D; public boolean vexTakeDamageFromWater = false; @@ -2104,7 +2104,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void vexSettings() { vexRidable = getBoolean("mobs.vex.ridable", vexRidable); vexRidableInWater = getBoolean("mobs.vex.ridable-in-water", vexRidableInWater); -@@ -2485,6 +2604,7 @@ public class PurpurWorldConfig { +@@ -2511,6 +2630,7 @@ public class PurpurWorldConfig { } vexMaxHealth = getDouble("mobs.vex.attributes.max_health", vexMaxHealth); vexTakeDamageFromWater = getBoolean("mobs.vex.takes-damage-from-water", vexTakeDamageFromWater); @@ -2112,7 +2112,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean villagerRidable = false; -@@ -2502,6 +2622,7 @@ public class PurpurWorldConfig { +@@ -2528,6 +2648,7 @@ public class PurpurWorldConfig { public boolean villagerBypassMobGriefing = false; public boolean villagerTakeDamageFromWater = false; public boolean villagerAllowTrading = true; @@ -2120,7 +2120,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -2523,6 +2644,7 @@ public class PurpurWorldConfig { +@@ -2549,6 +2670,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); @@ -2128,7 +2128,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean vindicatorRidable = false; -@@ -2531,6 +2653,7 @@ public class PurpurWorldConfig { +@@ -2557,6 +2679,7 @@ public class PurpurWorldConfig { public double vindicatorMaxHealth = 24.0D; public double vindicatorJohnnySpawnChance = 0D; public boolean vindicatorTakeDamageFromWater = false; @@ -2136,7 +2136,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void vindicatorSettings() { vindicatorRidable = getBoolean("mobs.vindicator.ridable", vindicatorRidable); vindicatorRidableInWater = getBoolean("mobs.vindicator.ridable-in-water", vindicatorRidableInWater); -@@ -2543,6 +2666,7 @@ public class PurpurWorldConfig { +@@ -2569,6 +2692,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); @@ -2144,7 +2144,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean wanderingTraderRidable = false; -@@ -2553,6 +2677,7 @@ public class PurpurWorldConfig { +@@ -2579,6 +2703,7 @@ public class PurpurWorldConfig { public boolean wanderingTraderCanBeLeashed = false; public boolean wanderingTraderTakeDamageFromWater = false; public boolean wanderingTraderAllowTrading = true; @@ -2152,15 +2152,15 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void wanderingTraderSettings() { wanderingTraderRidable = getBoolean("mobs.wandering_trader.ridable", wanderingTraderRidable); wanderingTraderRidableInWater = getBoolean("mobs.wandering_trader.ridable-in-water", wanderingTraderRidableInWater); -@@ -2567,6 +2692,7 @@ public class PurpurWorldConfig { +@@ -2593,6 +2718,7 @@ 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; -@@ -2574,6 +2700,7 @@ public class PurpurWorldConfig { + public boolean wardenRidable = false; +@@ -2609,6 +2735,7 @@ public class PurpurWorldConfig { public boolean witchControllable = true; public double witchMaxHealth = 26.0D; public boolean witchTakeDamageFromWater = false; @@ -2168,7 +2168,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void witchSettings() { witchRidable = getBoolean("mobs.witch.ridable", witchRidable); witchRidableInWater = getBoolean("mobs.witch.ridable-in-water", witchRidableInWater); -@@ -2585,6 +2712,7 @@ public class PurpurWorldConfig { +@@ -2620,6 +2747,7 @@ public class PurpurWorldConfig { } witchMaxHealth = getDouble("mobs.witch.attributes.max_health", witchMaxHealth); witchTakeDamageFromWater = getBoolean("mobs.witch.takes-damage-from-water", witchTakeDamageFromWater); @@ -2176,7 +2176,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean witherRidable = false; -@@ -2599,6 +2727,7 @@ public class PurpurWorldConfig { +@@ -2634,6 +2762,7 @@ public class PurpurWorldConfig { public boolean witherCanRideVehicles = false; public float witherExplosionRadius = 1.0F; public boolean witherPlaySpawnSound = true; @@ -2184,7 +2184,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void witherSettings() { witherRidable = getBoolean("mobs.wither.ridable", witherRidable); witherRidableInWater = getBoolean("mobs.wither.ridable-in-water", witherRidableInWater); -@@ -2621,6 +2750,7 @@ public class PurpurWorldConfig { +@@ -2656,6 +2785,7 @@ 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); @@ -2192,7 +2192,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean witherSkeletonRidable = false; -@@ -2628,6 +2758,7 @@ public class PurpurWorldConfig { +@@ -2663,6 +2793,7 @@ public class PurpurWorldConfig { public boolean witherSkeletonControllable = true; public double witherSkeletonMaxHealth = 20.0D; public boolean witherSkeletonTakeDamageFromWater = false; @@ -2200,7 +2200,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void witherSkeletonSettings() { witherSkeletonRidable = getBoolean("mobs.wither_skeleton.ridable", witherSkeletonRidable); witherSkeletonRidableInWater = getBoolean("mobs.wither_skeleton.ridable-in-water", witherSkeletonRidableInWater); -@@ -2639,6 +2770,7 @@ public class PurpurWorldConfig { +@@ -2674,6 +2805,7 @@ public class PurpurWorldConfig { } witherSkeletonMaxHealth = getDouble("mobs.wither_skeleton.attributes.max_health", witherSkeletonMaxHealth); witherSkeletonTakeDamageFromWater = getBoolean("mobs.wither_skeleton.takes-damage-from-water", witherSkeletonTakeDamageFromWater); @@ -2208,7 +2208,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean wolfRidable = false; -@@ -2650,6 +2782,7 @@ public class PurpurWorldConfig { +@@ -2685,6 +2817,7 @@ public class PurpurWorldConfig { public double wolfNaturalRabid = 0.0D; public int wolfBreedingTicks = 6000; public boolean wolfTakeDamageFromWater = false; @@ -2216,7 +2216,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void wolfSettings() { wolfRidable = getBoolean("mobs.wolf.ridable", wolfRidable); wolfRidableInWater = getBoolean("mobs.wolf.ridable-in-water", wolfRidableInWater); -@@ -2669,6 +2802,7 @@ public class PurpurWorldConfig { +@@ -2704,6 +2837,7 @@ 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); @@ -2224,7 +2224,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean zoglinRidable = false; -@@ -2676,6 +2810,7 @@ public class PurpurWorldConfig { +@@ -2711,6 +2845,7 @@ public class PurpurWorldConfig { public boolean zoglinControllable = true; public double zoglinMaxHealth = 40.0D; public boolean zoglinTakeDamageFromWater = false; @@ -2232,7 +2232,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void zoglinSettings() { zoglinRidable = getBoolean("mobs.zoglin.ridable", zoglinRidable); zoglinRidableInWater = getBoolean("mobs.zoglin.ridable-in-water", zoglinRidableInWater); -@@ -2687,6 +2822,7 @@ public class PurpurWorldConfig { +@@ -2722,6 +2857,7 @@ public class PurpurWorldConfig { } zoglinMaxHealth = getDouble("mobs.zoglin.attributes.max_health", zoglinMaxHealth); zoglinTakeDamageFromWater = getBoolean("mobs.zoglin.takes-damage-from-water", zoglinTakeDamageFromWater); @@ -2240,7 +2240,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean zombieRidable = false; -@@ -2700,6 +2836,7 @@ public class PurpurWorldConfig { +@@ -2735,6 +2871,7 @@ public class PurpurWorldConfig { public boolean zombieAggressiveTowardsVillagerWhenLagging = true; public boolean zombieBypassMobGriefing = false; public boolean zombieTakeDamageFromWater = false; @@ -2248,7 +2248,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void zombieSettings() { zombieRidable = getBoolean("mobs.zombie.ridable", zombieRidable); zombieRidableInWater = getBoolean("mobs.zombie.ridable-in-water", zombieRidableInWater); -@@ -2717,6 +2854,7 @@ public class PurpurWorldConfig { +@@ -2752,6 +2889,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); @@ -2256,7 +2256,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean zombieHorseRidableInWater = false; -@@ -2729,6 +2867,7 @@ public class PurpurWorldConfig { +@@ -2764,6 +2902,7 @@ public class PurpurWorldConfig { public double zombieHorseMovementSpeedMax = 0.2D; public double zombieHorseSpawnChance = 0.0D; public boolean zombieHorseTakeDamageFromWater = false; @@ -2264,7 +2264,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void zombieHorseSettings() { zombieHorseRidableInWater = getBoolean("mobs.zombie_horse.ridable-in-water", zombieHorseRidableInWater); zombieHorseCanSwim = getBoolean("mobs.zombie_horse.can-swim", zombieHorseCanSwim); -@@ -2746,6 +2885,7 @@ public class PurpurWorldConfig { +@@ -2781,6 +2920,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); @@ -2272,7 +2272,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean zombieVillagerRidable = false; -@@ -2760,6 +2900,7 @@ public class PurpurWorldConfig { +@@ -2795,6 +2935,7 @@ public class PurpurWorldConfig { public int zombieVillagerCuringTimeMin = 3600; public int zombieVillagerCuringTimeMax = 6000; public boolean zombieVillagerCureEnabled = true; @@ -2280,7 +2280,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void zombieVillagerSettings() { zombieVillagerRidable = getBoolean("mobs.zombie_villager.ridable", zombieVillagerRidable); zombieVillagerRidableInWater = getBoolean("mobs.zombie_villager.ridable-in-water", zombieVillagerRidableInWater); -@@ -2778,6 +2919,7 @@ public class PurpurWorldConfig { +@@ -2813,6 +2954,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); @@ -2288,7 +2288,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 } public boolean zombifiedPiglinRidable = false; -@@ -2790,6 +2932,7 @@ public class PurpurWorldConfig { +@@ -2825,6 +2967,7 @@ public class PurpurWorldConfig { public boolean zombifiedPiglinJockeyTryExistingChickens = true; public boolean zombifiedPiglinCountAsPlayerKillWhenAngry = true; public boolean zombifiedPiglinTakeDamageFromWater = false; @@ -2296,7 +2296,7 @@ index 6e2352841252c693fd7cfe6935694e116c01e243..df4f916efd84cec23ae66cf2ed6d62e6 private void zombifiedPiglinSettings() { zombifiedPiglinRidable = getBoolean("mobs.zombified_piglin.ridable", zombifiedPiglinRidable); zombifiedPiglinRidableInWater = getBoolean("mobs.zombified_piglin.ridable-in-water", zombifiedPiglinRidableInWater); -@@ -2806,6 +2949,7 @@ public class PurpurWorldConfig { +@@ -2841,6 +2984,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); diff --git a/patches/server/0244-Option-to-prevent-spiders-from-climbing-world-border.patch b/patches/server/0244-Option-to-prevent-spiders-from-climbing-world-border.patch index b83e56c69..7b09e2b5d 100644 --- a/patches/server/0244-Option-to-prevent-spiders-from-climbing-world-border.patch +++ b/patches/server/0244-Option-to-prevent-spiders-from-climbing-world-border.patch @@ -39,10 +39,10 @@ index bdd4fc3072f7a5ea504ba35f6a08ae971e83b69f..b9ac8cefefe1f47548166330b7c889df } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index df4f916efd84cec23ae66cf2ed6d62e6b5e61398..50b2f53d349df590c82086bd1dda24628d3f32c6 100644 +index fe167bf81997f5657b0efcc01c302bcaa222d5fc..493ebb58ddbcd6d78e48b7fe5f66d3a385c38746 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2453,6 +2453,7 @@ public class PurpurWorldConfig { +@@ -2470,6 +2470,7 @@ public class PurpurWorldConfig { public double spiderMaxHealth = 16.0D; public boolean spiderTakeDamageFromWater = false; public boolean spiderAlwaysDropExp = false; @@ -50,7 +50,7 @@ index df4f916efd84cec23ae66cf2ed6d62e6b5e61398..50b2f53d349df590c82086bd1dda2462 private void spiderSettings() { spiderRidable = getBoolean("mobs.spider.ridable", spiderRidable); spiderRidableInWater = getBoolean("mobs.spider.ridable-in-water", spiderRidableInWater); -@@ -2465,6 +2466,7 @@ public class PurpurWorldConfig { +@@ -2482,6 +2483,7 @@ 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); diff --git a/patches/server/0246-Shearing-jeb-produces-random-color-wool.patch b/patches/server/0246-Shearing-jeb-produces-random-color-wool.patch index e06b52f4a..1f8ba7d69 100644 --- a/patches/server/0246-Shearing-jeb-produces-random-color-wool.patch +++ b/patches/server/0246-Shearing-jeb-produces-random-color-wool.patch @@ -18,10 +18,10 @@ index 63aeab7204ac954b2908207dc6e743d17aa27f2e..aa6f6e252f6f2933825b97bf1b9679fe if (entityitem != null) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 1f30405dc250d02b7670b3d0c8b126a4449a2cdc..b63c3664b99227eaccb4721bbae269bf1e25c47a 100644 +index c3f66860b5a153eb1a8f88d81fd0e7f19383a5eb..4e89843d98bf0cd09032eeed36e0c2f90af15e5e 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2246,6 +2246,7 @@ public class PurpurWorldConfig { +@@ -2263,6 +2263,7 @@ public class PurpurWorldConfig { public boolean sheepBypassMobGriefing = false; public boolean sheepTakeDamageFromWater = false; public boolean sheepAlwaysDropExp = false; @@ -29,7 +29,7 @@ index 1f30405dc250d02b7670b3d0c8b126a4449a2cdc..b63c3664b99227eaccb4721bbae269bf private void sheepSettings() { sheepRidable = getBoolean("mobs.sheep.ridable", sheepRidable); sheepRidableInWater = getBoolean("mobs.sheep.ridable-in-water", sheepRidableInWater); -@@ -2260,6 +2261,7 @@ public class PurpurWorldConfig { +@@ -2277,6 +2278,7 @@ public class PurpurWorldConfig { 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); diff --git a/patches/server/0248-Mob-head-visibility-percent.patch b/patches/server/0248-Mob-head-visibility-percent.patch index ab7574159..c4e379ae7 100644 --- a/patches/server/0248-Mob-head-visibility-percent.patch +++ b/patches/server/0248-Mob-head-visibility-percent.patch @@ -29,10 +29,10 @@ index 6e7af1939df4ff99d6d4645f7ed270110d9d0373..d120c8808c6a8df2c8615fe02f2c8a5b // Purpur start if (entity instanceof LivingEntity entityliving) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 66cc1e13182874e9265a81c80a8b9ff3daaf8fc4..57a3e2822b587180f0c6210eaffa1b192419c62e 100644 +index 1e7b7a560b12b3de0a23124c58bc73e001189d92..ab26229fc60bd81e2f0264ce3b4cda46590870de 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1242,6 +1242,7 @@ public class PurpurWorldConfig { +@@ -1251,6 +1251,7 @@ public class PurpurWorldConfig { public boolean creeperExplodeWhenKilled = false; public boolean creeperHealthRadius = false; public boolean creeperAlwaysDropExp = false; @@ -40,7 +40,7 @@ index 66cc1e13182874e9265a81c80a8b9ff3daaf8fc4..57a3e2822b587180f0c6210eaffa1b19 private void creeperSettings() { creeperRidable = getBoolean("mobs.creeper.ridable", creeperRidable); creeperRidableInWater = getBoolean("mobs.creeper.ridable-in-water", creeperRidableInWater); -@@ -1259,6 +1260,7 @@ public class PurpurWorldConfig { +@@ -1268,6 +1269,7 @@ public class PurpurWorldConfig { creeperExplodeWhenKilled = getBoolean("mobs.creeper.explode-when-killed", creeperExplodeWhenKilled); creeperHealthRadius = getBoolean("mobs.creeper.health-impacts-explosion", creeperHealthRadius); creeperAlwaysDropExp = getBoolean("mobs.creeper.always-drop-exp", creeperAlwaysDropExp); @@ -48,7 +48,7 @@ index 66cc1e13182874e9265a81c80a8b9ff3daaf8fc4..57a3e2822b587180f0c6210eaffa1b19 } public boolean dolphinRidable = false; -@@ -2326,6 +2328,7 @@ public class PurpurWorldConfig { +@@ -2343,6 +2345,7 @@ public class PurpurWorldConfig { public double skeletonMaxHealth = 20.0D; public boolean skeletonTakeDamageFromWater = false; public boolean skeletonAlwaysDropExp = false; @@ -56,7 +56,7 @@ index 66cc1e13182874e9265a81c80a8b9ff3daaf8fc4..57a3e2822b587180f0c6210eaffa1b19 private void skeletonSettings() { skeletonRidable = getBoolean("mobs.skeleton.ridable", skeletonRidable); skeletonRidableInWater = getBoolean("mobs.skeleton.ridable-in-water", skeletonRidableInWater); -@@ -2338,6 +2341,7 @@ public class PurpurWorldConfig { +@@ -2355,6 +2358,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); @@ -64,7 +64,7 @@ index 66cc1e13182874e9265a81c80a8b9ff3daaf8fc4..57a3e2822b587180f0c6210eaffa1b19 } public boolean skeletonHorseRidableInWater = true; -@@ -2847,6 +2851,7 @@ public class PurpurWorldConfig { +@@ -2882,6 +2886,7 @@ public class PurpurWorldConfig { public boolean zombieBypassMobGriefing = false; public boolean zombieTakeDamageFromWater = false; public boolean zombieAlwaysDropExp = false; @@ -72,7 +72,7 @@ index 66cc1e13182874e9265a81c80a8b9ff3daaf8fc4..57a3e2822b587180f0c6210eaffa1b19 private void zombieSettings() { zombieRidable = getBoolean("mobs.zombie.ridable", zombieRidable); zombieRidableInWater = getBoolean("mobs.zombie.ridable-in-water", zombieRidableInWater); -@@ -2865,6 +2870,7 @@ public class PurpurWorldConfig { +@@ -2900,6 +2905,7 @@ public class PurpurWorldConfig { 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); diff --git a/patches/server/0251-Stop-bees-from-dying-after-stinging.patch b/patches/server/0251-Stop-bees-from-dying-after-stinging.patch index c19f341f7..dca9e8361 100644 --- a/patches/server/0251-Stop-bees-from-dying-after-stinging.patch +++ b/patches/server/0251-Stop-bees-from-dying-after-stinging.patch @@ -5,7 +5,7 @@ Subject: [PATCH] Stop bees from dying after stinging 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 dcffd24a40766a18e9f70753dd95dff88330cb30..3cf1f1094c4444797bd615e57a3f885df1a94144 100644 +index 4b9d13fb36d0e35f1cc7a5d95b26dc5f8ded0d6a..a6378e6db70ba80aaa18954766f029cd6e97419e 100644 --- a/src/main/java/net/minecraft/world/entity/animal/Bee.java +++ b/src/main/java/net/minecraft/world/entity/animal/Bee.java @@ -455,6 +455,7 @@ public class Bee extends Animal implements NeutralMob, FlyingAnimal { @@ -17,10 +17,10 @@ index dcffd24a40766a18e9f70753dd95dff88330cb30..3cf1f1094c4444797bd615e57a3f885d ++this.timeSinceSting; if (this.timeSinceSting % 5 == 0 && this.random.nextInt(Mth.clamp(1200 - this.timeSinceSting, (int) 1, (int) 1200)) == 0) { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 16652ffffb714a232ef1ca6ca877adf312888e9b..ff48b818df8d2f2f9ca399257242f47e78cbc5e9 100644 +index ab26229fc60bd81e2f0264ce3b4cda46590870de..96a586d893373cf21ee3d1510f54d897faad457a 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1062,6 +1062,7 @@ public class PurpurWorldConfig { +@@ -1071,6 +1071,7 @@ public class PurpurWorldConfig { public boolean beeCanWorkAtNight = false; public boolean beeCanWorkInRain = false; public boolean beeAlwaysDropExp = false; @@ -28,7 +28,7 @@ index 16652ffffb714a232ef1ca6ca877adf312888e9b..ff48b818df8d2f2f9ca399257242f47e private void beeSettings() { beeRidable = getBoolean("mobs.bee.ridable", beeRidable); beeRidableInWater = getBoolean("mobs.bee.ridable-in-water", beeRidableInWater); -@@ -1078,6 +1079,7 @@ public class PurpurWorldConfig { +@@ -1087,6 +1088,7 @@ public class PurpurWorldConfig { 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); diff --git a/patches/server/0257-Configurable-phantom-size.patch b/patches/server/0257-Configurable-phantom-size.patch index 6e575f20a..58612cbad 100644 --- a/patches/server/0257-Configurable-phantom-size.patch +++ b/patches/server/0257-Configurable-phantom-size.patch @@ -22,10 +22,10 @@ index 33b347474b7485633ca77bdff28e4b32580b51b8..bfca1101025e473c97cd4804e74bed04 } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 52708f60b0b13d550777cbe23b9c97cc5cae5fe6..ac842c9b9da59f530ec0c7ff64693763e807c24f 100644 +index f187872e96f41e5c97c9f1bc71c859310769f914..75f83aa35fb5ac24f6c51e2315b322d96c69050e 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1985,6 +1985,8 @@ public class PurpurWorldConfig { +@@ -2002,6 +2002,8 @@ public class PurpurWorldConfig { public boolean phantomFlamesOnSwoop = false; public boolean phantomTakeDamageFromWater = false; public boolean phantomAlwaysDropExp = false; @@ -34,7 +34,7 @@ index 52708f60b0b13d550777cbe23b9c97cc5cae5fe6..ac842c9b9da59f530ec0c7ff64693763 private void phantomSettings() { phantomRidable = getBoolean("mobs.phantom.ridable", phantomRidable); phantomRidableInWater = getBoolean("mobs.phantom.ridable-in-water", phantomRidableInWater); -@@ -2027,6 +2029,13 @@ public class PurpurWorldConfig { +@@ -2044,6 +2046,13 @@ public class PurpurWorldConfig { phantomFlamesOnSwoop = getBoolean("mobs.phantom.flames-on-swoop", phantomFlamesOnSwoop); phantomTakeDamageFromWater = getBoolean("mobs.phantom.takes-damage-from-water", phantomTakeDamageFromWater); phantomAlwaysDropExp = getBoolean("mobs.phantom.always-drop-exp", phantomAlwaysDropExp); diff --git a/patches/server/0260-Configurable-minimum-demand-for-trades.patch b/patches/server/0260-Configurable-minimum-demand-for-trades.patch index 6ba2b1ff2..9f060f72c 100644 --- a/patches/server/0260-Configurable-minimum-demand-for-trades.patch +++ b/patches/server/0260-Configurable-minimum-demand-for-trades.patch @@ -40,10 +40,10 @@ index 8a9a701baabdaf066cd9b28c05430f673fcafb4e..17cc3237c7fc8ceda136b2371fabf6f0 public ItemStack assemble() { diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index ac842c9b9da59f530ec0c7ff64693763e807c24f..17300a6bf04036c6df45841fc1ebdf6d776fc9df 100644 +index 75f83aa35fb5ac24f6c51e2315b322d96c69050e..eb021d6673ea37fd59ad3644995eb9ecc394b506 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2654,6 +2654,7 @@ public class PurpurWorldConfig { +@@ -2680,6 +2680,7 @@ public class PurpurWorldConfig { public boolean villagerTakeDamageFromWater = false; public boolean villagerAllowTrading = true; public boolean villagerAlwaysDropExp = false; @@ -51,7 +51,7 @@ index ac842c9b9da59f530ec0c7ff64693763e807c24f..17300a6bf04036c6df45841fc1ebdf6d private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -2676,6 +2677,7 @@ public class PurpurWorldConfig { +@@ -2702,6 +2703,7 @@ public class PurpurWorldConfig { villagerTakeDamageFromWater = getBoolean("mobs.villager.takes-damage-from-water", villagerTakeDamageFromWater); villagerAllowTrading = getBoolean("mobs.villager.allow-trading", villagerAllowTrading); villagerAlwaysDropExp = getBoolean("mobs.villager.always-drop-exp", villagerAlwaysDropExp); diff --git a/patches/server/0261-Lobotomize-stuck-villagers.patch b/patches/server/0261-Lobotomize-stuck-villagers.patch index f54e1a917..f5dba00b4 100644 --- a/patches/server/0261-Lobotomize-stuck-villagers.patch +++ b/patches/server/0261-Lobotomize-stuck-villagers.patch @@ -111,10 +111,10 @@ index f0b910df1ee471b4d72d97c6197ab14f2854976e..6ce32a52d621a0c2629568ea07e445f5 + // Purpur end } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 17300a6bf04036c6df45841fc1ebdf6d776fc9df..a6349da9538bad97f4909a0359adee09200928ff 100644 +index eb021d6673ea37fd59ad3644995eb9ecc394b506..e327fcaec25b36eabf3858f6231ec0303108d1c0 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2655,6 +2655,8 @@ public class PurpurWorldConfig { +@@ -2681,6 +2681,8 @@ public class PurpurWorldConfig { public boolean villagerAllowTrading = true; public boolean villagerAlwaysDropExp = false; public int villagerMinimumDemand = 0; @@ -123,7 +123,7 @@ index 17300a6bf04036c6df45841fc1ebdf6d776fc9df..a6349da9538bad97f4909a0359adee09 private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -2678,6 +2680,17 @@ public class PurpurWorldConfig { +@@ -2704,6 +2706,17 @@ public class PurpurWorldConfig { villagerAllowTrading = getBoolean("mobs.villager.allow-trading", villagerAllowTrading); villagerAlwaysDropExp = getBoolean("mobs.villager.always-drop-exp", villagerAlwaysDropExp); villagerMinimumDemand = getInt("mobs.villager.minimum-demand", villagerMinimumDemand); diff --git a/patches/server/0262-Option-for-villager-display-trade-item.patch b/patches/server/0262-Option-for-villager-display-trade-item.patch index 6eb2eff79..3a6799e46 100644 --- a/patches/server/0262-Option-for-villager-display-trade-item.patch +++ b/patches/server/0262-Option-for-villager-display-trade-item.patch @@ -17,10 +17,10 @@ index 385f3df7044e3f03f17c3ec7484b268004a3def9..90ba6a3abf62e4b272fada96b554ca31 } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index a6349da9538bad97f4909a0359adee09200928ff..e33d4a02162cc8a1d6ea0b6c264de2a629c28450 100644 +index e327fcaec25b36eabf3858f6231ec0303108d1c0..c1affafde07585dbde862430da0b1dac1d67004c 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2657,6 +2657,7 @@ public class PurpurWorldConfig { +@@ -2683,6 +2683,7 @@ public class PurpurWorldConfig { public int villagerMinimumDemand = 0; public boolean villagerLobotomizeEnabled = false; public int villagerLobotomizeCheckInterval = 100; @@ -28,7 +28,7 @@ index a6349da9538bad97f4909a0359adee09200928ff..e33d4a02162cc8a1d6ea0b6c264de2a6 private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -2691,6 +2692,7 @@ public class PurpurWorldConfig { +@@ -2717,6 +2718,7 @@ public class PurpurWorldConfig { } villagerLobotomizeEnabled = getBoolean("mobs.villager.lobotomize.enabled", villagerLobotomizeEnabled); villagerLobotomizeCheckInterval = getInt("mobs.villager.lobotomize.check-interval", villagerLobotomizeCheckInterval); diff --git a/patches/server/0270-Config-to-prevent-horses-from-standing-when-hurt.patch b/patches/server/0270-Config-to-prevent-horses-from-standing-when-hurt.patch index 497e11d11..420ab4088 100644 --- a/patches/server/0270-Config-to-prevent-horses-from-standing-when-hurt.patch +++ b/patches/server/0270-Config-to-prevent-horses-from-standing-when-hurt.patch @@ -21,10 +21,10 @@ index 7466c437b2e996f16a08aaefc5c2b7cba216a14c..205ce2bd91a98a0c67d3c5dd640eb88c } diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 7c4dd0e91cf060850e46b52a0e82280e9d0eb8d7..6ab90d6945d44335505cb30678f8a4c65ce6fbdc 100644 +index 8ef68901082975716b3684b240fb847b04d70b55..8418c1ad58fe39baba10e0315a8a94cc0ef7e712 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -1677,6 +1677,7 @@ public class PurpurWorldConfig { +@@ -1694,6 +1694,7 @@ public class PurpurWorldConfig { public int horseBreedingTicks = 6000; public boolean horseTakeDamageFromWater = false; public boolean horseStandWithRider = true; @@ -32,7 +32,7 @@ index 7c4dd0e91cf060850e46b52a0e82280e9d0eb8d7..6ab90d6945d44335505cb30678f8a4c6 public boolean horseAlwaysDropExp = false; private void horseSettings() { horseRidableInWater = getBoolean("mobs.horse.ridable-in-water", horseRidableInWater); -@@ -1696,6 +1697,7 @@ public class PurpurWorldConfig { +@@ -1713,6 +1714,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); diff --git a/patches/server/0272-Implement-configurable-search-radius-for-villagers-t.patch b/patches/server/0272-Implement-configurable-search-radius-for-villagers-t.patch index c6ce3123b..672b4a6cb 100644 --- a/patches/server/0272-Implement-configurable-search-radius-for-villagers-t.patch +++ b/patches/server/0272-Implement-configurable-search-radius-for-villagers-t.patch @@ -18,10 +18,10 @@ index ace39b0585c67b2764d75ff9e64d132347157a51..20668d53625ec88ba3eb2a655ad3f6bc AABB axisalignedbb = this.getBoundingBox().inflate(10.0D, 10.0D, 10.0D); List list = world.getEntitiesOfClass(Villager.class, axisalignedbb); diff --git a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -index 6ab90d6945d44335505cb30678f8a4c65ce6fbdc..e59a0eadd24748969802b2d4fac2306264345668 100644 +index 8418c1ad58fe39baba10e0315a8a94cc0ef7e712..553e86c7461be4f9ee5b3c4b48013688b3a3debe 100644 --- a/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java +++ b/src/main/java/org/purpurmc/purpur/PurpurWorldConfig.java -@@ -2670,6 +2670,8 @@ public class PurpurWorldConfig { +@@ -2696,6 +2696,8 @@ public class PurpurWorldConfig { public boolean villagerLobotomizeEnabled = false; public int villagerLobotomizeCheckInterval = 100; public boolean villagerDisplayTradeItem = true; @@ -30,7 +30,7 @@ index 6ab90d6945d44335505cb30678f8a4c65ce6fbdc..e59a0eadd24748969802b2d4fac23062 private void villagerSettings() { villagerRidable = getBoolean("mobs.villager.ridable", villagerRidable); villagerRidableInWater = getBoolean("mobs.villager.ridable-in-water", villagerRidableInWater); -@@ -2705,6 +2707,8 @@ public class PurpurWorldConfig { +@@ -2731,6 +2733,8 @@ public class PurpurWorldConfig { villagerLobotomizeEnabled = getBoolean("mobs.villager.lobotomize.enabled", villagerLobotomizeEnabled); villagerLobotomizeCheckInterval = getInt("mobs.villager.lobotomize.check-interval", villagerLobotomizeCheckInterval); villagerDisplayTradeItem = getBoolean("mobs.villager.display-trade-item", villagerDisplayTradeItem); diff --git a/patches/todo/api/0001-Add-pufferfish-added-classes-to-junit-exemptions.patch b/patches/todo/api/0001-Add-pufferfish-added-classes-to-junit-exemptions.patch deleted file mode 100644 index 1b6d7a047..000000000 --- a/patches/todo/api/0001-Add-pufferfish-added-classes-to-junit-exemptions.patch +++ /dev/null @@ -1,21 +0,0 @@ -From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 -From: BillyGalbreath -Date: Tue, 4 Jan 2022 23:05:41 -0600 -Subject: [PATCH] Add pufferfish added classes to junit exemptions - - -diff --git a/src/test/java/org/bukkit/AnnotationTest.java b/src/test/java/org/bukkit/AnnotationTest.java -index 57cf9fab2501da6f1abd12e14697630ca82b0a6d..a5bced98d5b8860f4f05e42cfd8a355c162b8b6e 100644 ---- a/src/test/java/org/bukkit/AnnotationTest.java -+++ b/src/test/java/org/bukkit/AnnotationTest.java -@@ -47,6 +47,10 @@ public class AnnotationTest { - "org/bukkit/plugin/java/PluginClassLoader", - // Generic functional interface - "org/bukkit/util/Consumer", -+ // Purpur start -+ "gg/pufferfish/pufferfish/sentry/SentryContext", -+ "gg/pufferfish/pufferfish/sentry/SentryContext$State", -+ // Purpur end - // Paper start - "io/papermc/paper/util/TransformingRandomAccessList", - "io/papermc/paper/util/TransformingRandomAccessList$TransformedListIterator",