diff options
Diffstat (limited to 'patch-remap/og/net/minecraft/server/level/PlayerChunkMap.patch')
| -rw-r--r-- | patch-remap/og/net/minecraft/server/level/PlayerChunkMap.patch | 181 |
1 files changed, 181 insertions, 0 deletions
diff --git a/patch-remap/og/net/minecraft/server/level/PlayerChunkMap.patch b/patch-remap/og/net/minecraft/server/level/PlayerChunkMap.patch new file mode 100644 index 0000000000..1115794843 --- /dev/null +++ b/patch-remap/og/net/minecraft/server/level/PlayerChunkMap.patch @@ -0,0 +1,181 @@ +--- a/net/minecraft/server/level/PlayerChunkMap.java ++++ b/net/minecraft/server/level/PlayerChunkMap.java +@@ -101,6 +101,12 @@ + import org.apache.commons.lang3.mutable.MutableBoolean; + import org.slf4j.Logger; + ++// CraftBukkit start ++import net.minecraft.world.level.levelgen.GeneratorSettings; ++import org.bukkit.craftbukkit.generator.CustomChunkGenerator; ++import org.bukkit.entity.Player; ++// CraftBukkit end ++ + public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d { + + private static final byte CHUNK_TYPE_REPLACEABLE = -1; +@@ -143,6 +149,27 @@ + private final Queue<Runnable> unloadQueue; + private int serverViewDistance; + ++ // CraftBukkit start - recursion-safe executor for Chunk loadCallback() and unloadCallback() ++ public final CallbackExecutor callbackExecutor = new CallbackExecutor(); ++ public static final class CallbackExecutor implements java.util.concurrent.Executor, Runnable { ++ ++ private final java.util.Queue<Runnable> queue = new java.util.ArrayDeque<>(); ++ ++ @Override ++ public void execute(Runnable runnable) { ++ queue.add(runnable); ++ } ++ ++ @Override ++ public void run() { ++ Runnable task; ++ while ((task = queue.poll()) != null) { ++ task.run(); ++ } ++ } ++ }; ++ // CraftBukkit end ++ + public PlayerChunkMap(WorldServer worldserver, Convertable.ConversionSession convertable_conversionsession, DataFixer datafixer, StructureTemplateManager structuretemplatemanager, Executor executor, IAsyncTaskHandler<Runnable> iasynctaskhandler, ILightAccess ilightaccess, ChunkGenerator chunkgenerator, WorldLoadListener worldloadlistener, ChunkStatusUpdateListener chunkstatusupdatelistener, Supplier<WorldPersistentData> supplier, int i, boolean flag) { + super(convertable_conversionsession.getDimensionPath(worldserver.dimension()).resolve("region"), datafixer, flag); + this.visibleChunkMap = this.updatingChunkMap.clone(); +@@ -161,6 +188,11 @@ + this.storageName = path.getFileName().toString(); + this.level = worldserver; + this.generator = chunkgenerator; ++ // CraftBukkit start - SPIGOT-7051: It's a rigged game! Use delegate for random state creation, otherwise it is not so random. ++ if (chunkgenerator instanceof CustomChunkGenerator) { ++ chunkgenerator = ((CustomChunkGenerator) chunkgenerator).getDelegate(); ++ } ++ // CraftBukkit end + IRegistryCustom iregistrycustom = worldserver.registryAccess(); + long j = worldserver.getSeed(); + +@@ -332,9 +364,12 @@ + CompletableFuture<List<Either<IChunkAccess, PlayerChunk.Failure>>> completablefuture1 = SystemUtils.sequence(list); + CompletableFuture<Either<List<IChunkAccess>, PlayerChunk.Failure>> completablefuture2 = completablefuture1.thenApply((list2) -> { + List<IChunkAccess> list3 = Lists.newArrayList(); +- final int l1 = 0; ++ // CraftBukkit start - decompile error ++ int cnt = 0; + +- for (Iterator iterator = list2.iterator(); iterator.hasNext(); ++l1) { ++ for (Iterator iterator = list2.iterator(); iterator.hasNext(); ++cnt) { ++ final int l1 = cnt; ++ // CraftBukkit end + final Either<IChunkAccess, PlayerChunk.Failure> either = (Either) iterator.next(); + + if (either == null) { +@@ -540,7 +575,7 @@ + + private void scheduleUnload(long i, PlayerChunk playerchunk) { + CompletableFuture<IChunkAccess> completablefuture = playerchunk.getChunkToSave(); +- Consumer consumer = (ichunkaccess) -> { ++ Consumer<IChunkAccess> consumer = (ichunkaccess) -> { // CraftBukkit - decompile error + CompletableFuture<IChunkAccess> completablefuture1 = playerchunk.getChunkToSave(); + + if (completablefuture1 != completablefuture) { +@@ -631,9 +666,9 @@ + ProtoChunk protochunk = ChunkRegionLoader.read(this.level, this.poiManager, chunkcoordintpair, (NBTTagCompound) optional.get()); + + this.markPosition(chunkcoordintpair, protochunk.getStatus().getChunkType()); +- return Either.left(protochunk); ++ return Either.<IChunkAccess, PlayerChunk.Failure>left(protochunk); // CraftBukkit - decompile error + } else { +- return Either.left(this.createEmptyChunk(chunkcoordintpair)); ++ return Either.<IChunkAccess, PlayerChunk.Failure>left(this.createEmptyChunk(chunkcoordintpair)); // CraftBukkit - decompile error + } + }, this.mainThreadExecutor).exceptionallyAsync((throwable) -> { + return this.handleChunkLoadFailure(throwable, chunkcoordintpair); +@@ -748,7 +783,21 @@ + + private static void postLoadProtoChunk(WorldServer worldserver, List<NBTTagCompound> list) { + if (!list.isEmpty()) { +- worldserver.addWorldGenChunkEntities(EntityTypes.loadEntitiesRecursive(list, worldserver)); ++ // CraftBukkit start - these are spawned serialized (DefinedStructure) and we don't call an add event below at the moment due to ordering complexities ++ worldserver.addWorldGenChunkEntities(EntityTypes.loadEntitiesRecursive(list, worldserver).filter((entity) -> { ++ boolean needsRemoval = false; ++ net.minecraft.server.dedicated.DedicatedServer server = worldserver.getCraftServer().getServer(); ++ if (!server.areNpcsEnabled() && entity instanceof net.minecraft.world.entity.npc.NPC) { ++ entity.discard(); ++ needsRemoval = true; ++ } ++ if (!server.isSpawningAnimals() && (entity instanceof net.minecraft.world.entity.animal.EntityAnimal || entity instanceof net.minecraft.world.entity.animal.EntityWaterAnimal)) { ++ entity.discard(); ++ needsRemoval = true; ++ } ++ return !needsRemoval; ++ })); ++ // CraftBukkit end + } + + } +@@ -860,7 +909,7 @@ + if (!playerchunk.wasAccessibleSinceLastSave()) { + return false; + } else { +- IChunkAccess ichunkaccess = (IChunkAccess) playerchunk.getChunkToSave().getNow((Object) null); ++ IChunkAccess ichunkaccess = (IChunkAccess) playerchunk.getChunkToSave().getNow(null); // CraftBukkit - decompile error + + if (!(ichunkaccess instanceof ProtoChunkExtension) && !(ichunkaccess instanceof Chunk)) { + return false; +@@ -1017,7 +1066,8 @@ + return ichunkaccess instanceof Chunk ? Optional.of((Chunk) ichunkaccess) : Optional.empty(); + }); + +- csvwriter.writeRow(chunkcoordintpair.x, chunkcoordintpair.z, playerchunk.getTicketLevel(), optional.isPresent(), optional.map(IChunkAccess::getStatus).orElse((Object) null), optional1.map(Chunk::getFullStatus).orElse((Object) null), printFuture(playerchunk.getFullChunkFuture()), printFuture(playerchunk.getTickingChunkFuture()), printFuture(playerchunk.getEntityTickingChunkFuture()), this.distanceManager.getTicketDebugString(i), this.anyPlayerCloseEnoughForSpawning(chunkcoordintpair), optional1.map((chunk) -> { ++ // CraftBukkit - decompile error ++ csvwriter.writeRow(chunkcoordintpair.x, chunkcoordintpair.z, playerchunk.getTicketLevel(), optional.isPresent(), optional.map(IChunkAccess::getStatus).orElse(null), optional1.map(Chunk::getFullStatus).orElse(null), printFuture(playerchunk.getFullChunkFuture()), printFuture(playerchunk.getTickingChunkFuture()), printFuture(playerchunk.getEntityTickingChunkFuture()), this.distanceManager.getTicketDebugString(i), this.anyPlayerCloseEnoughForSpawning(chunkcoordintpair), optional1.map((chunk) -> { + return chunk.getBlockEntities().size(); + }).orElse(0), tickingtracker.getTicketDebugString(i), tickingtracker.getLevel(i), optional1.map((chunk) -> { + return chunk.getBlockTicks().count(); +@@ -1030,7 +1080,7 @@ + + private static String printFuture(CompletableFuture<Either<Chunk, PlayerChunk.Failure>> completablefuture) { + try { +- Either<Chunk, PlayerChunk.Failure> either = (Either) completablefuture.getNow((Object) null); ++ Either<Chunk, PlayerChunk.Failure> either = (Either) completablefuture.getNow(null); // CraftBukkit - decompile error + + return either != null ? (String) either.map((chunk) -> { + return "done"; +@@ -1046,12 +1096,14 @@ + + private CompletableFuture<Optional<NBTTagCompound>> readChunk(ChunkCoordIntPair chunkcoordintpair) { + return this.read(chunkcoordintpair).thenApplyAsync((optional) -> { +- return optional.map(this::upgradeChunkTag); ++ return optional.map((nbttagcompound) -> upgradeChunkTag(nbttagcompound, chunkcoordintpair)); // CraftBukkit + }, SystemUtils.backgroundExecutor()); + } + +- private NBTTagCompound upgradeChunkTag(NBTTagCompound nbttagcompound) { +- return this.upgradeChunkTag(this.level.dimension(), this.overworldDataStorage, nbttagcompound, this.generator.getTypeNameForDataFixer()); ++ // CraftBukkit start ++ private NBTTagCompound upgradeChunkTag(NBTTagCompound nbttagcompound, ChunkCoordIntPair chunkcoordintpair) { ++ return this.upgradeChunkTag(this.level.getTypeKey(), this.overworldDataStorage, nbttagcompound, this.generator.getTypeNameForDataFixer(), chunkcoordintpair, level); ++ // CraftBukkit end + } + + boolean anyPlayerCloseEnoughForSpawning(ChunkCoordIntPair chunkcoordintpair) { +@@ -1460,7 +1512,7 @@ + public final Set<ServerPlayerConnection> seenBy = Sets.newIdentityHashSet(); + + public EntityTracker(Entity entity, int i, int j, boolean flag) { +- this.serverEntity = new EntityTrackerEntry(PlayerChunkMap.this.level, entity, j, flag, this::broadcast); ++ this.serverEntity = new EntityTrackerEntry(PlayerChunkMap.this.level, entity, j, flag, this::broadcast, seenBy); // CraftBukkit + this.entity = entity; + this.range = i; + this.lastSectionPos = SectionPosition.of((EntityAccess) entity); +@@ -1520,6 +1572,11 @@ + double d2 = d0 * d0; + boolean flag = d1 <= d2 && this.entity.broadcastToPlayer(entityplayer) && PlayerChunkMap.this.isChunkTracked(entityplayer, this.entity.chunkPosition().x, this.entity.chunkPosition().z); + ++ // CraftBukkit start - respect vanish API ++ if (!entityplayer.getBukkitEntity().canSee(this.entity.getBukkitEntity())) { ++ flag = false; ++ } ++ // CraftBukkit end + if (flag) { + if (this.seenBy.add(entityplayer.connection)) { + this.serverEntity.addPairing(entityplayer); |