SPIGOT-7300, #1180: Add new DamageSource API providing enhanced information about entity damage

By: Doc <nachito94@msn.com>

paper-server/src/main/java/org/bukkit/craftbukkit/CraftRegistry.java

@@ -16,6 +16,7 @@ import org.bukkit.Keyed;
 import org.bukkit.MusicInstrument;
 import org.bukkit.NamespacedKey;
 import org.bukkit.Registry;
+import org.bukkit.craftbukkit.damage.CraftDamageType;
 import org.bukkit.craftbukkit.enchantments.CraftEnchantment;
 import org.bukkit.craftbukkit.generator.structure.CraftStructure;
 import org.bukkit.craftbukkit.generator.structure.CraftStructureType;
@@ -24,6 +25,7 @@ import org.bukkit.craftbukkit.inventory.trim.CraftTrimPattern;
 import org.bukkit.craftbukkit.potion.CraftPotionEffectType;
 import org.bukkit.craftbukkit.util.CraftNamespacedKey;
 import org.bukkit.craftbukkit.util.Handleable;
+import org.bukkit.damage.DamageType;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.generator.structure.Structure;
 import org.bukkit.generator.structure.StructureType;
@@ -115,6 +117,9 @@ public class CraftRegistry<B extends Keyed, M> implements Registry<B> {
         if (bukkitClass == TrimPattern.class) {
             return new CraftRegistry<>(TrimPattern.class, registryHolder.registryOrThrow(Registries.TRIM_PATTERN), CraftTrimPattern::new);
         }
+        if (bukkitClass == DamageType.class) {
+            return new CraftRegistry<>(DamageType.class, registryHolder.registryOrThrow(Registries.DAMAGE_TYPE), CraftDamageType::new);
+        }
 
         return null;
     }

paper-server/src/main/java/org/bukkit/craftbukkit/damage/CraftDamageEffect.java

@@ -0,0 +1,37 @@
+package org.bukkit.craftbukkit.damage;
+
+import net.minecraft.world.damagesource.DamageEffects;
+import org.bukkit.Sound;
+import org.bukkit.craftbukkit.CraftSound;
+import org.bukkit.damage.DamageEffect;
+
+public class CraftDamageEffect implements DamageEffect {
+
+    private final DamageEffects damageEffects;
+
+    public CraftDamageEffect(DamageEffects damageEffects) {
+        this.damageEffects = damageEffects;
+    }
+
+    public DamageEffects getHandle() {
+        return this.damageEffects;
+    }
+
+    @Override
+    public Sound getSound() {
+        return CraftSound.minecraftToBukkit(this.getHandle().sound());
+    }
+
+    public static DamageEffect getById(String id) {
+        for (DamageEffects damageEffects : DamageEffects.values()) {
+            if (damageEffects.getSerializedName().equalsIgnoreCase(id)) {
+                return toBukkit(damageEffects);
+            }
+        }
+        return null;
+    }
+
+    public static DamageEffect toBukkit(DamageEffects damageEffects) {
+        return new CraftDamageEffect(damageEffects);
+    }
+}

paper-server/src/main/java/org/bukkit/craftbukkit/damage/CraftDamageSource.java

