core
/
testserver
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
testserver/patches/server/0861-Prevent-entity-loading...

74 lines
3.1 KiB
Diff
Raw Normal View History

Prevent entity loading causing async lookups (#7553)
2022-06-02 01:35:57 +00:00
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
Date: Sun, 6 Mar 2022 11:09:09 -0500
Subject: [PATCH] Prevent entity loading causing async lookups
diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
Remove old redundant fix (#8530)
2022-11-03 21:03:31 +00:00
index d81ee5367205ba96eb23f885ec648a27f2cf62f8..7bb45ae3ed51975972e013aaf66acc352277c375 100644
Prevent entity loading causing async lookups (#7553)
2022-06-02 01:35:57 +00:00
--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
Expose isUnderWater to Entity (#8454)
2022-10-11 12:43:10 +00:00
@@ -788,6 +788,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
Prevent entity loading causing async lookups (#7553)
2022-06-02 01:35:57 +00:00
public void baseTick() {
this.level.getProfiler().push("entityBaseTick");
+ if (firstTick && this instanceof net.minecraft.world.entity.NeutralMob neutralMob) neutralMob.tickInitialPersistentAnger(level); // Paper - Update last hurt when ticking
this.feetBlockState = null;
if (this.isPassenger() && this.getVehicle().isRemoved()) {
this.stopRiding();
diff --git a/src/main/java/net/minecraft/world/entity/NeutralMob.java b/src/main/java/net/minecraft/world/entity/NeutralMob.java
Fully deserialise persistent anger post async load (#8560) The modified patch prevents entity loading off the main thread when entities are initially loaded. However, the initial loading of an entity is not the only time the Entity#readAdditionalSaveData method is called. Commands like /data also invoke the method (through Entity#load) to update an entities data without completely re-creating it. This however breaks with the current patch, as the patch moves parts of the entity lookup for persistent anger deserialisation into the first tick of an entity (which obviously is only called once and hence not re-run when an already ticking entity is modified as laid out above). This change actively runs the now split logic for deserialisation again if the entity has already ticked its first tick. This way, initial deserialisation is still split into one off thread and the first tick parts, but following main thread deserialisations can happen completely inside Entity#readAdditionalSaveData is called.
2022-12-02 17:09:41 +00:00
index dedf76de5d6f46b9626ca4a98cfffe125b90dd0c..7dac62b6370dae3ad6d098857c3136d5acf2bd74 100644
Prevent entity loading causing async lookups (#7553)
2022-06-02 01:35:57 +00:00
--- a/src/main/java/net/minecraft/world/entity/NeutralMob.java
+++ b/src/main/java/net/minecraft/world/entity/NeutralMob.java
Fully deserialise persistent anger post async load (#8560) The modified patch prevents entity loading off the main thread when entities are initially loaded. However, the initial loading of an entity is not the only time the Entity#readAdditionalSaveData method is called. Commands like /data also invoke the method (through Entity#load) to update an entities data without completely re-creating it. This however breaks with the current patch, as the patch moves parts of the entity lookup for persistent anger deserialisation into the first tick of an entity (which obviously is only called once and hence not re-run when an already ticking entity is modified as laid out above). This change actively runs the now split logic for deserialisation again if the entity has already ticked its first tick. This way, initial deserialisation is still split into one off thread and the first tick parts, but following main thread deserialisations can happen completely inside Entity#readAdditionalSaveData is called.
2022-12-02 17:09:41 +00:00
@@ -42,18 +42,11 @@ public interface NeutralMob {
Prevent entity loading causing async lookups (#7553)
2022-06-02 01:35:57 +00:00
UUID uuid = nbt.getUUID("AngryAt");
this.setPersistentAngerTarget(uuid);
- Entity entity = ((ServerLevel) world).getEntity(uuid);
-
- if (entity != null) {
- if (entity instanceof Mob) {
- this.setLastHurtByMob((Mob) entity);
- }
-
- if (entity.getType() == EntityType.PLAYER) {
- this.setLastHurtByPlayer((Player) entity);
- }
-
- }
+ // Paper - Moved diff to separate method
Fully deserialise persistent anger post async load (#8560) The modified patch prevents entity loading off the main thread when entities are initially loaded. However, the initial loading of an entity is not the only time the Entity#readAdditionalSaveData method is called. Commands like /data also invoke the method (through Entity#load) to update an entities data without completely re-creating it. This however breaks with the current patch, as the patch moves parts of the entity lookup for persistent anger deserialisation into the first tick of an entity (which obviously is only called once and hence not re-run when an already ticking entity is modified as laid out above). This change actively runs the now split logic for deserialisation again if the entity has already ticked its first tick. This way, initial deserialisation is still split into one off thread and the first tick parts, but following main thread deserialisations can happen completely inside Entity#readAdditionalSaveData is called.
2022-12-02 17:09:41 +00:00
+ // If this entity already survived its first tick, e.g. is loaded and ticked in sync, actively
+ // tick the initial persistent anger.
+ // If not, let the first tick on the baseTick call the method later down the line.
+ if (this instanceof Entity entity && !entity.firstTick) this.tickInitialPersistentAnger(world);
Prevent entity loading causing async lookups (#7553)
2022-06-02 01:35:57 +00:00
}
}
}
Fully deserialise persistent anger post async load (#8560) The modified patch prevents entity loading off the main thread when entities are initially loaded. However, the initial loading of an entity is not the only time the Entity#readAdditionalSaveData method is called. Commands like /data also invoke the method (through Entity#load) to update an entities data without completely re-creating it. This however breaks with the current patch, as the patch moves parts of the entity lookup for persistent anger deserialisation into the first tick of an entity (which obviously is only called once and hence not re-run when an already ticking entity is modified as laid out above). This change actively runs the now split logic for deserialisation again if the entity has already ticked its first tick. This way, initial deserialisation is still split into one off thread and the first tick parts, but following main thread deserialisations can happen completely inside Entity#readAdditionalSaveData is called.
2022-12-02 17:09:41 +00:00
@@ -127,4 +120,26 @@ public interface NeutralMob {
Prevent entity loading causing async lookups (#7553)
2022-06-02 01:35:57 +00:00
@Nullable
LivingEntity getTarget();
+
+ // Paper start - Update last hurt when ticking
+ default void tickInitialPersistentAnger(Level level) {
+ UUID target = getPersistentAngerTarget();
+ if (target == null) {
+ return;
+ }
+
+ Entity entity = ((ServerLevel) level).getEntity(target);
+
+ if (entity != null) {
+ if (entity instanceof Mob) {
+ this.setLastHurtByMob((Mob) entity);
+ }
+
+ if (entity.getType() == EntityType.PLAYER) {
+ this.setLastHurtByPlayer((Player) entity);
+ }
+
+ }
+ }
+ // Paper end
}