--- a/net/minecraft/server/level/ServerChunkCache.java +++ b/net/minecraft/server/level/ServerChunkCache.java @@ -73,6 +_,13 @@ @Nullable @VisibleForDebug private NaturalSpawner.SpawnState lastSpawnState; + // Paper start + private final ca.spottedleaf.concurrentutil.map.ConcurrentLong2ReferenceChainedHashTable fullChunks = new ca.spottedleaf.concurrentutil.map.ConcurrentLong2ReferenceChainedHashTable<>(); + public int getFullChunksCount() { + return this.fullChunks.size(); + } + long chunkFutureAwaitCounter; + // Paper end public ServerChunkCache( ServerLevel level, @@ -121,6 +_,64 @@ this.clearCache(); } + // CraftBukkit start - properly implement isChunkLoaded + public boolean isChunkLoaded(int chunkX, int chunkZ) { + ChunkHolder chunk = this.chunkMap.getUpdatingChunkIfPresent(ChunkPos.asLong(chunkX, chunkZ)); + if (chunk == null) { + return false; + } + return chunk.getFullChunkNow() != null; + } + // CraftBukkit end + // Paper start + public void addLoadedChunk(LevelChunk chunk) { + this.fullChunks.put(chunk.coordinateKey, chunk); + } + + public void removeLoadedChunk(LevelChunk chunk) { + this.fullChunks.remove(chunk.coordinateKey); + } + + @Nullable + public ChunkAccess getChunkAtImmediately(int x, int z) { + ChunkHolder holder = this.chunkMap.getVisibleChunkIfPresent(ChunkPos.asLong(x, z)); + if (holder == null) { + return null; + } + + return holder.getLatestChunk(); + } + + public void addTicketAtLevel(TicketType ticketType, ChunkPos chunkPos, int ticketLevel, T identifier) { + this.distanceManager.addTicket(ticketType, chunkPos, ticketLevel, identifier); + } + + public void removeTicketAtLevel(TicketType ticketType, ChunkPos chunkPos, int ticketLevel, T identifier) { + this.distanceManager.removeTicket(ticketType, chunkPos, ticketLevel, identifier); + } + + // "real" get chunk if loaded + // Note: Partially copied from the getChunkAt method below + @Nullable + public LevelChunk getChunkAtIfCachedImmediately(int x, int z) { + long k = ChunkPos.asLong(x, z); + + // Note: Bypass cache since we need to check ticket level, and to make this MT-Safe + + ChunkHolder playerChunk = this.getVisibleChunkIfPresent(k); + if (playerChunk == null) { + return null; + } + + return playerChunk.getFullChunkNowUnchecked(); + } + + @Nullable + public LevelChunk getChunkAtIfLoadedImmediately(int x, int z) { + return this.fullChunks.get(ChunkPos.asLong(x, z)); + } + // Paper end + @Override public ThreadedLevelLightEngine getLightEngine() { return this.lightEngine; @@ -160,7 +_,7 @@ for (int i = 0; i < 4; i++) { if (packedChunkPos == this.lastChunkPos[i] && chunkStatus == this.lastChunkStatus[i]) { ChunkAccess chunkAccess = this.lastChunk[i]; - if (chunkAccess != null || !requireChunk) { + if (chunkAccess != null) { // CraftBukkit - the chunk can become accessible in the meantime TODO for non-null chunks it might also make sense to check that the chunk's state hasn't changed in the meantime return chunkAccess; } } @@ -169,6 +_,7 @@ profilerFiller.incrementCounter("getChunkCacheMiss"); CompletableFuture> chunkFutureMainThread = this.getChunkFutureMainThread(x, z, chunkStatus, requireChunk); this.mainThreadProcessor.managedBlock(chunkFutureMainThread::isDone); + // com.destroystokyo.paper.io.SyncLoadFinder.logSyncLoad(this.level, x, z); // Paper - Add debug for sync chunk loads ChunkResult chunkResult = chunkFutureMainThread.join(); ChunkAccess chunkAccess1 = chunkResult.orElse(null); if (chunkAccess1 == null && requireChunk) { @@ -240,7 +_,15 @@ long packedChunkPos = chunkPos.toLong(); int i = ChunkLevel.byStatus(chunkStatus); ChunkHolder visibleChunkIfPresent = this.getVisibleChunkIfPresent(packedChunkPos); - if (requireChunk) { + // CraftBukkit start - don't add new ticket for currently unloading chunk + boolean currentlyUnloading = false; + if (visibleChunkIfPresent != null) { + FullChunkStatus oldChunkState = ChunkLevel.fullStatus(visibleChunkIfPresent.oldTicketLevel); + FullChunkStatus currentChunkState = ChunkLevel.fullStatus(visibleChunkIfPresent.getTicketLevel()); + currentlyUnloading = (oldChunkState.isOrAfter(FullChunkStatus.FULL) && !currentChunkState.isOrAfter(FullChunkStatus.FULL)); + } + if (requireChunk && !currentlyUnloading) { + // CraftBukkit end this.distanceManager.addTicket(TicketType.UNKNOWN, chunkPos, i, chunkPos); if (this.chunkAbsent(visibleChunkIfPresent, i)) { ProfilerFiller profilerFiller = Profiler.get(); @@ -260,7 +_,7 @@ } private boolean chunkAbsent(@Nullable ChunkHolder chunkHolder, int status) { - return chunkHolder == null || chunkHolder.getTicketLevel() > status; + return chunkHolder == null || chunkHolder.oldTicketLevel > status; // CraftBukkit using oldTicketLevel for isLoaded checks } @Override @@ -287,7 +_,7 @@ return this.mainThreadProcessor.pollTask(); } - boolean runDistanceManagerUpdates() { + public boolean runDistanceManagerUpdates() { // Paper - public boolean flag = this.distanceManager.runAllUpdates(this.chunkMap); boolean flag1 = this.chunkMap.promoteChunkMap(); this.chunkMap.runGenerationTasks(); @@ -315,17 +_,39 @@ @Override public void close() throws IOException { - this.save(true); + // CraftBukkit start + this.close(true); + } + + public void close(boolean save) throws IOException { + if (save) { + this.save(true); + } + // CraftBukkit end this.dataStorage.close(); this.lightEngine.close(); this.chunkMap.close(); } + // CraftBukkit start - modelled on below + public void purgeUnload() { + ProfilerFiller gameprofilerfiller = Profiler.get(); + + gameprofilerfiller.push("purge"); + this.distanceManager.purgeStaleTickets(); + this.runDistanceManagerUpdates(); + gameprofilerfiller.popPush("unload"); + this.chunkMap.tick(() -> true); + gameprofilerfiller.pop(); + this.clearCache(); + } + // CraftBukkit end + @Override public void tick(BooleanSupplier hasTimeLeft, boolean tickChunks) { ProfilerFiller profilerFiller = Profiler.get(); profilerFiller.push("purge"); - if (this.level.tickRateManager().runsNormally() || !tickChunks) { + if (this.level.tickRateManager().runsNormally() || !tickChunks || this.level.spigotConfig.unloadFrozenChunks) { // Spigot this.distanceManager.purgeStaleTickets(); } @@ -400,12 +_,20 @@ ); this.lastSpawnState = spawnState; profiler.popPush("spawnAndTick"); - boolean _boolean = this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING); + boolean _boolean = this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && !this.level.players().isEmpty(); // CraftBukkit; int _int = this.level.getGameRules().getInt(GameRules.RULE_RANDOMTICKING); List filteredSpawningCategories; if (_boolean && (this.spawnEnemies || this.spawnFriendlies)) { - boolean flag = this.level.getLevelData().getGameTime() % 400L == 0L; - filteredSpawningCategories = NaturalSpawner.getFilteredSpawningCategories(spawnState, this.spawnFriendlies, this.spawnEnemies, flag); + // Paper start - PlayerNaturallySpawnCreaturesEvent + for (ServerPlayer entityPlayer : this.level.players()) { + int chunkRange = Math.min(level.spigotConfig.mobSpawnRange, entityPlayer.getBukkitEntity().getViewDistance()); + chunkRange = Math.min(chunkRange, 8); + entityPlayer.playerNaturallySpawnedEvent = new com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent(entityPlayer.getBukkitEntity(), (byte) chunkRange); + entityPlayer.playerNaturallySpawnedEvent.callEvent(); + } + // Paper end - PlayerNaturallySpawnCreaturesEvent + boolean flag = this.level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) != 0L && this.level.getLevelData().getGameTime() % this.level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) == 0L; // CraftBukkit + filteredSpawningCategories = NaturalSpawner.getFilteredSpawningCategories(spawnState, this.spawnFriendlies, this.spawnEnemies, flag, this.level); // CraftBukkit } else { filteredSpawningCategories = List.of(); } @@ -413,7 +_,7 @@ for (LevelChunk levelChunk : chunks) { ChunkPos pos = levelChunk.getPos(); levelChunk.incrementInhabitedTime(timeInhabited); - if (!filteredSpawningCategories.isEmpty() && this.level.getWorldBorder().isWithinBounds(pos)) { + if (!filteredSpawningCategories.isEmpty() && this.level.getWorldBorder().isWithinBounds(pos) && this.chunkMap.anyPlayerCloseEnoughForSpawning(pos, true)) { // Spigot NaturalSpawner.spawnForChunk(this.level, levelChunk, spawnState, filteredSpawningCategories); } @@ -526,8 +_,13 @@ @Override public void setSpawnSettings(boolean spawnSettings) { + // CraftBukkit start + this.setSpawnSettings(spawnSettings, this.spawnFriendlies); + } + public void setSpawnSettings(boolean spawnSettings, boolean spawnFriendlies) { this.spawnEnemies = spawnSettings; - this.spawnFriendlies = this.spawnFriendlies; + this.spawnFriendlies = spawnFriendlies; + // CraftBukkit end } public String getChunkDebugData(ChunkPos chunkPos) { @@ -603,12 +_,18 @@ @Override public boolean pollTask() { + try { // CraftBukkit - process pending Chunk loadCallback() and unloadCallback() after each run task if (ServerChunkCache.this.runDistanceManagerUpdates()) { return true; } else { ServerChunkCache.this.lightEngine.tryScheduleUpdate(); return super.pollTask(); } + // CraftBukkit start - process pending Chunk loadCallback() and unloadCallback() after each run task + } finally { + ServerChunkCache.this.chunkMap.callbackExecutor.run(); + } + // CraftBukkit end - process pending Chunk loadCallback() and unloadCallback() after each run task } } }