@@ -0,0 +1,128 @@
+package org.bukkit.craftbukkit.damage;
+
+import java.util.Objects;
+import net.minecraft.world.phys.Vec3D;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.craftbukkit.entity.CraftEntity;
+import org.bukkit.craftbukkit.util.CraftLocation;
+import org.bukkit.damage.DamageSource;
+import org.bukkit.damage.DamageType;
+import org.bukkit.entity.Entity;
+
+public class CraftDamageSource implements DamageSource {
+
+    private final net.minecraft.world.damagesource.DamageSource damageSource;
+    private final DamageType damageType;
+
+    public CraftDamageSource(net.minecraft.world.damagesource.DamageSource damageSource) {
+        this.damageSource = damageSource;
+        this.damageType = CraftDamageType.minecraftHolderToBukkit(damageSource.typeHolder());
+    }
+
+    public net.minecraft.world.damagesource.DamageSource getHandle() {
+        return this.damageSource;
+    }
+
+    public World getCausingEntityWorld() {
+        org.bukkit.entity.Entity causingEntity = getCausingEntity();
+        return causingEntity != null ? causingEntity.getWorld() : null;
+    }
+
+    public Block getDirectBlock() {
+        return this.getHandle().getDirectBlock();
+    }
+
+    @Override
+    public DamageType getDamageType() {
+        return this.damageType;
+    }
+
+    @Override
+    public org.bukkit.entity.Entity getCausingEntity() {
+        net.minecraft.world.entity.Entity entity = this.getHandle().getCausingEntity();
+        return (entity != null) ? entity.getBukkitEntity() : null;
+    }
+
+    @Override
+    public org.bukkit.entity.Entity getDirectEntity() {
+        net.minecraft.world.entity.Entity entity = this.getHandle().getDirectEntity();
+        return (entity != null) ? entity.getBukkitEntity() : null;
+    }
+
+    @Override
+    public Location getDamageLocation() {
+        Vec3D vec3D = this.getHandle().sourcePositionRaw();
+        return (vec3D != null) ? CraftLocation.toBukkit(vec3D, this.getCausingEntityWorld()) : null;
+    }
+
+    @Override
+    public Location getSourceLocation() {
+        Vec3D vec3D = this.getHandle().getSourcePosition();
+        return (vec3D != null) ? CraftLocation.toBukkit(vec3D, this.getCausingEntityWorld()) : null;
+    }
+
+    @Override
+    public boolean isIndirect() {
+        return this.getHandle().getCausingEntity() != this.getHandle().getDirectEntity();
+    }
+
+    @Override
+    public float getFoodExhaustion() {
+        return this.damageType.getExhaustion();
+    }
+
+    @Override
+    public boolean scalesWithDifficulty() {
+        return this.getHandle().scalesWithDifficulty();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+
+        if (!(obj instanceof DamageSource)) {
+            return false;
+        }
+
+        DamageSource other = (DamageSource) obj;
+        return Objects.equals(this.getDamageType(), other.getDamageType()) && Objects.equals(this.getCausingEntity(), other.getCausingEntity())
+                && Objects.equals(this.getDirectEntity(), other.getDirectEntity()) && Objects.equals(this.getDamageLocation(), other.getDamageLocation());
+    }
+
+    @Override
+    public int hashCode() {
+        int result = 1;
+        result = 31 * result + this.damageType.hashCode();
+        result = 31 * result + (this.getCausingEntity() != null ? this.getCausingEntity().hashCode() : 0);
+        result = 31 * result + (this.getDirectEntity() != null ? this.getDirectEntity().hashCode() : 0);
+        result = 31 * result + (this.getDamageLocation() != null ? this.getDamageLocation().hashCode() : 0);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "DamageSource{damageType=" + this.getDamageType() + ",causingEntity=" + this.getCausingEntity() + ",directEntity=" + this.getDirectEntity() + ",damageLocation=" + this.getDamageLocation() + "}";
+    }
+
+    public static DamageSource buildFromBukkit(DamageType damageType, Entity causingEntity, Entity directEntity, Location damageLocation) {
+        net.minecraft.core.Holder<net.minecraft.world.damagesource.DamageType> holderDamageType = CraftDamageType.bukkitToMinecraftHolder(damageType);
+
+        net.minecraft.world.entity.Entity nmsCausingEntity = null;
+        if (causingEntity instanceof CraftEntity craftCausingEntity) {
+            nmsCausingEntity = craftCausingEntity.getHandle();
+        }
+
+        net.minecraft.world.entity.Entity nmsDirectEntity = null;
+        if (directEntity instanceof CraftEntity craftDirectEntity) {
+            nmsDirectEntity = craftDirectEntity.getHandle();
+        }
+
+        Vec3D vec3D = (damageLocation == null) ? null : CraftLocation.toVec3D(damageLocation);
+
+        return new CraftDamageSource(new net.minecraft.world.damagesource.DamageSource(holderDamageType, nmsDirectEntity, nmsCausingEntity, vec3D));
+    }
+}

paper-server/src/main/java/org/bukkit/craftbukkit/damage/CraftDamageSourceBuilder.java

