diff --git a/patches/server/0003-Setup-Gradle-project.patch b/patches/server/0003-Setup-Gradle-project.patch index 33fe2cd4..68bb5db6 100644 --- a/patches/server/0003-Setup-Gradle-project.patch +++ b/patches/server/0003-Setup-Gradle-project.patch @@ -6,10 +6,10 @@ Subject: [PATCH] Setup Gradle project diff --git a/build.gradle.kts b/build.gradle.kts new file mode 100644 -index 0000000000000000000000000000000000000000..3938905ca58c3d1cd1db4fa9632637b7a43ff8c5 +index 0000000000000000000000000000000000000000..7a4dbe3923dc2a001f57e35fe6a6e94083769c65 --- /dev/null +++ b/build.gradle.kts -@@ -0,0 +1,114 @@ +@@ -0,0 +1,116 @@ +plugins { + id("pandaspigot.conventions") + id("com.github.johnrengelman.shadow") version "7.1.2" @@ -112,15 +112,17 @@ index 0000000000000000000000000000000000000000..3938905ca58c3d1cd1db4fa9632637b7 + ) + } + } -+ ++ var jvmargs = listOf("-Xms1G", "-Xmx1G", "-XX:+UseG1GC", "-XX:+ParallelRefProcEnabled", "-XX:MaxGCPauseMillis=200", "-XX:+UnlockExperimentalVMOptions", "-XX:+DisableExplicitGC", "-XX:+AlwaysPreTouch", "-XX:G1NewSizePercent=30", "-XX:G1MaxNewSizePercent=40", "-XX:G1HeapRegionSize=8M", "-XX:G1ReservePercent=20", "-XX:G1HeapWastePercent=5", "-XX:G1MixedGCCountTarget=4", "-XX:InitiatingHeapOccupancyPercent=15", "-XX:G1MixedGCLiveThresholdPercent=90", "-XX:G1RSetUpdatingPauseTimePercent=5", "-XX:SurvivorRatio=32", "-XX:+PerfDisableSharedMem", "-XX:MaxTenuringThreshold=1", "-Dusing.aikars.flags=https://mcflags.emc.gs", "-Daikars.new.flags=true") + registerRunTask("runShadow") { + description = "Spin up a test server from the shadowJar archiveFile" ++ jvmArgs = jvmargs + classpath(shadowJar.flatMap { it.archiveFile }) + } + + registerRunTask("runDev") { + description = "Spin up a non-shaded non-relocated test server" + classpath = java.sourceSets.main.get().runtimeClasspath ++ jvmArgs = jvmargs + mainClass.set("org.bukkit.craftbukkit.Main") + } +} diff --git a/patches/server/0100-add-fastutil.patch b/patches/server/0100-add-fastutil.patch new file mode 100644 index 00000000..5dddf522 --- /dev/null +++ b/patches/server/0100-add-fastutil.patch @@ -0,0 +1,18 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 17:27:39 +0200 +Subject: [PATCH] add fastutil + + +diff --git a/build.gradle.kts b/build.gradle.kts +index 32e86e461d803da6493ac42c173317c2c67ca18b..12283bd6386dc459aebb28484cb1221fabb3db88 100644 +--- a/build.gradle.kts ++++ b/build.gradle.kts +@@ -20,6 +20,7 @@ dependencies { + + // Minecraft libraries: + implementation("io.netty:netty-all:4.1.91.Final") // PandaSpigot - Update Netty to 4.1.x ++ implementation("it.unimi.dsi:fastutil:8.5.12") // PandaSpigot - add fastutil + implementation("com.mojang:authlib:1.5.21") + // PandaSpigot start - Update log4j + implementation("org.apache.logging.log4j:log4j-api:2.17.1") diff --git a/patches/server/0101-fastutil-add-ObjectMapList.patch b/patches/server/0101-fastutil-add-ObjectMapList.patch new file mode 100644 index 00000000..3d6cc436 --- /dev/null +++ b/patches/server/0101-fastutil-add-ObjectMapList.patch @@ -0,0 +1,210 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 17:33:06 +0200 +Subject: [PATCH] fastutil - add ObjectMapList + + +diff --git a/src/main/java/io/papermc/paper/util/maplist/ObjectMapList.java b/src/main/java/io/papermc/paper/util/maplist/ObjectMapList.java +new file mode 100644 +index 0000000000000000000000000000000000000000..a9eee73e34cc6ad6f872e8f000775c900a7509c1 +--- /dev/null ++++ b/src/main/java/io/papermc/paper/util/maplist/ObjectMapList.java +@@ -0,0 +1,198 @@ ++package io.papermc.paper.util.maplist; ++ ++import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap; ++import it.unimi.dsi.fastutil.objects.AbstractReferenceList; ++import it.unimi.dsi.fastutil.objects.ObjectListIterator; ++import it.unimi.dsi.fastutil.objects.ObjectSpliterator; ++import org.jetbrains.annotations.NotNull; ++ ++import java.util.Arrays; ++import java.util.NoSuchElementException; ++import java.util.Set; ++ ++/** ++ * list with O(1) remove & contains ++ * @author Spottedleaf ++ */ ++public final class ObjectMapList extends AbstractReferenceList implements Set { ++ ++ private final Int2IntOpenHashMap objectToIndex; ++ ++ private static final Object[] EMPTY_LIST = new Object[0]; ++ private T[] elements = (T[]) EMPTY_LIST; ++ private int count; ++ ++ public ObjectMapList() { ++ this(2, 0.8f); ++ } ++ ++ public ObjectMapList(int expectedSize, float loadFactor) { ++ this.objectToIndex = new Int2IntOpenHashMap(expectedSize, loadFactor); ++ this.objectToIndex.defaultReturnValue(Integer.MIN_VALUE); ++ } ++ ++ @Override ++ public int size() { ++ return this.count; ++ } ++ ++ @Override ++ public int indexOf(Object object) { ++ return this.objectToIndex.get(object.hashCode()); ++ } ++ ++ @Override ++ public int lastIndexOf(Object object) { ++ return super.indexOf(object); ++ } ++ ++ @Override ++ public boolean remove(final Object object) { ++ final int index = this.objectToIndex.remove(object.hashCode()); ++ if (index == Integer.MIN_VALUE) { ++ return false; ++ } ++ ++ // move the obj at the end to this index ++ final int endIndex = --this.count; ++ final T end = this.elements[endIndex]; ++ if (index != endIndex) { ++ // not empty after this call ++ this.objectToIndex.put(end.hashCode(), index); // update index ++ } ++ this.elements[index] = end; ++ this.elements[endIndex] = null; ++ return true; ++ } ++ ++ @Override ++ public boolean add(final T object) { ++ final int count = this.count; ++ final int currIndex = this.objectToIndex.putIfAbsent(object.hashCode(), count); ++ ++ if (currIndex != Integer.MIN_VALUE) { ++ return false; // already in this list ++ } ++ ++ T[] list = this.elements; ++ if (list.length == count) { ++ // resize required ++ list = this.elements = Arrays.copyOf(list, (int)Math.max(4L, (long) count << 1)); // overflow results in negative ++ } ++ ++ list[count] = object; ++ this.count = count + 1; ++ return true; ++ } ++ ++ @Override ++ public void add(final int index, final T object) { ++ final int currIndex = this.objectToIndex.putIfAbsent(object.hashCode(), index); ++ ++ if (currIndex != Integer.MIN_VALUE) { ++ return; // already in this list ++ } ++ ++ int count = this.count; ++ T[] list = this.elements; ++ if (list.length == count) { ++ // resize required ++ list = this.elements = Arrays.copyOf(list, (int) Math.max(4L, (long) count << 1)); // overflow results in negative ++ } ++ ++ System.arraycopy(list, index, list, index + 1, count - index); ++ list[index] = object; ++ this.count = count + 1; ++ } ++ ++ @Override ++ public T get(int index) { ++ return this.elements[index]; ++ } ++ ++ @Override ++ public boolean isEmpty() { ++ return this.count == 0; ++ } ++ ++ @Override ++ public void clear() { ++ this.objectToIndex.clear(); ++ Arrays.fill(this.elements, 0, this.count, null); ++ this.count = 0; ++ } ++ ++ @Override ++ public Object @NotNull [] toArray() { ++ return Arrays.copyOf(this.elements, this.count); ++ } ++ ++ @Override ++ public ObjectSpliterator spliterator() { ++ return super.spliterator(); ++ } ++ ++ @Override ++ public @NotNull ObjectListIterator iterator() { ++ return new Iterator(0); ++ } ++ ++ private class Iterator implements ObjectListIterator { ++ ++ T lastRet; ++ int current; ++ ++ Iterator(int index) { ++ current = index; ++ } ++ ++ @Override ++ public int nextIndex() { ++ return this.current + 1; ++ } ++ ++ @Override ++ public int previousIndex() { ++ return this.current - 1; ++ } ++ ++ @Override ++ public boolean hasNext() { ++ return this.current < ObjectMapList.this.count; ++ } ++ ++ @Override ++ public boolean hasPrevious() { ++ return this.current > 0; ++ } ++ ++ @Override ++ public T next() { ++ if (this.current >= ObjectMapList.this.count) { ++ throw new NoSuchElementException(); ++ } ++ return this.lastRet = ObjectMapList.this.elements[this.current++]; ++ } ++ ++ @Override ++ public T previous() { ++ if (this.current < 0) { ++ throw new NoSuchElementException(); ++ } ++ return this.lastRet = ObjectMapList.this.elements[--this.current]; ++ } ++ ++ @Override ++ public void remove() { ++ final T lastRet = this.lastRet; ++ ++ if (lastRet == null) { ++ throw new IllegalStateException(); ++ } ++ this.lastRet = null; ++ ++ ObjectMapList.this.remove(lastRet); ++ --this.current; ++ } ++ } ++} diff --git a/patches/server/0102-fastutil-EntityTracker.patch b/patches/server/0102-fastutil-EntityTracker.patch new file mode 100644 index 00000000..b00495e0 --- /dev/null +++ b/patches/server/0102-fastutil-EntityTracker.patch @@ -0,0 +1,32 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 17:33:39 +0200 +Subject: [PATCH] fastutil - EntityTracker + + +diff --git a/src/main/java/net/minecraft/server/EntityTracker.java b/src/main/java/net/minecraft/server/EntityTracker.java +index cb72b36725927272fddfdad929b268a7b06140ac..d3afb43259dc34a63c561266efbf7e5050d9d213 100644 +--- a/src/main/java/net/minecraft/server/EntityTracker.java ++++ b/src/main/java/net/minecraft/server/EntityTracker.java +@@ -13,7 +13,7 @@ public class EntityTracker { + + private static final Logger a = LogManager.getLogger(); + private final WorldServer world; +- private Set c = Sets.newHashSet(); ++ private Set c = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - FastUtil - ObjectMapList + public IntHashMap trackedEntities = new IntHashMap(); + private int e; + +diff --git a/src/main/java/net/minecraft/server/EntityTrackerEntry.java b/src/main/java/net/minecraft/server/EntityTrackerEntry.java +index 0b90b6f30ea09fb117281d5ddd2fc752d2c139b5..108043d6460374d64a6c1fcfb9e1aab5a4024733 100644 +--- a/src/main/java/net/minecraft/server/EntityTrackerEntry.java ++++ b/src/main/java/net/minecraft/server/EntityTrackerEntry.java +@@ -42,7 +42,7 @@ public class EntityTrackerEntry { + // PaperSpigot start + // Replace trackedPlayers Set with a Map. The value is true until the player receives + // their first update (which is forced to have absolute coordinates), false afterward. +- public java.util.Map trackedPlayerMap = new java.util.HashMap(); ++ public java.util.Map trackedPlayerMap = new it.unimi.dsi.fastutil.objects.Reference2BooleanOpenHashMap<>(); // PandaSpigot - HashMap -> Reference2BooleanOpenHashMap + public Set trackedPlayers = trackedPlayerMap.keySet(); + // PaperSpigot end + diff --git a/patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch b/patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch new file mode 100644 index 00000000..fb9c430b --- /dev/null +++ b/patches/server/0103-fastutil-use-ObjectMapList-in-Chunk-EntitySlices.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 17:34:37 +0200 +Subject: [PATCH] fastutil - use ObjectMapList in Chunk EntitySlices + + +diff --git a/src/main/java/net/minecraft/server/Chunk.java b/src/main/java/net/minecraft/server/Chunk.java +index 3cb8d99311e2fa9a4a1173f6ef9e8dee957b20fa..4107f2ab945cc1f1ae428493341f5c65f1b56daa 100644 +--- a/src/main/java/net/minecraft/server/Chunk.java ++++ b/src/main/java/net/minecraft/server/Chunk.java +@@ -146,7 +146,7 @@ public class Chunk { + this.heightMap = new int[256]; + + for (int k = 0; k < this.entitySlices.length; ++k) { +- this.entitySlices[k] = new org.bukkit.craftbukkit.util.UnsafeList(); // Spigot ++ this.entitySlices[k] = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - UnsafeList -> ObjectMapList + } + + Arrays.fill(this.f, -999); diff --git a/patches/server/0104-fastutil-PlayerChunkMap.patch b/patches/server/0104-fastutil-PlayerChunkMap.patch new file mode 100644 index 00000000..2c9d47ef --- /dev/null +++ b/patches/server/0104-fastutil-PlayerChunkMap.patch @@ -0,0 +1,37 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 17:51:33 +0200 +Subject: [PATCH] fastutil - PlayerChunkMap + + +diff --git a/src/main/java/net/minecraft/server/PlayerChunkMap.java b/src/main/java/net/minecraft/server/PlayerChunkMap.java +index 696edfe83aa6c75deaaa59cc10818dbf261cc5a9..600c75e86db444b1f31e245a729d22365d5b222b 100644 +--- a/src/main/java/net/minecraft/server/PlayerChunkMap.java ++++ b/src/main/java/net/minecraft/server/PlayerChunkMap.java +@@ -19,7 +19,7 @@ public class PlayerChunkMap { + + private static final Logger a = LogManager.getLogger(); + private final WorldServer world; +- private final List managedPlayers = Lists.newArrayList(); ++ private final List managedPlayers = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - ArrayList -> ObjectArrayList + private final LongHashMap d = new LongHashMap(); + private final Queue e = new java.util.concurrent.ConcurrentLinkedQueue(); // CraftBukkit ArrayList -> ConcurrentLinkedQueue + private final Queue f = new java.util.concurrent.ConcurrentLinkedQueue(); // CraftBukkit ArrayList -> ConcurrentLinkedQueue +@@ -351,7 +351,7 @@ public class PlayerChunkMap { + + class PlayerChunk { + +- private final List b = Lists.newArrayList(); ++ private final List b = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - ArrayList -> ObjectArrayList + private final ChunkCoordIntPair location; + private short[] dirtyBlocks = new short[64]; + private int dirtyCount; +@@ -359,7 +359,7 @@ public class PlayerChunkMap { + private long g; + + // CraftBukkit start - add fields +- private final HashMap players = new HashMap(); ++ private final java.util.Map players = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(); // Pandaspigot - HashMap -> Object2ObjectOpenHashMAp + private boolean loaded = false; + private Runnable loadedRunnable = new Runnable() { + public void run() { diff --git a/patches/server/0105-fastutil-World.patch b/patches/server/0105-fastutil-World.patch new file mode 100644 index 00000000..ebd9d4df --- /dev/null +++ b/patches/server/0105-fastutil-World.patch @@ -0,0 +1,30 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 20:52:52 +0200 +Subject: [PATCH] fastutil - World + + +diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java +index 38ebe35f6fa434103b52e86262c7f4cc32d486e3..599b496acfd7ba727a4948ff18ada7614bb74e08 100644 +--- a/src/main/java/net/minecraft/server/World.java ++++ b/src/main/java/net/minecraft/server/World.java +@@ -36,7 +36,7 @@ public abstract class World implements IBlockAccess { + private int a = 63; + protected boolean e; + // Spigot start - guard entity list from removals +- public final List entityList = new java.util.ArrayList() ++ public final List entityList = new it.unimi.dsi.fastutil.objects.ObjectArrayList() // PandaSpigot ArrayList -> ObjectArrayList + { + @Override + public Entity remove(int index) +@@ -66,8 +66,8 @@ public abstract class World implements IBlockAccess { + public final List tileEntityList = Lists.newArrayList(); + private final List b = Lists.newArrayList(); + private final Set c = Sets.newHashSet(); // Paper +- public final List players = Lists.newArrayList(); +- public final List k = Lists.newArrayList(); ++ public final List players = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - ArrayList -> ObjectArrayList ++ public final List k = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - ArrayList -> ObjectArrayList + protected final IntHashMap entitiesById = new IntHashMap(); + private long d = 16777215L; + private int I; diff --git a/patches/server/0106-fastutil-NBTTagCompound.patch b/patches/server/0106-fastutil-NBTTagCompound.patch new file mode 100644 index 00000000..e8e07c49 --- /dev/null +++ b/patches/server/0106-fastutil-NBTTagCompound.patch @@ -0,0 +1,54 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 20:54:14 +0200 +Subject: [PATCH] fastutil - NBTTagCompound + + +diff --git a/src/main/java/net/minecraft/server/NBTTagCompound.java b/src/main/java/net/minecraft/server/NBTTagCompound.java +index 22d7c2ab36f11f93c0b9d08b786c784562ef7077..01cc42ebc8429ac0fb66366542781739fbe77ee7 100644 +--- a/src/main/java/net/minecraft/server/NBTTagCompound.java ++++ b/src/main/java/net/minecraft/server/NBTTagCompound.java +@@ -12,10 +12,14 @@ import java.util.concurrent.Callable; + + public class NBTTagCompound extends NBTBase { + +- private Map map = Maps.newHashMap(); +- +- public NBTTagCompound() {} ++ private Map map; + ++ public NBTTagCompound() { ++ map = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>(8, 0.8f); // PandaSpigot - reduce memory footprint of NBTTagCompound ++ } ++ public NBTTagCompound(it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap map) { ++ this.map = map; ++ } + void write(DataOutput dataoutput) throws IOException { + Iterator iterator = this.map.keySet().iterator(); + +@@ -282,16 +286,17 @@ public class NBTTagCompound extends NBTBase { + } + + public NBTBase clone() { +- NBTTagCompound nbttagcompound = new NBTTagCompound(); +- Iterator iterator = this.map.keySet().iterator(); +- ++ it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap ret = new it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap<>( ++ this.map.size(), 0.8f); ++ Iterator> iterator = (this.map instanceof it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap) ++ ? ((it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap) this.map).object2ObjectEntrySet() ++ .fastIterator() ++ : this.map.entrySet().iterator(); + while (iterator.hasNext()) { +- String s = (String) iterator.next(); +- +- nbttagcompound.set(s, ((NBTBase) this.map.get(s)).clone()); ++ Map.Entry entry = iterator.next(); ++ ret.put(entry.getKey(), entry.getValue().clone()); + } +- +- return nbttagcompound; ++ return new NBTTagCompound(ret); + } + + public boolean equals(Object object) { diff --git a/patches/server/0107-fastutil-HashTreeSet.patch b/patches/server/0107-fastutil-HashTreeSet.patch new file mode 100644 index 00000000..34657c0e --- /dev/null +++ b/patches/server/0107-fastutil-HashTreeSet.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 20:55:42 +0200 +Subject: [PATCH] fastutil - HashTreeSet + + +diff --git a/src/main/java/org/bukkit/craftbukkit/util/HashTreeSet.java b/src/main/java/org/bukkit/craftbukkit/util/HashTreeSet.java +index 80a5c29f3b9f0e6ccb2acb01a6be3726d6b368b3..2a1ab9d3a3675acaaacb6c257cbe0beed415efce 100644 +--- a/src/main/java/org/bukkit/craftbukkit/util/HashTreeSet.java ++++ b/src/main/java/org/bukkit/craftbukkit/util/HashTreeSet.java +@@ -8,7 +8,7 @@ import java.util.TreeSet; + + public class HashTreeSet implements Set { + +- private HashSet hash = new HashSet(); ++ private Set hash = new it.unimi.dsi.fastutil.objects.ObjectOpenHashSet<>(); // PandaSpigot - HashSet -> ObjectOpenHashSet + private TreeSet tree = new TreeSet(); + + public HashTreeSet() { diff --git a/patches/server/0108-fastutil-DataWatcher.patch b/patches/server/0108-fastutil-DataWatcher.patch new file mode 100644 index 00000000..76110601 --- /dev/null +++ b/patches/server/0108-fastutil-DataWatcher.patch @@ -0,0 +1,53 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 21:29:31 +0200 +Subject: [PATCH] fastutil - DataWatcher + + +diff --git a/src/main/java/net/minecraft/server/DataWatcher.java b/src/main/java/net/minecraft/server/DataWatcher.java +index 518e8f379d690b1f1b4d2374c875dd3dae22360e..ca88b6ab6d3fac8ae30659555559d12fdee272b9 100644 +--- a/src/main/java/net/minecraft/server/DataWatcher.java ++++ b/src/main/java/net/minecraft/server/DataWatcher.java +@@ -16,11 +16,11 @@ public class DataWatcher { + private final Entity a; + private boolean b = true; + // Spigot Start +- private static final gnu.trove.map.TObjectIntMap classToId = new gnu.trove.map.hash.TObjectIntHashMap( 10, 0.5f, -1 ); +- private final gnu.trove.map.TIntObjectMap dataValues = new gnu.trove.map.hash.TIntObjectHashMap( 10, 0.5f, -1 ); ++ private static final it.unimi.dsi.fastutil.objects.Object2IntMap> classToId = new it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap<>(10, 0.5f); // Pandaspigot TObjectIntHashMap -> Object2IntOpenHashMap ++ private final it.unimi.dsi.fastutil.ints.Int2ObjectMap dataValues = new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>( 10, 0.5f);// Pandaspigot TIntObjectHashMap -> Int2ObjectOpenHashMap + // These exist as an attempt at backwards compatability for (broken) NMS plugins +- private static final Map, Integer> c = gnu.trove.TDecorators.wrap( classToId ); +- private final Map d = gnu.trove.TDecorators.wrap( dataValues ); ++ private static final Map, Integer> c = classToId; // Pandaspigot ++ private final Map d = dataValues; // Pandaspigot + // Spigot End + private boolean e; + // private ReadWriteLock f = new ReentrantReadWriteLock(); // PandaSpigot - Remove DataWatcher Locking +@@ -151,7 +151,7 @@ public class DataWatcher { + + if (this.e) { + // this.f.readLock().lock(); // PandaSpigot +- Iterator iterator = this.dataValues.valueCollection().iterator(); // Spigot ++ Iterator iterator = this.dataValues.values().iterator(); // Spigot // Pandaspigot + + while (iterator.hasNext()) { + DataWatcher.WatchableObject datawatcher_watchableobject = (DataWatcher.WatchableObject) iterator.next(); +@@ -186,7 +186,7 @@ public class DataWatcher { + + public void a(PacketDataSerializer packetdataserializer) throws IOException { + // this.f.readLock().lock(); // PandaSpigot +- Iterator iterator = this.dataValues.valueCollection().iterator(); // Spigot ++ Iterator iterator = this.dataValues.values().iterator(); // Spigot // Pandaspigot + + while (iterator.hasNext()) { + DataWatcher.WatchableObject datawatcher_watchableobject = (DataWatcher.WatchableObject) iterator.next(); +@@ -203,7 +203,7 @@ public class DataWatcher { + + // this.f.readLock().lock(); // PandaSpigot + +- arraylist.addAll(this.dataValues.valueCollection()); // Spigot ++ arraylist.addAll(this.dataValues.values()); // Spigot // Pandaspigot + // Spigot start - copy ItemStacks to prevent ConcurrentModificationExceptions + for ( int i = 0; i < arraylist.size(); i++ ) + { diff --git a/patches/server/0109-fastutil-HandshakeListener.patch b/patches/server/0109-fastutil-HandshakeListener.patch new file mode 100644 index 00000000..98df576f --- /dev/null +++ b/patches/server/0109-fastutil-HandshakeListener.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 21:30:42 +0200 +Subject: [PATCH] fastutil - HandshakeListener + + +diff --git a/src/main/java/net/minecraft/server/HandshakeListener.java b/src/main/java/net/minecraft/server/HandshakeListener.java +index 10a8c440f08535d90d8d1204a23c859ba296aa39..9fedebc490273994352f9f024d1e789a06215a78 100644 +--- a/src/main/java/net/minecraft/server/HandshakeListener.java ++++ b/src/main/java/net/minecraft/server/HandshakeListener.java +@@ -9,7 +9,7 @@ public class HandshakeListener implements PacketHandshakingInListener { + + private static final com.google.gson.Gson gson = new com.google.gson.Gson(); // Spigot + // CraftBukkit start - add fields +- private static final HashMap throttleTracker = new HashMap(); ++ private static final java.util.Map throttleTracker = new it.unimi.dsi.fastutil.objects.Object2LongOpenHashMap<>(); // PandaSpigot HashMap -> Object2LongOpenHashMap + private static int throttleCounter = 0; + // CraftBukkit end + diff --git a/patches/server/0110-fastutil-ChunkProviderServer.patch b/patches/server/0110-fastutil-ChunkProviderServer.patch new file mode 100644 index 00000000..c0f00c78 --- /dev/null +++ b/patches/server/0110-fastutil-ChunkProviderServer.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 21:32:40 +0200 +Subject: [PATCH] fastutil - ChunkProviderServer + + +diff --git a/src/main/java/net/minecraft/server/ChunkProviderServer.java b/src/main/java/net/minecraft/server/ChunkProviderServer.java +index 7085cb503db3e1e585417ce4300c6be075c7d2fe..15dff439f1e2caf6881612a5c629d65a6c2b5734 100644 +--- a/src/main/java/net/minecraft/server/ChunkProviderServer.java ++++ b/src/main/java/net/minecraft/server/ChunkProviderServer.java +@@ -34,7 +34,7 @@ public class ChunkProviderServer implements IChunkProvider { + public IChunkProvider chunkProvider; + private IChunkLoader chunkLoader; + public boolean forceChunkLoad = false; // CraftBukkit - true -> false +- public LongObjectHashMap chunks = new LongObjectHashMap(); ++ public it.unimi.dsi.fastutil.longs.Long2ObjectMap chunks = new it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap<>(4096, 0.5f); // PandaSpigot LongObjectHashMap -> Long2ObjectOpenHashMap + public WorldServer world; + + public ChunkProviderServer(WorldServer worldserver, IChunkLoader ichunkloader, IChunkProvider ichunkprovider) { diff --git a/patches/server/0111-fastutil-SpawnerCreature.patch b/patches/server/0111-fastutil-SpawnerCreature.patch new file mode 100644 index 00000000..561ba10f --- /dev/null +++ b/patches/server/0111-fastutil-SpawnerCreature.patch @@ -0,0 +1,45 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 21:43:55 +0200 +Subject: [PATCH] fastutil - SpawnerCreature + + +diff --git a/src/main/java/net/minecraft/server/SpawnerCreature.java b/src/main/java/net/minecraft/server/SpawnerCreature.java +index 550bd42b656ce2e7a0d1542215845d2bf7c475d7..4c497835c9f3be3410d53a53beb289fcb36ca2d9 100644 +--- a/src/main/java/net/minecraft/server/SpawnerCreature.java ++++ b/src/main/java/net/minecraft/server/SpawnerCreature.java +@@ -23,28 +23,13 @@ public final class SpawnerCreature { + // Spigot start - get entity count only from chunks being processed in b + private int getEntityCount(WorldServer server, Class oClass) + { +- // PandaSpigot start - use entire world, not just active chunks. Spigot broke vanilla expectations. +- if (true) { +- int sum = 0; +- for (Chunk c : server.chunkProviderServer.chunks.values()) { +- sum += c.entityCount.get(oClass); +- } +- return sum; +- } +- // PandaSpigot end +- int i = 0; +- Iterator it = this.b.iterator(); +- while ( it.hasNext() ) +- { +- Long coord = it.next(); +- int x = LongHash.msw( coord ); +- int z = LongHash.lsw( coord ); +- if ( !server.chunkProviderServer.unloadQueue.contains( coord ) && server.isChunkLoaded( x, z, true ) ) +- { +- i += server.getChunkAt( x, z ).entityCount.get( oClass ); +- } ++ int sum = 0; ++ for (it.unimi.dsi.fastutil.objects.ObjectIterator objectIterator = (server.chunkProviderServer).chunks.values() ++ .iterator(); objectIterator.hasNext();) { ++ Chunk c = objectIterator.next(); ++ sum += c.entityCount.get(oClass); + } +- return i; ++ return sum; + } + // Spigot end + diff --git a/patches/server/0112-fastutil-CraftingManager.patch b/patches/server/0112-fastutil-CraftingManager.patch new file mode 100644 index 00000000..ba17939b --- /dev/null +++ b/patches/server/0112-fastutil-CraftingManager.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 21:46:27 +0200 +Subject: [PATCH] fastutil - CraftingManager + + +diff --git a/src/main/java/net/minecraft/server/CraftingManager.java b/src/main/java/net/minecraft/server/CraftingManager.java +index 544ff0a6c2ec62911c97fb02aec24d0215188dc3..f0ef79d01ab2019686b9fb56f6672ebab7c6b56e 100644 +--- a/src/main/java/net/minecraft/server/CraftingManager.java ++++ b/src/main/java/net/minecraft/server/CraftingManager.java +@@ -14,7 +14,7 @@ import org.bukkit.craftbukkit.event.CraftEventFactory; // CraftBukkit + public class CraftingManager { + + private static final CraftingManager a = new CraftingManager(); +- public List recipes = Lists.newArrayList(); ++ public List recipes = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - ArrayList -> ObjectArrayList + // CraftBukkit start + public IRecipe lastRecipe; + public org.bukkit.inventory.InventoryView lastCraftView; diff --git a/patches/server/0113-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch b/patches/server/0113-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch new file mode 100644 index 00000000..1265185d --- /dev/null +++ b/patches/server/0113-fastutil-PlayerList-faster-uuid-and-name-lookup-tabl.patch @@ -0,0 +1,147 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 22:32:49 +0200 +Subject: [PATCH] fastutil - PlayerList faster uuid and name lookup tables + + +diff --git a/src/main/java/net/minecraft/server/PlayerList.java b/src/main/java/net/minecraft/server/PlayerList.java +index ada9cf25b091c2df24301bb5e82d1f76fbd929e5..3c677b8bde482400e6cdb3818ce0a9cd036aece8 100644 +--- a/src/main/java/net/minecraft/server/PlayerList.java ++++ b/src/main/java/net/minecraft/server/PlayerList.java +@@ -49,7 +49,89 @@ public abstract class PlayerList { + private static final SimpleDateFormat g = new SimpleDateFormat("yyyy-MM-dd \'at\' HH:mm:ss z"); + private final MinecraftServer server; + public final List players = new java.util.concurrent.CopyOnWriteArrayList(); // CraftBukkit - ArrayList -> CopyOnWriteArrayList: Iterator safety +- private final Map j = Maps.newHashMap(); ++ public final Map playerMap = new it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap() { ++ ++ private final java.util.concurrent.locks.ReentrantReadWriteLock lock = new java.util.concurrent.locks.ReentrantReadWriteLock(); ++ ++ @Override ++ public EntityPlayer put(String key, EntityPlayer value) { ++ lock.writeLock().lock(); ++ try { ++ return super.put(key.toLowerCase(), value); ++ } finally { ++ lock.writeLock().unlock(); ++ } ++ } ++ ++ @Override ++ public EntityPlayer get(Object key) { ++ lock.readLock().lock(); ++ try { ++ // put the .playerConnection check done in other places here ++ EntityPlayer player = super.get(key instanceof String ? ((String) key).toLowerCase() : key); ++ return (player != null && player.playerConnection != null) ? player : null; ++ } finally { ++ lock.readLock().unlock(); ++ } ++ } ++ ++ @Override ++ public boolean containsKey(Object key) { ++ return get(key) != null; ++ } ++ ++ @Override ++ public EntityPlayer remove(Object key) { ++ lock.writeLock().lock(); ++ try { ++ return super.remove(key instanceof String ? ((String) key).toLowerCase() : key); ++ } finally { ++ lock.writeLock().unlock(); ++ } ++ } ++ }; ++ public final Map uuidMap = new it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap() { ++ ++ private final java.util.concurrent.locks.ReentrantReadWriteLock lock = new java.util.concurrent.locks.ReentrantReadWriteLock(); ++ ++ @Override ++ public EntityPlayer get(Object key) { ++ lock.readLock().lock(); ++ try { ++ // put the .playerConnection check done in other places here ++ EntityPlayer player = super.get(key instanceof String ? ((String) key).toLowerCase() : key); ++ return (player != null && player.playerConnection != null) ? player : null; ++ } finally { ++ lock.readLock().unlock(); ++ } ++ } ++ ++ @Override ++ public EntityPlayer put(UUID key, EntityPlayer value) { ++ lock.writeLock().lock(); ++ try { ++ return super.put(key, value); ++ } finally { ++ lock.writeLock().unlock(); ++ } ++ } ++ ++ @Override ++ public boolean containsKey(Object key) { ++ // WindSpigot - synchronize uuid map ++ return get(key) != null; ++ } ++ ++ @Override ++ public EntityPlayer remove(Object key) { ++ lock.writeLock().lock(); ++ try { ++ return super.remove(key); ++ } finally { ++ lock.writeLock().unlock(); ++ } ++ } ++ }; + private final GameProfileBanList k; + private final IpBanList l; + private final OpList operators; +@@ -304,7 +386,8 @@ public abstract class PlayerList { + public void onPlayerJoin(EntityPlayer entityplayer, String joinMessage) { // CraftBukkit added param + this.players.add(entityplayer); + this.playersByName.put(entityplayer.getName(), entityplayer); // Spigot +- this.j.put(entityplayer.getUniqueID(), entityplayer); ++ this.playerMap.put(entityplayer.getName(), entityplayer); ++ this.uuidMap.put(entityplayer.getUniqueID(), entityplayer); + // this.sendAll(new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.ADD_PLAYER, new EntityPlayer[] { entityplayer})); // CraftBukkit - replaced with loop below + WorldServer worldserver = this.server.getWorldServer(entityplayer.dimension); + +@@ -381,12 +464,14 @@ public abstract class PlayerList { + worldserver.kill(entityplayer); + worldserver.getPlayerChunkMap().removePlayer(entityplayer); + this.players.remove(entityplayer); ++ this.uuidMap.remove(entityplayer.getUniqueID()); ++ this.playerMap.remove(entityplayer.getName()); + this.playersByName.remove(entityplayer.getName()); // Spigot + UUID uuid = entityplayer.getUniqueID(); +- EntityPlayer entityplayer1 = (EntityPlayer) this.j.get(uuid); ++ EntityPlayer entityplayer1 = this.uuidMap.get(uuid); + + if (entityplayer1 == entityplayer) { +- this.j.remove(uuid); ++ this.playerMap.remove(entityplayer.getName()); + this.o.remove(uuid); + } + +@@ -629,7 +714,8 @@ public abstract class PlayerList { + worldserver.addEntity(entityplayer1); + this.players.add(entityplayer1); + this.playersByName.put(entityplayer1.getName(), entityplayer1); // Spigot +- this.j.put(entityplayer1.getUniqueID(), entityplayer1); ++ this.playerMap.put(entityplayer1.getName(), entityplayer1); ++ this.uuidMap.put(entityplayer1.getUniqueID(), entityplayer1); + } + // Added from changeDimension + updateClient(entityplayer); // Update health, etc... +@@ -1269,7 +1355,7 @@ public abstract class PlayerList { + } + + public EntityPlayer a(UUID uuid) { +- return (EntityPlayer) this.j.get(uuid); ++ return this.uuidMap.get(uuid); + } + + public boolean f(GameProfile gameprofile) { diff --git a/patches/server/0114-fastutil-EntityPlayer-more-optimized-entties-checkin.patch b/patches/server/0114-fastutil-EntityPlayer-more-optimized-entties-checkin.patch new file mode 100644 index 00000000..d80fb0b4 --- /dev/null +++ b/patches/server/0114-fastutil-EntityPlayer-more-optimized-entties-checkin.patch @@ -0,0 +1,77 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 22:43:20 +0200 +Subject: [PATCH] fastutil - EntityPlayer more optimized entties checking + + +diff --git a/src/main/java/net/minecraft/server/EntityPlayer.java b/src/main/java/net/minecraft/server/EntityPlayer.java +index b4f301a3eb660b9bf080c4f6b4e3bbaa3678a8d6..54ead77dbf1ef17121a2068947e5b1018f2fa3b0 100644 +--- a/src/main/java/net/minecraft/server/EntityPlayer.java ++++ b/src/main/java/net/minecraft/server/EntityPlayer.java +@@ -232,9 +232,9 @@ public class EntityPlayer extends EntityHuman implements ICrafting { + } + + if (!this.chunkCoordIntPairQueue.isEmpty()) { +- ArrayList arraylist = Lists.newArrayList(); +- Iterator iterator1 = this.chunkCoordIntPairQueue.iterator(); +- ArrayList arraylist1 = Lists.newArrayList(); ++ ArrayList arraylist = Lists.newArrayList(); ++ Iterator iterator1 = this.chunkCoordIntPairQueue.iterator(); ++ ArrayList arraylist1 = Lists.newArrayList(); + + Chunk chunk; + +@@ -262,20 +262,18 @@ public class EntityPlayer extends EntityHuman implements ICrafting { + } else { + this.playerConnection.sendPacket(new PacketPlayOutMapChunkBulk(arraylist)); + } +- +- Iterator iterator2 = arraylist1.iterator(); +- +- while (iterator2.hasNext()) { +- TileEntity tileentity = (TileEntity) iterator2.next(); +- ++ for (TileEntity tileentity : arraylist1) { + this.a(tileentity); + } ++ it.unimi.dsi.fastutil.longs.LongOpenHashSet chunkPosSet = new it.unimi.dsi.fastutil.longs.LongOpenHashSet(arraylist.size()); ++ for (Chunk newChunk : arraylist) { ++ chunkPosSet.add(this.chunkToLong(newChunk.locX, newChunk.locZ)); ++ } + +- iterator2 = arraylist.iterator(); +- +- while (iterator2.hasNext()) { +- chunk = (Chunk) iterator2.next(); +- this.u().getTracker().a(this, chunk); ++ for (EntityTrackerEntry entitytrackerentry : this.u().getTracker().c) { ++ if (entitytrackerentry.tracker != this && chunkPosSet.contains(this.chunkToLong(entitytrackerentry.tracker.ae, entitytrackerentry.tracker.ag))) { ++ entitytrackerentry.updatePlayer(this); ++ } + } + } + } +@@ -295,7 +293,9 @@ public class EntityPlayer extends EntityHuman implements ICrafting { + } + + } +- ++ private long chunkToLong(int chunkX, int chunkZ) { ++ return (chunkX << 32L) + chunkZ - -2147483648L; ++ } + public void l() { + try { + super.t_(); +diff --git a/src/main/java/net/minecraft/server/EntityTracker.java b/src/main/java/net/minecraft/server/EntityTracker.java +index d3afb43259dc34a63c561266efbf7e5050d9d213..e34f7e4cba2d9e4213e44da99dfdebd907dc8ffb 100644 +--- a/src/main/java/net/minecraft/server/EntityTracker.java ++++ b/src/main/java/net/minecraft/server/EntityTracker.java +@@ -13,7 +13,7 @@ public class EntityTracker { + + private static final Logger a = LogManager.getLogger(); + private final WorldServer world; +- private Set c = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - FastUtil - ObjectMapList ++ public Set c = new io.papermc.paper.util.maplist.ObjectMapList<>(); // PandaSpigot - private -> public + public IntHashMap trackedEntities = new IntHashMap(); + private int e; + diff --git a/patches/server/0115-tempfixup-Add-packet-limiter-config.patch b/patches/server/0115-tempfixup-Add-packet-limiter-config.patch new file mode 100644 index 00000000..94d2a6a7 --- /dev/null +++ b/patches/server/0115-tempfixup-Add-packet-limiter-config.patch @@ -0,0 +1,19 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 7 Oct 2023 23:26:59 +0200 +Subject: [PATCH] tempfixup! Add packet limiter config + + +diff --git a/src/main/java/net/minecraft/server/NetworkManager.java b/src/main/java/net/minecraft/server/NetworkManager.java +index 5c631068db79615bf51ed357bc9bda2b0ebb0c3b..87ecc1b9a46bfcc146b7b42f142cac46c02faa9c 100644 +--- a/src/main/java/net/minecraft/server/NetworkManager.java ++++ b/src/main/java/net/minecraft/server/NetworkManager.java +@@ -126,7 +126,7 @@ public class NetworkManager extends SimpleChannelInboundHandler { + this.close(reason[0]); + this.k(); + this.stopReadingPackets = true; +- }, null); ++ }, (GenericFutureListener>) null); + } + // PandaSpigot end - packet limiter + public NetworkManager(EnumProtocolDirection enumprotocoldirection) { diff --git a/patches/server/0116-temp.patch b/patches/server/0116-temp.patch new file mode 100644 index 00000000..9671ec19 --- /dev/null +++ b/patches/server/0116-temp.patch @@ -0,0 +1,127 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Mechoriet +Date: Sat, 14 Oct 2023 22:47:19 +0200 +Subject: [PATCH] temp + + +diff --git a/src/main/java/net/minecraft/server/Entity.java b/src/main/java/net/minecraft/server/Entity.java +index 37aae0ccb40e1827f268a88b1a74d288e3f5760d..f7087e3d0dae1c9f3653b4d5039de8403304db98 100644 +--- a/src/main/java/net/minecraft/server/Entity.java ++++ b/src/main/java/net/minecraft/server/Entity.java +@@ -437,11 +437,9 @@ public abstract class Entity implements ICommandListener { + * PaperSpigot - Load surrounding chunks the entity is moving through + */ + public void loadChunks() { +- for (int cx = (int) locX >> 4; cx <= (int) (locX + motX) >> 4; ++cx) { +- for (int cz = (int) locZ >> 4; cz <= (int) (locZ + motZ) >> 4; ++cz) { +- ((ChunkProviderServer) world.chunkProvider).getChunkAt(cx, cz); +- } +- } ++ int chunkX = org.bukkit.util.NumberConversions.floor(locX) >> 4; ++ int chunkZ = org.bukkit.util.NumberConversions.floor(locZ) >> 4; ++ ((ChunkProviderServer) world.chunkProvider).getChunkAt(chunkX, chunkZ); + } + + +diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java +index 599b496acfd7ba727a4948ff18ada7614bb74e08..aab8252468afee9ebe3684f37291749699d4de86 100644 +--- a/src/main/java/net/minecraft/server/World.java ++++ b/src/main/java/net/minecraft/server/World.java +@@ -129,7 +129,8 @@ public abstract class World implements IBlockAccess { + + // Spigot start + private boolean guardEntityList; +- protected final gnu.trove.map.hash.TLongShortHashMap chunkTickList; ++// protected final gnu.trove.map.hash.TLongShortHashMap chunkTickList; ++ protected final it.unimi.dsi.fastutil.longs.Long2ShortOpenHashMap chunkTickList; + protected float growthOdds = 100; + protected float modifiedOdds = 100; + private final byte chunkTickRadius; +@@ -196,8 +197,7 @@ public abstract class World implements IBlockAccess { + // CraftBukkit end + // Spigot start + this.chunkTickRadius = (byte) ( ( this.getServer().getViewDistance() < 7 ) ? this.getServer().getViewDistance() : 7 ); +- this.chunkTickList = new gnu.trove.map.hash.TLongShortHashMap( spigotConfig.chunksPerTick * 5, 0.7f, Long.MIN_VALUE, Short.MIN_VALUE ); +- this.chunkTickList.setAutoCompactionFactor( 0 ); ++ this.chunkTickList = new it.unimi.dsi.fastutil.longs.Long2ShortOpenHashMap(spigotConfig.chunksPerTick * 5,0.7f); + // Spigot end + + this.L = this.random.nextInt(12000); +@@ -1273,7 +1273,7 @@ public abstract class World implements IBlockAccess { + } + + public List getCubes(Entity entity, AxisAlignedBB axisalignedbb) { +- ArrayList arraylist = Lists.newArrayList(); ++ List arraylist = new it.unimi.dsi.fastutil.objects.ObjectArrayList<>(); // PandaSpigot - ArrayList -> ObjectArrayList + int i = MathHelper.floor(axisalignedbb.a); + int j = MathHelper.floor(axisalignedbb.d + 1.0D); + int k = MathHelper.floor(axisalignedbb.b); +@@ -1283,8 +1283,6 @@ public abstract class World implements IBlockAccess { + WorldBorder worldborder = this.getWorldBorder(); + boolean flag = entity.aT(); + boolean flag1 = this.a(worldborder, entity); +- IBlockData iblockdata = Blocks.STONE.getBlockData(); +- BlockPosition.MutableBlockPosition blockposition_mutableblockposition = new BlockPosition.MutableBlockPosition(); + + // Spigot start + int ystart = ( ( k - 1 ) < 0 ) ? 0 : ( k - 1 ); +@@ -2363,7 +2361,7 @@ public abstract class World implements IBlockAccess { + int dx = ( random.nextBoolean() ? 1 : -1 ) * random.nextInt( randRange ); + int dz = ( random.nextBoolean() ? 1 : -1 ) * random.nextInt( randRange ); + long hash = chunkToKey( dx + j, dz + k ); +- if ( !chunkTickList.contains( hash ) && this.chunkProvider.isChunkLoaded(dx + j, dz + k ) ) ++ if ( !chunkTickList.containsKey( hash ) && this.chunkProvider.isChunkLoaded(dx + j, dz + k ) ) + { + chunkTickList.put( hash, (short) -1 ); // no players + } +diff --git a/src/main/java/net/minecraft/server/WorldServer.java b/src/main/java/net/minecraft/server/WorldServer.java +index d68deb81f9f7dfb82591d5876daaac9a3a258dc6..20ea81dea87bf75e1426cd60618f2d4c19c2a5cf 100644 +--- a/src/main/java/net/minecraft/server/WorldServer.java ++++ b/src/main/java/net/minecraft/server/WorldServer.java +@@ -13,6 +13,10 @@ import java.util.Random; + import java.util.Set; + import java.util.TreeSet; + import java.util.UUID; ++ ++import it.unimi.dsi.fastutil.longs.Long2ShortMap; ++import it.unimi.dsi.fastutil.objects.ObjectIterator; ++import it.unimi.dsi.fastutil.shorts.ShortIterator; + import org.apache.logging.log4j.LogManager; + import org.apache.logging.log4j.Logger; + +@@ -377,11 +381,10 @@ public class WorldServer extends World implements IAsyncTaskHandler { + super.h(); + if (this.worldData.getType() == WorldType.DEBUG_ALL_BLOCK_STATES) { + // Spigot start +- gnu.trove.iterator.TLongShortIterator iterator = this.chunkTickList.iterator(); ++ ObjectIterator iterator = this.chunkTickList.long2ShortEntrySet().fastIterator(); + + while (iterator.hasNext()) { +- iterator.advance(); +- long chunkCoord = iterator.key(); ++ long chunkCoord = iterator.next().getLongKey(); + + this.getChunkAt(World.keyToX( chunkCoord ), World.keyToZ( chunkCoord )).b(false); + // Spigot end +@@ -397,16 +400,16 @@ public class WorldServer extends World implements IAsyncTaskHandler { + // int k = chunkcoordintpair1.x * 16; + // int l = chunkcoordintpair1.z * 16; + // Spigot start +- for (gnu.trove.iterator.TLongShortIterator iter = chunkTickList.iterator(); iter.hasNext(); ) +- { +- iter.advance(); +- long chunkCoord = iter.key(); ++ ObjectIterator iterator = this.chunkTickList.long2ShortEntrySet().iterator(); ++ while (iterator.hasNext()) { ++ Long2ShortMap.Entry entry = iterator.next(); ++ long chunkCoord = entry.getLongKey(); + int chunkX = World.keyToX( chunkCoord ); + int chunkZ = World.keyToZ( chunkCoord ); + // If unloaded, or in procedd of being unloaded, drop it + if ( ( !this.chunkProvider.isChunkLoaded( chunkX, chunkZ ) ) || ( this.chunkProviderServer.unloadQueue.contains( chunkX, chunkZ ) ) ) + { +- iter.remove(); ++ iterator.remove(); + continue; + } + // Spigot end