aboutsummaryrefslogtreecommitdiffhomepage
path: root/patches/server/1035-Only-call-EntityDamageEvents-before-actuallyHurt.patch
blob: f91219dbe1570705be540fd23c00708b569a81c7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Bjarne Koll <lynxplay101@gmail.com>
Date: Mon, 8 Jul 2024 22:01:08 +0200
Subject: [PATCH] Only call EntityDamageEvents before actuallyHurt

The recent upstream update moved around the event logic for
EntiyDamageEvent and its derivatives.
However, the event was called on every call to #hurt as it was moved out
of actuallyHurt.

This patch moves the invocation directly before the #actuallyHurt calls,
respective invulnerable timings.

diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
index 945da6b82653f05625f054d64bbf605a4ec1cd05..909accac7538e1c0c0c51deb2ee0605697c059d0 100644
--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
@@ -1459,12 +1459,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
             }
 
             // CraftBukkit start
-            EntityDamageEvent event = this.handleEntityDamage(source, amount);
-            amount = 0;
-            amount += (float) event.getDamage(DamageModifier.BASE);
-            amount += (float) event.getDamage(DamageModifier.BLOCKING);
-            amount += (float) event.getDamage(DamageModifier.FREEZING);
-            amount += (float) event.getDamage(DamageModifier.HARD_HAT);
+            EntityDamageEvent event; // Paper - move this into the actual invuln check....
             // CraftBukkit end
 
             this.walkAnimation.setSpeed(1.5F);
@@ -1475,6 +1470,11 @@ public abstract class LivingEntity extends Entity implements Attackable {
                     return false;
                 }
 
+                // Paper start - only call damage event when actuallyHurt will be called - move call logic down
+                event = this.handleEntityDamage(source, amount);
+                amount = computeAmountFromEntityDamageEvent(event);
+                // Paper end - only call damage event when actuallyHurt will be called - move call logic down
+
                 // CraftBukkit start
                 if (!this.actuallyHurt(source, (float) event.getFinalDamage() - this.lastHurt, event)) {
                     return false;
@@ -1484,6 +1484,10 @@ public abstract class LivingEntity extends Entity implements Attackable {
                 this.lastHurt = amount;
                 flag1 = false;
             } else {
+                // Paper start - only call damage event when actuallyHurt will be called - move call logic down
+                event = this.handleEntityDamage(source, amount);
+                amount = computeAmountFromEntityDamageEvent(event);
+                // Paper end - only call damage event when actuallyHurt will be called - move call logic down
                 // CraftBukkit start
                 if (!this.actuallyHurt(source, (float) event.getFinalDamage(), event)) {
                     return false;
@@ -1615,6 +1619,18 @@ public abstract class LivingEntity extends Entity implements Attackable {
         }
     }
 
+    // Paper start - only call damage event when actuallyHurt will be called - move out amount computation logic
+    private float computeAmountFromEntityDamageEvent(final EntityDamageEvent event) {
+        // Taken from hurt()'s craftbukkit diff.
+        float amount = 0;
+        amount += (float) event.getDamage(DamageModifier.BASE);
+        amount += (float) event.getDamage(DamageModifier.BLOCKING);
+        amount += (float) event.getDamage(DamageModifier.FREEZING);
+        amount += (float) event.getDamage(DamageModifier.HARD_HAT);
+        return amount;
+    }
+    // Paper end - only call damage event when actuallyHurt will be called - move out amount computation logic
+
     protected void blockUsingShield(LivingEntity attacker) {
         attacker.blockedByShield(this);
     }