@@ -0,0 +1,46 @@
+package org.bukkit.craftbukkit.damage;
+
+import com.google.common.base.Preconditions;
+import org.bukkit.Location;
+import org.bukkit.damage.DamageSource;
+import org.bukkit.damage.DamageType;
+import org.bukkit.entity.Entity;
+
+public class CraftDamageSourceBuilder implements DamageSource.Builder {
+
+    private final DamageType damageType;
+    private Entity causingEntity;
+    private Entity directEntity;
+    private Location damageLocation;
+
+    public CraftDamageSourceBuilder(DamageType damageType) {
+        Preconditions.checkArgument(damageType != null, "DamageType cannot be null");
+        this.damageType = damageType;
+    }
+
+    @Override
+    public DamageSource.Builder withCausingEntity(Entity entity) {
+        Preconditions.checkArgument(entity != null, "Entity cannot be null");
+        this.causingEntity = entity;
+        return this;
+    }
+
+    @Override
+    public DamageSource.Builder withDirectEntity(Entity entity) {
+        Preconditions.checkArgument(entity != null, "Entity cannot be null");
+        this.directEntity = entity;
+        return this;
+    }
+
+    @Override
+    public DamageSource.Builder withDamageLocation(Location location) {
+        Preconditions.checkArgument(location != null, "Location cannot be null");
+        this.damageLocation = location.clone();
+        return this;
+    }
+
+    @Override
+    public DamageSource build() {
+        return CraftDamageSource.buildFromBukkit(damageType, causingEntity, directEntity, damageLocation);
+    }
+}

paper-server/src/main/java/org/bukkit/craftbukkit/damage/CraftDamageType.java

@@ -0,0 +1,126 @@
+package org.bukkit.craftbukkit.damage;
+
+import com.google.common.base.Preconditions;
+import net.minecraft.core.Holder;
+import net.minecraft.core.IRegistry;
+import net.minecraft.core.registries.Registries;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Registry;
+import org.bukkit.craftbukkit.CraftRegistry;
+import org.bukkit.craftbukkit.util.Handleable;
+import org.bukkit.damage.DamageEffect;
+import org.bukkit.damage.DamageScaling;
+import org.bukkit.damage.DamageType;
+import org.bukkit.damage.DeathMessageType;
+
+public class CraftDamageType implements DamageType, Handleable<net.minecraft.world.damagesource.DamageType> {
+
+    private final NamespacedKey key;
+    private final net.minecraft.world.damagesource.DamageType damageType;
+
+    public CraftDamageType(NamespacedKey key, net.minecraft.world.damagesource.DamageType damageType) {
+        this.key = key;
+        this.damageType = damageType;
+    }
+
+    @Override
+    public net.minecraft.world.damagesource.DamageType getHandle() {
+        return this.damageType;
+    }
+
+    @Override
+    public String getTranslationKey() {
+        return this.getHandle().msgId();
+    }
+
+    @Override
+    public DamageScaling getDamageScaling() {
+        return damageScalingToBukkit(this.getHandle().scaling());
+    }
+
+    @Override
+    public DamageEffect getDamageEffect() {
+        return CraftDamageEffect.toBukkit(this.getHandle().effects());
+    }
+
+    @Override
+    public DeathMessageType getDeathMessageType() {
+        return deathMessageTypeToBukkit(this.getHandle().deathMessageType());
+    }
+
+    @Override
+    public float getExhaustion() {
+        return this.getHandle().exhaustion();
+    }
+
+    @Override
+    public NamespacedKey getKey() {
+        return this.key;
+    }
+
+    @Override
+    public String toString() {
+        return "CraftDamageType{" + "key=" + this.getKey() + ",damageScaling=" + this.getDamageScaling() + ",damageEffect=" + this.getDamageEffect() + ",deathMessageType=" + this.getDeathMessageType() + ",exhaustion=" + this.getExhaustion() + "}";
+    }
+
+    public static DeathMessageType deathMessageTypeToBukkit(net.minecraft.world.damagesource.DeathMessageType deathMessageType) {
+        return switch (deathMessageType) {
+            case DEFAULT -> DeathMessageType.DEFAULT;
+            case FALL_VARIANTS -> DeathMessageType.FALL_VARIANTS;
+            case INTENTIONAL_GAME_DESIGN -> DeathMessageType.INTENTIONAL_GAME_DESIGN;
+            default -> throw new IllegalArgumentException("NMS DeathMessageType." + deathMessageType + " cannot be converted to a Bukkit DeathMessageType.");
+        };
+    }
+
+    public static net.minecraft.world.damagesource.DeathMessageType deathMessageTypeToNMS(DeathMessageType deathMessageType) {
+        return switch (deathMessageType) {
+            case DEFAULT -> net.minecraft.world.damagesource.DeathMessageType.DEFAULT;
+            case FALL_VARIANTS -> net.minecraft.world.damagesource.DeathMessageType.FALL_VARIANTS;
+            case INTENTIONAL_GAME_DESIGN -> net.minecraft.world.damagesource.DeathMessageType.INTENTIONAL_GAME_DESIGN;
+            default -> throw new IllegalArgumentException("Bukkit DeathMessageType." + deathMessageType + " cannot be converted to a NMS DeathMessageType.");
+        };
+    }
+
+    public static DamageScaling damageScalingToBukkit(net.minecraft.world.damagesource.DamageScaling damageScaling) {
+        return switch (damageScaling) {
+            case ALWAYS -> DamageScaling.ALWAYS;
+            case WHEN_CAUSED_BY_LIVING_NON_PLAYER -> DamageScaling.WHEN_CAUSED_BY_LIVING_NON_PLAYER;
+            case NEVER -> DamageScaling.NEVER;
+            default -> throw new IllegalArgumentException("NMS DamageScaling." + damageScaling + " cannot be converted to a Bukkit DamageScaling");
+        };
+    }
+
+    public static net.minecraft.world.damagesource.DamageScaling damageScalingToNMS(DamageScaling damageScaling) {
+        return switch (damageScaling) {
+            case ALWAYS -> net.minecraft.world.damagesource.DamageScaling.ALWAYS;
+            case WHEN_CAUSED_BY_LIVING_NON_PLAYER -> net.minecraft.world.damagesource.DamageScaling.WHEN_CAUSED_BY_LIVING_NON_PLAYER;
+            case NEVER -> net.minecraft.world.damagesource.DamageScaling.NEVER;
+            default -> throw new IllegalArgumentException("Bukkit DamageScaling." + damageScaling + " cannot be converted to a NMS DamageScaling");
+        };
+    }
+
+    public static DamageType minecraftHolderToBukkit(Holder<net.minecraft.world.damagesource.DamageType> minecraftHolder) {
+        return minecraftToBukkit(minecraftHolder.value());
+    }
+
+    public static Holder<net.minecraft.world.damagesource.DamageType> bukkitToMinecraftHolder(DamageType bukkitDamageType) {
+        Preconditions.checkArgument(bukkitDamageType != null);
+
+        IRegistry<net.minecraft.world.damagesource.DamageType> registry = CraftRegistry.getMinecraftRegistry(Registries.DAMAGE_TYPE);
+
+        if (registry.wrapAsHolder(bukkitToMinecraft(bukkitDamageType)) instanceof Holder.c<net.minecraft.world.damagesource.DamageType> holder) {
+            return holder;
+        }
+
+        throw new IllegalArgumentException("No Reference holder found for " + bukkitDamageType
+                + ", this can happen if a plugin creates its own damage type with out properly registering it.");
+    }
+
+    public static net.minecraft.world.damagesource.DamageType bukkitToMinecraft(DamageType bukkitDamageType) {
+        return CraftRegistry.bukkitToMinecraft(bukkitDamageType);
+    }
+
+    public static DamageType minecraftToBukkit(net.minecraft.world.damagesource.DamageType minecraftDamageType) {
+        return CraftRegistry.minecraftToBukkit(minecraftDamageType, Registries.DAMAGE_TYPE, Registry.DAMAGE_TYPE);
+    }
+}

