diff --git a/Spigot-API-Patches/0148-Improve-death-events.patch b/Spigot-API-Patches/0148-Improve-death-events.patch new file mode 100644 index 000000000..2191cabb7 --- /dev/null +++ b/Spigot-API-Patches/0148-Improve-death-events.patch @@ -0,0 +1,177 @@ +From a8fa87ebeff0217428ce384063ee98f0cec1519e Mon Sep 17 00:00:00 2001 +From: Phoenix616 +Date: Tue, 21 Aug 2018 01:32:28 +0100 +Subject: [PATCH] Improve death events + +This adds the ability to cancel the death events and to modify the sound +an entity makes when dying. (In cases were no sound should it will be +called with shouldPlaySound set to false allowing unsilencing of silent +entities) + +It makes handling of entity deaths a lot nicer as you no longer need +to listen on the damage event and calculate if the entity dies yourself +to cancel the death which has the benefit of also receiving the dropped +items and experience which is otherwise only properly possible by using +internal code. + +diff --git a/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java b/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java +index ab9e81fd..a7b8f869 100644 +--- a/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java ++++ b/src/main/java/org/bukkit/event/entity/EntityDeathEvent.java +@@ -8,10 +8,19 @@ import org.bukkit.inventory.ItemStack; + /** + * Thrown whenever a LivingEntity dies + */ +-public class EntityDeathEvent extends EntityEvent { ++public class EntityDeathEvent extends EntityEvent implements org.bukkit.event.Cancellable { // Paper - make cancellable + private static final HandlerList handlers = new HandlerList(); + private final List drops; + private int dropExp = 0; ++ // Paper start - make cancellable ++ private boolean cancelled; ++ private double reviveHealth = 0; ++ private boolean shouldPlayDeathSound; ++ private org.bukkit.Sound deathSound; ++ private org.bukkit.SoundCategory deathSoundCategory; ++ private float deathSoundVolume; ++ private float deathSoundPitch; ++ // Paper end + + public EntityDeathEvent(final LivingEntity entity, final List drops) { + this(entity, drops, 0); +@@ -69,4 +78,132 @@ public class EntityDeathEvent extends EntityEvent { + public static HandlerList getHandlerList() { + return handlers; + } ++ ++ // Paper start - make cancellable ++ @Override ++ public boolean isCancelled() { ++ return cancelled; ++ } ++ ++ @Override ++ public void setCancelled(boolean cancel) { ++ cancelled = cancel; ++ } ++ ++ /** ++ * Get the amount of health that the entity should revive with after cancelling the event. ++ * Set to the entity's max health by default. ++ * ++ * @return The amount of health ++ */ ++ public double getReviveHealth() { ++ return reviveHealth; ++ } ++ ++ /** ++ * Set the amount of health that the entity should revive with after cancelling the event. ++ * Revive health value must be between 0 (exclusive) and the entity's max health (inclusive). ++ * ++ * @param reviveHealth The amount of health ++ * @throws IllegalArgumentException Thrown if the health is {@literal <= 0 or >} max health ++ */ ++ public void setReviveHealth(double reviveHealth) throws IllegalArgumentException { ++ double maxHealth = ((LivingEntity) entity).getAttribute(org.bukkit.attribute.Attribute.GENERIC_MAX_HEALTH).getValue(); ++ if ((reviveHealth <= 0) || (reviveHealth > maxHealth)) { ++ throw new IllegalArgumentException("Health must be between 0 (exclusive) and " + maxHealth + " (inclusive), but was " + reviveHealth); ++ } ++ this.reviveHealth = reviveHealth; ++ } ++ ++ ++ /** ++ * Whether or not the death sound should play when the entity dies. If the event is cancelled it does not play! ++ * ++ * @return Whether or not the death sound should play. Event is called with this set to false if the entity is silent. ++ */ ++ public boolean shouldPlayDeathSound() { ++ return shouldPlayDeathSound; ++ } ++ ++ /** ++ * Set whether or not the death sound should play when the entity dies. If the event is cancelled it does not play! ++ * ++ * @param playDeathSound Enable or disable the death sound ++ */ ++ public void setShouldPlayDeathSound(boolean playDeathSound) { ++ this.shouldPlayDeathSound = playDeathSound; ++ } ++ ++ /** ++ * Get the sound that the entity makes when dying ++ * ++ * @return The sound that the entity makes ++ */ ++ public org.bukkit.Sound getDeathSound() { ++ return deathSound; ++ } ++ ++ /** ++ * Set the sound that the entity makes when dying ++ * ++ * @param sound The sound that the entity should make when dying ++ */ ++ public void setDeathSound(org.bukkit.Sound sound) { ++ deathSound = sound; ++ } ++ ++ /** ++ * Get the sound category that the death sound should play in ++ * ++ * @return The sound category ++ */ ++ public org.bukkit.SoundCategory getDeathSoundCategory() { ++ return deathSoundCategory; ++ } ++ ++ /** ++ * Set the sound category that the death sound should play in. ++ * ++ * @param soundCategory The sound category ++ */ ++ public void setDeathSoundCategory(org.bukkit.SoundCategory soundCategory) { ++ this.deathSoundCategory = soundCategory; ++ } ++ ++ /** ++ * Get the volume that the death sound will play at. ++ * ++ * @return The volume the death sound will play at ++ */ ++ public float getDeathSoundVolume() { ++ return deathSoundVolume; ++ } ++ ++ /** ++ * Set the volume the death sound should play at. If the event is cancelled this will not play the sound! ++ * ++ * @param volume The volume the death sound should play at ++ */ ++ public void setDeathSoundVolume(float volume) { ++ this.deathSoundVolume = volume; ++ } ++ ++ /** ++ * Get the pitch that the death sound will play with. ++ * ++ * @return The pitch the death sound will play with ++ */ ++ public float getDeathSoundPitch() { ++ return deathSoundPitch; ++ } ++ ++ /** ++ * GSetet the pitch that the death sound should play with. ++ * ++ * @param pitch The pitch the death sound should play with ++ */ ++ public void setDeathSoundPitch(float pitch) { ++ this.deathSoundPitch = pitch; ++ } ++ // Paper end + } +-- +2.18.0 + diff --git a/Spigot-Server-Patches/0363-Improve-death-events.patch b/Spigot-Server-Patches/0363-Improve-death-events.patch new file mode 100644 index 000000000..8a8a2b168 --- /dev/null +++ b/Spigot-Server-Patches/0363-Improve-death-events.patch @@ -0,0 +1,378 @@ +From 9e11f1b5d8df4fc2b1854ef5aa361dd4b00b3fe1 Mon Sep 17 00:00:00 2001 +From: Phoenix616 +Date: Tue, 21 Aug 2018 01:39:35 +0100 +Subject: [PATCH] Improve death events + +This adds the ability to cancel the death events and to modify the sound +an entity makes when dying. (In cases were no sound should it will be +called with shouldPlaySound set to false allowing unsilencing of silent +entities) + +It makes handling of entity deaths a lot nicer as you no longer need +to listen on the damage event and calculate if the entity dies yourself +to cancel the death which has the benefit of also receiving the dropped +items and experience which is otherwise only properly possible by using +internal code. + +diff --git a/src/main/java/net/minecraft/server/CombatTracker.java b/src/main/java/net/minecraft/server/CombatTracker.java +index 63bdb96db8..96dd1a7fa4 100644 +--- a/src/main/java/net/minecraft/server/CombatTracker.java ++++ b/src/main/java/net/minecraft/server/CombatTracker.java +@@ -163,6 +163,7 @@ public class CombatTracker { + this.h = null; + } + ++ public void reset() { this.g(); } // Paper - OBFHELPER + public void g() { + int i = this.f ? 300 : 100; + if (this.g && (!this.b.isAlive() || this.b.ticksLived - this.c > i)) { +diff --git a/src/main/java/net/minecraft/server/Entity.java b/src/main/java/net/minecraft/server/Entity.java +index 1fae9aa074..3e69bac9ad 100644 +--- a/src/main/java/net/minecraft/server/Entity.java ++++ b/src/main/java/net/minecraft/server/Entity.java +@@ -1538,6 +1538,7 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke + return false; + } + ++ public void runKillTrigger(Entity entity, int kills, DamageSource damageSource) { this.a(entity, kills, damageSource); } // Paper - OBFHELPER + public void a(Entity entity, int i, DamageSource damagesource) { + if (entity instanceof EntityPlayer) { + CriterionTriggers.c.a((EntityPlayer) entity, this, damagesource); +@@ -2406,6 +2407,7 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke + this.fallDistance = 0.0F; + } + ++ public void onKill(EntityLiving entityLiving) { this.b(entityLiving); } // Paper - OBFHELPER + public void b(EntityLiving entityliving) {} + + protected boolean i(double d0, double d1, double d2) { +@@ -3076,6 +3078,7 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke + return EnumPistonReaction.NORMAL; + } + ++ public SoundCategory getDeathSoundCategory() { return bV();} // Paper - OBFHELPER + public SoundCategory bV() { + return SoundCategory.NEUTRAL; + } +diff --git a/src/main/java/net/minecraft/server/EntityArmorStand.java b/src/main/java/net/minecraft/server/EntityArmorStand.java +index 35afffedef..e8e7413748 100644 +--- a/src/main/java/net/minecraft/server/EntityArmorStand.java ++++ b/src/main/java/net/minecraft/server/EntityArmorStand.java +@@ -629,7 +629,8 @@ public class EntityArmorStand extends EntityLiving { + } + + public void killEntity() { +- org.bukkit.craftbukkit.event.CraftEventFactory.callEntityDeathEvent(this, drops); // CraftBukkit - call event ++ org.bukkit.event.entity.EntityDeathEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityDeathEvent(this, drops); // CraftBukkit - call event // Paper - make cancellable ++ if (event.isCancelled()) return; // Paper - make cancellable + this.die(); + } + +diff --git a/src/main/java/net/minecraft/server/EntityLiving.java b/src/main/java/net/minecraft/server/EntityLiving.java +index 890a3a02bd..fec7bf0a5d 100644 +--- a/src/main/java/net/minecraft/server/EntityLiving.java ++++ b/src/main/java/net/minecraft/server/EntityLiving.java +@@ -76,14 +76,14 @@ public abstract class EntityLiving extends Entity { + public float aU; + public EntityHuman killer; + public int lastDamageByPlayerTime; // Paper - public +- protected boolean aX; ++ protected boolean aX; protected void setDying(boolean dying) { this.aX = dying; } protected boolean isDying() { return this.aX; } // Paper - OBFHELPER + protected int ticksFarFromPlayer; + protected float aZ; + protected float ba; + protected float bb; + protected float bc; + protected float bd; +- protected int be; ++ protected int be; protected int getKillCount() { return this.be; } // Paper - OBFHELPER + public float lastDamage; + protected boolean bg; + public float bh; +@@ -124,6 +124,7 @@ public abstract class EntityLiving extends Entity { + public boolean collides = true; + public boolean canPickUpLoot; + public org.bukkit.craftbukkit.entity.CraftLivingEntity getBukkitLivingEntity() { return (org.bukkit.craftbukkit.entity.CraftLivingEntity) super.getBukkitEntity(); } // Paper ++ public boolean silentDeath = false; // Paper - mark entity as dying silently for cancellable death event + + @Override + public float getBukkitYaw() { +@@ -1071,13 +1072,17 @@ public abstract class EntityLiving extends Entity { + + if (this.getHealth() <= 0.0F) { + if (!this.e(damagesource)) { +- SoundEffect soundeffect = this.cs(); ++ // Paper start - moved into CraftEventFactory event caller for cancellable death event ++ //SoundEffect soundeffect = this.cs(); + +- if (flag1 && soundeffect != null) { +- this.a(soundeffect, this.cD(), this.cE()); +- } ++ //if (flag1 && soundeffect != null) { ++ // this.a(soundeffect, this.cD(), this.cE()); ++ //} ++ this.silentDeath = !flag1; // mark entity as dying silently ++ // Paper end + + this.die(damagesource); ++ this.silentDeath = false; // Paper - cancellable death event - reset to default + } + } else if (flag1) { + this.c(damagesource); +@@ -1205,16 +1210,20 @@ public abstract class EntityLiving extends Entity { + Entity entity = damagesource.getEntity(); + EntityLiving entityliving = this.cv(); + +- if (this.be >= 0 && entityliving != null) { +- entityliving.a(this, this.be, damagesource); +- } ++ // Paper start - move down to make death event cancellable ++ //if (this.be >= 0 && entityliving != null) { ++ // entityliving.a(this, this.be, damagesource); ++ //} + +- if (entity != null) { +- entity.b(this); +- } ++ //if (entity != null) { ++ // entity.b(this); ++ //} + +- this.aX = true; +- this.getCombatTracker().g(); ++ //this.aX = true; ++ //this.getCombatTracker().g(); ++ ++ org.bukkit.event.entity.EntityDeathEvent deathEvent = null; ++ // Paper end + if (!this.world.isClientSide) { + int i = 0; + +@@ -1227,15 +1236,32 @@ public abstract class EntityLiving extends Entity { + + this.a(flag, i, damagesource); + // CraftBukkit start - Call death event +- CraftEventFactory.callEntityDeathEvent(this, this.drops); ++ deathEvent = CraftEventFactory.callEntityDeathEvent(this, this.drops); // Paper - cancellable death event + this.drops = new ArrayList(); + } else { +- CraftEventFactory.callEntityDeathEvent(this); ++ deathEvent = CraftEventFactory.callEntityDeathEvent(this); // Paper - cancellable death event + // CraftBukkit end + } + } + +- this.world.broadcastEntityEffect(this, (byte) 3); ++ // Paper start - cancellable death event ++ if (deathEvent == null || !deathEvent.isCancelled()) { ++ // triggers and stats got moved down ++ if (this.getKillCount() >= 0 && entityliving != null) { ++ entityliving.runKillTrigger(this, this.getKillCount(), damagesource); ++ } ++ ++ if (entity != null) { ++ entity.onKill(this); ++ } ++ ++ this.getCombatTracker().reset(); ++ this.setDying(true); ++ this.world.broadcastEntityEffect(this, (byte) 3); ++ } else { ++ this.setHealth((float) deathEvent.getReviveHealth()); ++ } ++ // Paper end + } + } + +@@ -1289,6 +1315,7 @@ public abstract class EntityLiving extends Entity { + return SoundEffects.ENTITY_GENERIC_HURT; + } + ++ @Nullable public SoundEffect getDeathSoundEffect() { return cs();} // Paper - OBFHELPER + @Nullable + protected SoundEffect cs() { + return SoundEffects.ENTITY_GENERIC_DEATH; +@@ -1706,10 +1733,12 @@ public abstract class EntityLiving extends Entity { + + } + ++ public float getDeathSoundVolume() { return cD();} // Paper - OBFHELPER + protected float cD() { + return 1.0F; + } + ++ public float getDeathSoundPitch() { return cE();} // Paper - OBFHELPER + protected float cE() { + return this.isBaby() ? (this.random.nextFloat() - this.random.nextFloat()) * 0.2F + 1.5F : (this.random.nextFloat() - this.random.nextFloat()) * 0.2F + 1.0F; + } +diff --git a/src/main/java/net/minecraft/server/EntityPlayer.java b/src/main/java/net/minecraft/server/EntityPlayer.java +index 334400a4ee..e2b8c70008 100644 +--- a/src/main/java/net/minecraft/server/EntityPlayer.java ++++ b/src/main/java/net/minecraft/server/EntityPlayer.java +@@ -84,6 +84,10 @@ public class EntityPlayer extends EntityHuman implements ICrafting { + } + // Paper end + private int containerUpdateDelay; // Paper ++ // Paper start - cancellable death event ++ public boolean queueHealthUpdatePacket = false; ++ public net.minecraft.server.PacketPlayOutUpdateHealth queuedHealthUpdatePacket; ++ // Paper end + + // CraftBukkit start + public String displayName; +@@ -517,6 +521,15 @@ public class EntityPlayer extends EntityHuman implements ICrafting { + + String deathmessage = defaultMessage.getString(); + org.bukkit.event.entity.PlayerDeathEvent event = CraftEventFactory.callPlayerDeathEvent(this, loot, deathmessage, keepInventory); ++ // Paper start - cancellable death event ++ if (event.isCancelled()) { ++ // make compatible with plugins that might have already set the health in an event listener ++ if (this.getHealth() <= 0) { ++ this.setHealth((float) event.getReviveHealth()); ++ } ++ return; ++ } ++ // Paper end + + String deathMessage = event.getDeathMessage(); + +@@ -644,8 +657,17 @@ public class EntityPlayer extends EntityHuman implements ICrafting { + } + } + } +- +- return super.damageEntity(damagesource, f); ++ // Paper start - cancellable death events ++ //return super.damageEntity(damagesource, f); ++ this.queueHealthUpdatePacket = true; ++ boolean damaged = super.damageEntity(damagesource, f); ++ this.queueHealthUpdatePacket = false; ++ if (this.queuedHealthUpdatePacket != null) { ++ this.playerConnection.sendPacket(this.queuedHealthUpdatePacket); ++ this.queuedHealthUpdatePacket = null; ++ } ++ return damaged; ++ // Paper end + } + } + } +diff --git a/src/main/java/org/bukkit/craftbukkit/CraftSound.java b/src/main/java/org/bukkit/craftbukkit/CraftSound.java +index 17fab031b4..ee8219e3ba 100644 +--- a/src/main/java/org/bukkit/craftbukkit/CraftSound.java ++++ b/src/main/java/org/bukkit/craftbukkit/CraftSound.java +@@ -674,6 +674,22 @@ public enum CraftSound { + WEATHER_RAIN_ABOVE("weather.rain.above"); + private final String minecraftKey; + ++ // Paper start - cancellable death event ++ public static CraftSound getBySoundEffect(final SoundEffect effect) { ++ MinecraftKey key = IRegistry.SOUND_EVENT.getKey(effect); ++ Preconditions.checkArgument(key != null, "Key for sound effect %s not found?", effect.toString()); ++ ++ return valueOf(key.getKey().replace('.', '_').toUpperCase(java.util.Locale.ENGLISH)); ++ } ++ ++ public static Sound getSoundByEffect(final SoundEffect effect) { ++ return Sound.valueOf(getBySoundEffect(effect).name()); ++ } ++ ++ public static SoundEffect getSoundEffect(final Sound sound) { ++ return getSoundEffect(getSound(sound)); ++ } ++ // Paper end + CraftSound(String minecraftKey) { + this.minecraftKey = minecraftKey; + } +diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java +index b6cf96e187..96232aa078 100644 +--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java ++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java +@@ -1711,7 +1711,15 @@ public class CraftPlayer extends CraftHumanEntity implements Player { + } + + public void sendHealthUpdate() { +- getHandle().playerConnection.sendPacket(new PacketPlayOutUpdateHealth(getScaledHealth(), getHandle().getFoodData().getFoodLevel(), getHandle().getFoodData().getSaturationLevel())); ++ // Paper start - cancellable death event ++ //getHandle().playerConnection.sendPacket(new PacketPlayOutUpdateHealth(getScaledHealth(), getHandle().getFoodData().getFoodLevel(), getHandle().getFoodData().getSaturationLevel())); ++ PacketPlayOutUpdateHealth packet = new PacketPlayOutUpdateHealth(getScaledHealth(), getHandle().getFoodData().getFoodLevel(), getHandle().getFoodData().getSaturationLevel()); ++ if (this.getHandle().queueHealthUpdatePacket) { ++ this.getHandle().queuedHealthUpdatePacket = packet; ++ } else { ++ this.getHandle().playerConnection.sendPacket(packet); ++ } ++ // Paper end + } + + public void injectScaledMaxHealth(Collection collection, boolean force) { +diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +index 64b34d2623..dc8c3ea758 100644 +--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java ++++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java +@@ -412,9 +412,16 @@ public class CraftEventFactory { + public static EntityDeathEvent callEntityDeathEvent(EntityLiving victim, List drops) { + CraftLivingEntity entity = (CraftLivingEntity) victim.getBukkitEntity(); + EntityDeathEvent event = new EntityDeathEvent(entity, drops, victim.getExpReward()); ++ populateFields(victim, event); // Paper - make cancellable + CraftWorld world = (CraftWorld) entity.getWorld(); + Bukkit.getServer().getPluginManager().callEvent(event); + ++ // Paper start - make cancellable ++ if (event.isCancelled()) { ++ return event; ++ } ++ playDeathSound(victim, event); ++ // Paper end + victim.expToDrop = event.getDroppedExp(); + + for (org.bukkit.inventory.ItemStack stack : event.getDrops()) { +@@ -430,8 +437,15 @@ public class CraftEventFactory { + CraftPlayer entity = victim.getBukkitEntity(); + PlayerDeathEvent event = new PlayerDeathEvent(entity, drops, victim.getExpReward(), 0, deathMessage); + event.setKeepInventory(keepInventory); ++ populateFields(victim, event); // Paper - make cancellable + org.bukkit.World world = entity.getWorld(); + Bukkit.getServer().getPluginManager().callEvent(event); ++ // Paper start - make cancellable ++ if (event.isCancelled()) { ++ return event; ++ } ++ playDeathSound(victim, event); ++ // Paper end + + victim.keepLevel = event.getKeepLevel(); + victim.newLevel = event.getNewLevel(); +@@ -452,6 +466,31 @@ public class CraftEventFactory { + return event; + } + ++ // Paper start - helper methods for making death event cancellable ++ // Add information to death event ++ private static void populateFields(EntityLiving victim, EntityDeathEvent event) { ++ event.setReviveHealth(event.getEntity().getAttribute(org.bukkit.attribute.Attribute.GENERIC_MAX_HEALTH).getValue()); ++ event.setShouldPlayDeathSound(!victim.silentDeath && !victim.isSilent()); ++ SoundEffect soundEffect = victim.getDeathSoundEffect(); ++ event.setDeathSound(soundEffect != null ? org.bukkit.craftbukkit.CraftSound.getSoundByEffect(soundEffect) : null); ++ event.setDeathSoundCategory(org.bukkit.SoundCategory.valueOf(victim.getDeathSoundCategory().name())); ++ event.setDeathSoundVolume(victim.getDeathSoundVolume()); ++ event.setDeathSoundPitch(victim.getDeathSoundPitch()); ++ } ++ ++ // Play death sound manually ++ private static void playDeathSound(EntityLiving victim, EntityDeathEvent event) { ++ if (event.shouldPlayDeathSound() && event.getDeathSound() != null && event.getDeathSoundCategory() != null) { ++ EntityHuman source = victim instanceof EntityHuman ? (EntityHuman) victim : null; ++ double x = event.getEntity().getLocation().getX(); ++ double y = event.getEntity().getLocation().getY(); ++ double z = event.getEntity().getLocation().getZ(); ++ SoundEffect soundEffect = org.bukkit.craftbukkit.CraftSound.getSoundEffect(event.getDeathSound()); ++ SoundCategory soundCategory = SoundCategory.valueOf(event.getDeathSoundCategory().name()); ++ victim.world.sendSoundEffect(source, x, y, z, soundEffect, soundCategory, event.getDeathSoundVolume(), event.getDeathSoundPitch()); ++ } ++ } ++ // Paper end + /** + * Server methods + */ +-- +2.18.0 +