mirror of
https://github.com/PaperMC/Paper.git
synced 2024-09-12 06:58:11 +02:00
Upstream has released updates that appears to apply and compile correctly. This update has not been tested by PaperMC and as with ANY update, please do your own testing Bukkit Changes: b2f1908c SPIGOT-5783: Add helpful info to UnknownDependencyException e4f46260 SPIGOT-2623: Add EntityEquipment methods to get/set ItemStacks by slot. 529a9a69 SPIGOT-5751: Clarify behaviour of block drop-related API methods CraftBukkit Changes:8ea9b138
Remove outdated build delay.ffc2b251
Revert "#675: Fix redirected CommandNodes sometimes not being properly redirected"cb701f6b
#675: Fix redirected CommandNodes sometimes not being properly redirectedc9d7c16b
SPIGOT-2623: Add EntityEquipment methods to get/set ItemStacks by slot.fad2494a
#673: Fix Craftworld#isChunkLoaded8637ec00
SPIGOT-5751: Made breakNaturally and getDrops returns the correct item if no argument is given Spigot Changes: a99063f7 Rebuild patches Fixes #3602
217 lines
11 KiB
Diff
217 lines
11 KiB
Diff
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
|
|
From: Spottedleaf <Spottedleaf@users.noreply.github.com>
|
|
Date: Wed, 15 Apr 2020 18:08:53 -0700
|
|
Subject: [PATCH] Optimise entity hard collision checking
|
|
|
|
Very few entities actually hard collide, so store them in their own
|
|
entity slices and provide a special getEntites type call just for them.
|
|
This reduces entity collision checking impact (in my testing) by 25%
|
|
for crammed entities (shove 130 cows into an 8x6 area in one chunk).
|
|
Less crammed entities are likely to show significantly less benefit.
|
|
Effectively, this patch optimises crammed entity situations.
|
|
|
|
diff --git a/src/main/java/net/minecraft/server/Chunk.java b/src/main/java/net/minecraft/server/Chunk.java
|
|
index 74d110874d0a9c1603d6b2d77753179ba49811ea..cf86ce24e12068d6ff7ae43cb1fd6fe665c24932 100644
|
|
--- a/src/main/java/net/minecraft/server/Chunk.java
|
|
+++ b/src/main/java/net/minecraft/server/Chunk.java
|
|
@@ -90,6 +90,54 @@ public class Chunk implements IChunkAccess {
|
|
private final int[] inventoryEntityCounts = new int[16];
|
|
// Paper end
|
|
|
|
+ // Paper start - optimise hard collision handling
|
|
+ final com.destroystokyo.paper.util.maplist.EntityList[] hardCollidingEntities = new com.destroystokyo.paper.util.maplist.EntityList[16];
|
|
+
|
|
+ {
|
|
+ for (int i = 0, len = this.hardCollidingEntities.length; i < len; ++i) {
|
|
+ this.hardCollidingEntities[i] = new com.destroystokyo.paper.util.maplist.EntityList();
|
|
+ }
|
|
+ }
|
|
+
|
|
+ public final void getHardCollidingEntities(@Nullable Entity entity, AxisAlignedBB axisalignedbb, List<Entity> into) {
|
|
+ // copied from getEntities
|
|
+ int min = MathHelper.floor((axisalignedbb.minY - 2.0D) / 16.0D);
|
|
+ int max = MathHelper.floor((axisalignedbb.maxY + 2.0D) / 16.0D);
|
|
+
|
|
+ min = MathHelper.clamp(min, 0, this.hardCollidingEntities.length - 1);
|
|
+ max = MathHelper.clamp(max, 0, this.hardCollidingEntities.length - 1);
|
|
+
|
|
+ for (int k = min; k <= max; ++k) {
|
|
+ com.destroystokyo.paper.util.maplist.EntityList entityList = this.hardCollidingEntities[k];
|
|
+ Entity[] entities = entityList.getRawData();
|
|
+
|
|
+ for (int i = 0, len = entityList.size(); i < len; ++i) {
|
|
+ Entity entity1 = entities[i];
|
|
+ if (entity1.shouldBeRemoved) continue; // Paper
|
|
+
|
|
+ if (entity1 != entity && entity1.getBoundingBox().intersects(axisalignedbb)) {
|
|
+ into.add(entity1);
|
|
+
|
|
+ if (!(entity1 instanceof EntityEnderDragon)) {
|
|
+ continue;
|
|
+ }
|
|
+
|
|
+ EntityComplexPart[] aentitycomplexpart = ((EntityEnderDragon) entity1).getComplexParts();
|
|
+ int l = aentitycomplexpart.length;
|
|
+
|
|
+ for (int i1 = 0; i1 < l; ++i1) {
|
|
+ EntityComplexPart entitycomplexpart = aentitycomplexpart[i1];
|
|
+
|
|
+ if (entitycomplexpart != entity && entitycomplexpart.getBoundingBox().intersects(axisalignedbb)) {
|
|
+ into.add(entitycomplexpart);
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ // Paper end - optimise hard collision handling
|
|
+
|
|
public Chunk(World world, ChunkCoordIntPair chunkcoordintpair, BiomeStorage biomestorage, ChunkConverter chunkconverter, TickList<Block> ticklist, TickList<FluidType> ticklist1, long i, @Nullable ChunkSection[] achunksection, @Nullable Consumer<Chunk> consumer) {
|
|
this.sections = new ChunkSection[16];
|
|
this.e = Maps.newHashMap();
|
|
@@ -545,7 +593,7 @@ public class Chunk implements IChunkAccess {
|
|
entity.chunkY = k;
|
|
entity.chunkZ = this.loc.z;
|
|
this.entities.add(entity); // Paper - per chunk entity list
|
|
- this.entitySlices[k].add(entity);
|
|
+ this.entitySlices[k].add(entity); if (entity.hardCollides()) this.hardCollidingEntities[k].add(entity); // Paper - optimise hard colliding entities
|
|
// Paper start
|
|
if (entity instanceof EntityItem) {
|
|
itemCounts[k]++;
|
|
@@ -582,7 +630,7 @@ public class Chunk implements IChunkAccess {
|
|
entity.entitySlice = null;
|
|
entity.inChunk = false;
|
|
}
|
|
- if (!this.entitySlices[i].remove(entity)) {
|
|
+ if (entity.hardCollides()) this.hardCollidingEntities[i].remove(entity); if (!this.entitySlices[i].remove(entity)) { // Paper - optimise hard colliding entities
|
|
return;
|
|
}
|
|
if (entity instanceof EntityItem) {
|
|
diff --git a/src/main/java/net/minecraft/server/Entity.java b/src/main/java/net/minecraft/server/Entity.java
|
|
index 7fb34a86dc35cb4bf51e1ce5220e56642096fece..f20f798f0f7bb765ffdab8672f4bf77a60fa52d2 100644
|
|
--- a/src/main/java/net/minecraft/server/Entity.java
|
|
+++ b/src/main/java/net/minecraft/server/Entity.java
|
|
@@ -211,6 +211,40 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
|
|
}
|
|
// CraftBukkit end
|
|
|
|
+ // Paper start
|
|
+ /**
|
|
+ * Overriding this field will cause memory leaks.
|
|
+ */
|
|
+ private final boolean hardCollides;
|
|
+
|
|
+ private static final java.util.Map<Class<? extends Entity>, Boolean> cachedOverrides = java.util.Collections.synchronizedMap(new java.util.WeakHashMap<>());
|
|
+ {
|
|
+ Boolean hardCollides = cachedOverrides.get(this.getClass());
|
|
+ if (hardCollides == null) {
|
|
+ try {
|
|
+ Object getHardCollisionBoxMethod = Entity.class.getMethod("au");
|
|
+ Object getHardCollisionBoxEntityMethod = Entity.class.getMethod("j", Entity.class);
|
|
+ if (!this.getClass().getMethod("au").equals(getHardCollisionBoxMethod)) {
|
|
+ hardCollides = Boolean.TRUE;
|
|
+ } else if (!this.getClass().getMethod("j", Entity.class).equals(getHardCollisionBoxEntityMethod)) {
|
|
+ hardCollides = Boolean.TRUE;
|
|
+ } else {
|
|
+ hardCollides = Boolean.FALSE;
|
|
+ }
|
|
+ cachedOverrides.put(this.getClass(), hardCollides);
|
|
+ } catch (Throwable thr) {
|
|
+ // shouldn't happen, just explode
|
|
+ throw new RuntimeException(thr);
|
|
+ }
|
|
+ }
|
|
+ this.hardCollides = hardCollides.booleanValue();
|
|
+ }
|
|
+
|
|
+ public final boolean hardCollides() {
|
|
+ return this.hardCollides;
|
|
+ }
|
|
+ // Paper end
|
|
+
|
|
public Entity(EntityTypes<?> entitytypes, World world) {
|
|
this.id = Entity.entityCount.incrementAndGet();
|
|
this.passengers = Lists.newArrayList();
|
|
diff --git a/src/main/java/net/minecraft/server/EntityEnderDragon.java b/src/main/java/net/minecraft/server/EntityEnderDragon.java
|
|
index 5bf99e0028b886a6ba1d2f39f8dc4cd3c9aa0943..aecdaacfc7da560759bc513680d76f55820d5046 100644
|
|
--- a/src/main/java/net/minecraft/server/EntityEnderDragon.java
|
|
+++ b/src/main/java/net/minecraft/server/EntityEnderDragon.java
|
|
@@ -847,6 +847,7 @@ public class EntityEnderDragon extends EntityInsentient implements IMonster {
|
|
@Override
|
|
public void checkDespawn() {}
|
|
|
|
+ public final EntityComplexPart[] getComplexParts() { return this.eo(); } // Paper - OBFHELPER
|
|
public EntityComplexPart[] eo() {
|
|
return this.children;
|
|
}
|
|
diff --git a/src/main/java/net/minecraft/server/IEntityAccess.java b/src/main/java/net/minecraft/server/IEntityAccess.java
|
|
index 4157e50e4d99c029759bffcb48a8d645487554c8..5135308fb6137a34ed6fd061f0a210de6de4e81c 100644
|
|
--- a/src/main/java/net/minecraft/server/IEntityAccess.java
|
|
+++ b/src/main/java/net/minecraft/server/IEntityAccess.java
|
|
@@ -42,17 +42,26 @@ public interface IEntityAccess {
|
|
return this.b(oclass, axisalignedbb, IEntitySelector.f);
|
|
}
|
|
|
|
+ // Paper start - optimise hard collision
|
|
+ /**
|
|
+ * Not guaranteed to only return hard colliding entites
|
|
+ */
|
|
+ default List<Entity> getHardCollidingEntities(@Nullable Entity entity, AxisAlignedBB axisalignedbb) {
|
|
+ return this.getEntities(entity, axisalignedbb);
|
|
+ }
|
|
+ // Paper end - optimise hard collision
|
|
+
|
|
default Stream<VoxelShape> b(@Nullable Entity entity, AxisAlignedBB axisalignedbb, Set<Entity> set) {
|
|
if (axisalignedbb.a() < 1.0E-7D) {
|
|
return Stream.empty();
|
|
} else {
|
|
AxisAlignedBB axisalignedbb1 = axisalignedbb.g(1.0E-7D);
|
|
- Stream<AxisAlignedBB> stream = this.getEntities(entity, axisalignedbb1).stream().filter((entity1) -> { // Paper - decompile fix
|
|
+ Stream<AxisAlignedBB> stream = ((entity != null && entity.hardCollides()) ? this.getEntities(entity, axisalignedbb) : this.getHardCollidingEntities(entity, axisalignedbb1)).stream().filter((entity1) -> { // Paper - decompile fix // Paper - optimise hard collision
|
|
return !set.contains(entity1);
|
|
}).filter((entity1) -> {
|
|
return entity == null || !entity.isSameVehicle(entity1);
|
|
}).flatMap((entity1) -> {
|
|
- return Stream.of(entity1.au(), entity == null ? null : entity.j(entity1));
|
|
+ return Stream.of(entity1.au(), entity == null ? null : entity.j(entity1)); // Paper - optimise hard collision - diff on change, these are the methods that only hard colliding entities override
|
|
}).filter(Objects::nonNull);
|
|
|
|
return stream.filter(axisalignedbb1::c).map(VoxelShapes::a);
|
|
diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java
|
|
index bdd0908adb7d3cd5370b43be196c975e6c48a70f..1c7955d3ae7ddd1c2d924cec20a91202cf090f40 100644
|
|
--- a/src/main/java/net/minecraft/server/World.java
|
|
+++ b/src/main/java/net/minecraft/server/World.java
|
|
@@ -1179,6 +1179,32 @@ public abstract class World implements GeneratorAccess, AutoCloseable {
|
|
return this.getChunkAt(i, j, ChunkStatus.FULL, false);
|
|
}
|
|
|
|
+ // Paper start - optimise hard collision handling
|
|
+ @Override
|
|
+ public List<Entity> getHardCollidingEntities(@Nullable Entity entity, AxisAlignedBB axisalignedbb) {
|
|
+ // copied from below
|
|
+ List<Entity> list = Lists.newArrayList();
|
|
+ int i = MathHelper.floor((axisalignedbb.minX - 2.0D) / 16.0D);
|
|
+ int j = MathHelper.floor((axisalignedbb.maxX + 2.0D) / 16.0D);
|
|
+ int k = MathHelper.floor((axisalignedbb.minZ - 2.0D) / 16.0D);
|
|
+ int l = MathHelper.floor((axisalignedbb.maxZ + 2.0D) / 16.0D);
|
|
+
|
|
+ ChunkProviderServer chunkProvider = ((ChunkProviderServer)this.chunkProvider);
|
|
+
|
|
+ for (int i1 = i; i1 <= j; ++i1) {
|
|
+ for (int j1 = k; j1 <= l; ++j1) {
|
|
+ Chunk chunk = chunkProvider.getChunkAtIfLoadedMainThread(i1, j1);
|
|
+
|
|
+ if (chunk != null) {
|
|
+ chunk.getHardCollidingEntities(entity, axisalignedbb, list);
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+
|
|
+ return list;
|
|
+ }
|
|
+ // Paper end - optimise hard collision handling
|
|
+
|
|
@Override
|
|
public List<Entity> getEntities(@Nullable Entity entity, AxisAlignedBB axisalignedbb, @Nullable Predicate<? super Entity> predicate) {
|
|
this.getMethodProfiler().c("getEntities");
|