paper-server/src/main/java/org/bukkit/craftbukkit/entity/CraftEnderDragonPart.java

@@ -2,6 +2,7 @@ package org.bukkit.craftbukkit.entity;
 
 import net.minecraft.world.entity.boss.EntityComplexPart;
 import org.bukkit.craftbukkit.CraftServer;
+import org.bukkit.damage.DamageSource;
 import org.bukkit.entity.EnderDragon;
 import org.bukkit.entity.EnderDragonPart;
 import org.bukkit.entity.Entity;
@@ -26,6 +27,11 @@ public class CraftEnderDragonPart extends CraftComplexPart implements EnderDrago
         return "CraftEnderDragonPart";
     }
 
+    @Override
+    public void damage(double amount, DamageSource damageSource) {
+        getParent().damage(amount, damageSource);
+    }
+
     @Override
     public void damage(double amount) {
         getParent().damage(amount);

paper-server/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java

@@ -51,6 +51,7 @@ import org.bukkit.block.Block;
 import org.bukkit.craftbukkit.CraftServer;
 import org.bukkit.craftbukkit.CraftSound;
 import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.damage.CraftDamageSource;
 import org.bukkit.craftbukkit.entity.memory.CraftMemoryKey;
 import org.bukkit.craftbukkit.entity.memory.CraftMemoryMapper;
 import org.bukkit.craftbukkit.inventory.CraftEntityEquipment;
@@ -280,13 +281,11 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
 
     @Override
     public void damage(double amount) {
-        damage(amount, null);
+        damage(amount, getHandle().damageSources().generic());
     }
 
     @Override
     public void damage(double amount, org.bukkit.entity.Entity source) {
-        Preconditions.checkState(!getHandle().generation, "Cannot damage entity during world generation");
-
         DamageSource reason = getHandle().damageSources().generic();
 
         if (source instanceof HumanEntity) {
@@ -295,7 +294,21 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
             reason = getHandle().damageSources().mobAttack(((CraftLivingEntity) source).getHandle());
         }
 
-        entity.hurt(reason, (float) amount);
+        damage(amount, reason);
+    }
+
+    @Override
+    public void damage(double amount, org.bukkit.damage.DamageSource damageSource) {
+        Preconditions.checkArgument(damageSource != null, "damageSource cannot be null");
+
+        damage(amount, ((CraftDamageSource) damageSource).getHandle());
+    }
+
+    private void damage(double amount, DamageSource damageSource) {
+        Preconditions.checkArgument(damageSource != null, "damageSource cannot be null");
+        Preconditions.checkState(!getHandle().generation, "Cannot damage entity during world generation");
+
+        entity.hurt(damageSource, (float) amount);
     }
 
     @Override

paper-server/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java

@@ -39,7 +39,6 @@ import net.minecraft.world.entity.animal.EntityAnimal;
 import net.minecraft.world.entity.animal.EntityFish;
 import net.minecraft.world.entity.animal.EntityGolem;
 import net.minecraft.world.entity.animal.EntityWaterAnimal;
-import net.minecraft.world.entity.boss.enderdragon.EntityEnderDragon;
 import net.minecraft.world.entity.item.EntityItem;
 import net.minecraft.world.entity.monster.EntityGhast;
 import net.minecraft.world.entity.monster.EntityIllagerWizard;
@@ -95,6 +94,7 @@ import org.bukkit.craftbukkit.block.CraftBlock;
 import org.bukkit.craftbukkit.block.CraftBlockState;
 import org.bukkit.craftbukkit.block.CraftBlockStates;
 import org.bukkit.craftbukkit.block.data.CraftBlockData;
+import org.bukkit.craftbukkit.damage.CraftDamageSource;
 import org.bukkit.craftbukkit.entity.CraftEntity;
 import org.bukkit.craftbukkit.entity.CraftLivingEntity;
 import org.bukkit.craftbukkit.entity.CraftPlayer;
@@ -258,8 +258,6 @@ import org.bukkit.potion.PotionEffect;
 import org.bukkit.util.Vector;
 
 public class CraftEventFactory {
-    public static org.bukkit.block.Block blockDamage; // For use in EntityDamageByBlockEvent
-    public static Entity entityDamage; // For use in EntityDamageByEntityEvent
 
     // helper methods
     private static boolean canBuild(WorldServer world, Player player, int x, int z) {
@@ -939,38 +937,18 @@ public class CraftEventFactory {
     }
 
     private static EntityDamageEvent handleEntityDamageEvent(Entity entity, DamageSource source, Map<DamageModifier, Double> modifiers, Map<DamageModifier, Function<? super Double, Double>> modifierFunctions, boolean cancelled) {
+        CraftDamageSource bukkitDamageSource = new CraftDamageSource(source);
+        Entity damager = source.getCausingEntity();
         if (source.is(DamageTypeTags.IS_EXPLOSION)) {
-            DamageCause damageCause;
-            Entity damager = entityDamage;
-            entityDamage = null;
-            EntityDamageEvent event;
             if (damager == null) {
-                event = new EntityDamageByBlockEvent(null, entity.getBukkitEntity(), DamageCause.BLOCK_EXPLOSION, modifiers, modifierFunctions);
-            } else if (entity instanceof EntityEnderDragon && /*PAIL FIXME ((EntityEnderDragon) entity).target == damager*/ false) {
-                event = new EntityDamageEvent(entity.getBukkitEntity(), DamageCause.ENTITY_EXPLOSION, modifiers, modifierFunctions);
-            } else {
-                if (damager instanceof org.bukkit.entity.TNTPrimed) {
-                    damageCause = DamageCause.BLOCK_EXPLOSION;
-                } else {
-                    damageCause = DamageCause.ENTITY_EXPLOSION;
-                }
-                event = new EntityDamageByEntityEvent(damager.getBukkitEntity(), entity.getBukkitEntity(), damageCause, modifiers, modifierFunctions);
+                return callEntityDamageEvent(source.getDirectBlock(), entity, DamageCause.BLOCK_EXPLOSION, bukkitDamageSource, modifiers, modifierFunctions, cancelled);
             }
-            event.setCancelled(cancelled);
-
-            callEvent(event);
-
-            if (!event.isCancelled()) {
-                event.getEntity().setLastDamageCause(event);
-            } else {
-                entity.lastDamageCancelled = true; // SPIGOT-5339, SPIGOT-6252, SPIGOT-6777: Keep track if the event was canceled
-            }
-            return event;
-        } else if (source.getEntity() != null || source.getDirectEntity() != null) {
-            Entity damager = source.getEntity();
+            DamageCause damageCause = (damager.getBukkitEntity() instanceof org.bukkit.entity.TNTPrimed) ? DamageCause.BLOCK_EXPLOSION : DamageCause.ENTITY_EXPLOSION;
+            return callEntityDamageEvent(damager, entity, damageCause, bukkitDamageSource, modifiers, modifierFunctions, cancelled);
+        } else if (damager != null || source.getDirectEntity() != null) {
             DamageCause cause = (source.isSweep()) ? DamageCause.ENTITY_SWEEP_ATTACK : DamageCause.ENTITY_ATTACK;
 
-            if (source.isIndirect() && source.getDirectEntity() != null) {
+            if (bukkitDamageSource.isIndirect() && source.getDirectEntity() != null) {
                 damager = source.getDirectEntity();
             }
 
@@ -984,37 +962,25 @@ public class CraftEventFactory {
                 cause = DamageCause.THORNS;
             } else if (source.is(DamageTypes.SONIC_BOOM)) {
                 cause = DamageCause.SONIC_BOOM;
+            } else if (source.is(DamageTypes.FALLING_STALACTITE) || source.is(DamageTypes.FALLING_BLOCK) || source.is(DamageTypes.FALLING_ANVIL)) {
+                cause = DamageCause.FALLING_BLOCK;
+            } else if (source.is(DamageTypes.LIGHTNING_BOLT)) {
+                cause = DamageCause.LIGHTNING;
+            } else if (source.is(DamageTypes.FALL)) {
+                cause = DamageCause.FALL;
+            } else if (source.is(DamageTypes.DRAGON_BREATH)) {
+                cause = DamageCause.DRAGON_BREATH;
+            } else if (source.is(DamageTypes.MAGIC)) {
+                cause = DamageCause.MAGIC;
             }
 
-            return callEntityDamageEvent(damager, entity, cause, modifiers, modifierFunctions, cancelled);
+            return callEntityDamageEvent(damager, entity, cause, bukkitDamageSource, modifiers, modifierFunctions, cancelled);
         } else if (source.is(DamageTypes.FELL_OUT_OF_WORLD)) {
-            EntityDamageEvent event = new EntityDamageByBlockEvent(null, entity.getBukkitEntity(), DamageCause.VOID, modifiers, modifierFunctions);
-            event.setCancelled(cancelled);
-            callEvent(event);
-            if (!event.isCancelled()) {
-                event.getEntity().setLastDamageCause(event);
-            } else {
-                entity.lastDamageCancelled = true; // SPIGOT-5339, SPIGOT-6252, SPIGOT-6777: Keep track if the event was canceled
-            }
-            return event;
+            return callEntityDamageEvent(source.getDirectBlock(), entity, DamageCause.VOID, bukkitDamageSource, modifiers, modifierFunctions, cancelled);
         } else if (source.is(DamageTypes.LAVA)) {
-            EntityDamageEvent event = (new EntityDamageByBlockEvent(blockDamage, entity.getBukkitEntity(), DamageCause.LAVA, modifiers, modifierFunctions));
-            event.setCancelled(cancelled);
-
-            Block damager = blockDamage;
-            blockDamage = null; // SPIGOT-6639: Clear blockDamage to allow other entity damage during event call
-            callEvent(event);
-            blockDamage = damager; // SPIGOT-6639: Re-set blockDamage so that other entities which are also getting damaged have the right cause
-
-            if (!event.isCancelled()) {
-                event.getEntity().setLastDamageCause(event);
-            } else {
-                entity.lastDamageCancelled = true; // SPIGOT-5339, SPIGOT-6252, SPIGOT-6777: Keep track if the event was canceled
-            }
-            return event;
-        } else if (blockDamage != null) {
-            DamageCause cause = null;
-            Block damager = blockDamage;
+            return callEntityDamageEvent(source.getDirectBlock(), entity, DamageCause.LAVA, bukkitDamageSource, modifiers, modifierFunctions, cancelled);
+        } else if (source.getDirectBlock() != null) {
+            DamageCause cause;
             if (source.is(DamageTypes.CACTUS) || source.is(DamageTypes.SWEET_BERRY_BUSH) || source.is(DamageTypes.STALAGMITE) || source.is(DamageTypes.FALLING_STALACTITE) || source.is(DamageTypes.FALLING_ANVIL)) {
                 cause = DamageCause.CONTACT;
             } else if (source.is(DamageTypes.HOT_FLOOR)) {
@@ -1024,50 +990,12 @@ public class CraftEventFactory {
             } else if (source.is(DamageTypes.IN_FIRE)) {
                 cause = DamageCause.FIRE;
             } else {
-                throw new IllegalStateException(String.format("Unhandled damage of %s by %s from %s", entity, damager, source.getMsgId()));
+                throw new IllegalStateException(String.format("Unhandled damage of %s by %s from %s", entity, source.getDirectBlock(), source.getMsgId()));
             }
-            EntityDamageEvent event = new EntityDamageByBlockEvent(damager, entity.getBukkitEntity(), cause, modifiers, modifierFunctions);
-            event.setCancelled(cancelled);
-
-            blockDamage = null; // SPIGOT-6639: Clear blockDamage to allow other entity damage during event call
-            callEvent(event);
-            blockDamage = damager; // SPIGOT-6639: Re-set blockDamage so that other entities which are also getting damaged have the right cause
-
-            if (!event.isCancelled()) {
-                event.getEntity().setLastDamageCause(event);
-            } else {
-                entity.lastDamageCancelled = true; // SPIGOT-5339, SPIGOT-6252, SPIGOT-6777: Keep track if the event was canceled
-            }
-            return event;
-        } else if (entityDamage != null) {
-            DamageCause cause = null;
-            CraftEntity damager = entityDamage.getBukkitEntity();
-            entityDamage = null;
-            if (source.is(DamageTypes.FALLING_STALACTITE) || source.is(DamageTypes.FALLING_BLOCK) || source.is(DamageTypes.FALLING_ANVIL)) {
-                cause = DamageCause.FALLING_BLOCK;
-            } else if (damager instanceof LightningStrike) {
-                cause = DamageCause.LIGHTNING;
-            } else if (source.is(DamageTypes.FALL)) {
-                cause = DamageCause.FALL;
-            } else if (source.is(DamageTypes.DRAGON_BREATH)) {
-                cause = DamageCause.DRAGON_BREATH;
-            } else if (source.is(DamageTypes.MAGIC)) {
-                cause = DamageCause.MAGIC;
-            } else {
-                throw new IllegalStateException(String.format("Unhandled damage of %s by %s from %s", entity, damager.getHandle(), source.getMsgId()));
-            }
-            EntityDamageEvent event = new EntityDamageByEntityEvent(damager, entity.getBukkitEntity(), cause, modifiers, modifierFunctions);
-            event.setCancelled(cancelled);
-            callEvent(event);
-            if (!event.isCancelled()) {
-                event.getEntity().setLastDamageCause(event);
-            } else {
-                entity.lastDamageCancelled = true; // SPIGOT-5339, SPIGOT-6252, SPIGOT-6777: Keep track if the event was canceled
-            }
-            return event;
+            return callEntityDamageEvent(source.getDirectBlock(), entity, cause, bukkitDamageSource, modifiers, modifierFunctions, cancelled);
         }
 
-        DamageCause cause = null;
+        DamageCause cause;
         if (source.is(DamageTypes.IN_FIRE)) {
             cause = DamageCause.FIRE;
         } else if (source.is(DamageTypes.STARVE)) {
@@ -1104,24 +1032,25 @@ public class CraftEventFactory {
             cause = DamageCause.CUSTOM;
         }
 
-        if (cause != null) {
-            return callEntityDamageEvent(null, entity, cause, modifiers, modifierFunctions, cancelled);
-        }
-
-        throw new IllegalStateException(String.format("Unhandled damage of %s from %s", entity, source.getMsgId()));
+        return callEntityDamageEvent((Entity) null, entity, cause, bukkitDamageSource, modifiers, modifierFunctions, cancelled);
     }
 
-    private static EntityDamageEvent callEntityDamageEvent(Entity damager, Entity damagee, DamageCause cause, Map<DamageModifier, Double> modifiers, Map<DamageModifier, Function<? super Double, Double>> modifierFunctions) {
-        return callEntityDamageEvent(damager, damagee, cause, modifiers, modifierFunctions, false);
-    }
-
-    private static EntityDamageEvent callEntityDamageEvent(Entity damager, Entity damagee, DamageCause cause, Map<DamageModifier, Double> modifiers, Map<DamageModifier, Function<? super Double, Double>> modifierFunctions, boolean cancelled) {
+    private static EntityDamageEvent callEntityDamageEvent(Entity damager, Entity damagee, DamageCause cause, org.bukkit.damage.DamageSource bukkitDamageSource, Map<DamageModifier, Double> modifiers, Map<DamageModifier, Function<? super Double, Double>> modifierFunctions, boolean cancelled) {
         EntityDamageEvent event;
         if (damager != null) {
-            event = new EntityDamageByEntityEvent(damager.getBukkitEntity(), damagee.getBukkitEntity(), cause, modifiers, modifierFunctions);
+            event = new EntityDamageByEntityEvent(damager.getBukkitEntity(), damagee.getBukkitEntity(), cause, bukkitDamageSource, modifiers, modifierFunctions);
         } else {
-            event = new EntityDamageEvent(damagee.getBukkitEntity(), cause, modifiers, modifierFunctions);
+            event = new EntityDamageEvent(damagee.getBukkitEntity(), cause, bukkitDamageSource, modifiers, modifierFunctions);
         }
+        return callEntityDamageEvent(event, damagee, cancelled);
+    }
+
+    private static EntityDamageEvent callEntityDamageEvent(Block damager, Entity damagee, DamageCause cause, org.bukkit.damage.DamageSource bukkitDamageSource, Map<DamageModifier, Double> modifiers, Map<DamageModifier, Function<? super Double, Double>> modifierFunctions, boolean cancelled) {
+        EntityDamageByBlockEvent event = new EntityDamageByBlockEvent(damager, damagee.getBukkitEntity(), cause, bukkitDamageSource, modifiers, modifierFunctions);
+        return callEntityDamageEvent(event, damagee, cancelled);
+    }
+
+    private static EntityDamageEvent callEntityDamageEvent(EntityDamageEvent event, Entity damagee, boolean cancelled) {
         event.setCancelled(cancelled);
         callEvent(event);
 

paper-server/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java

@@ -57,9 +57,14 @@ import org.bukkit.craftbukkit.CraftRegistry;
 import org.bukkit.craftbukkit.attribute.CraftAttribute;
 import org.bukkit.craftbukkit.attribute.CraftAttributeInstance;
 import org.bukkit.craftbukkit.block.data.CraftBlockData;
+import org.bukkit.craftbukkit.damage.CraftDamageEffect;
+import org.bukkit.craftbukkit.damage.CraftDamageSourceBuilder;
 import org.bukkit.craftbukkit.inventory.CraftItemStack;
 import org.bukkit.craftbukkit.legacy.CraftLegacy;
 import org.bukkit.craftbukkit.potion.CraftPotionType;
+import org.bukkit.damage.DamageEffect;
+import org.bukkit.damage.DamageSource;
+import org.bukkit.damage.DamageType;
 import org.bukkit.entity.EntityType;
 import org.bukkit.inventory.CreativeCategory;
 import org.bukkit.inventory.EquipmentSlot;
@@ -384,6 +389,17 @@ public final class CraftMagicNumbers implements UnsafeValues {
         return new CraftPotionType(namespacedKey, potionRegistry);
     }
 
+    @Override
+    public DamageEffect getDamageEffect(String key) {
+        Preconditions.checkArgument(key != null, "key cannot be null");
+        return CraftDamageEffect.getById(key);
+    }
+
+    @Override
+    public DamageSource.Builder createDamageSourceBuilder(DamageType damageType) {
+        return new CraftDamageSourceBuilder(damageType);
+    }
+
     /**
      * This helper class represents the different NBT Tags.
      * <p>