fix: redundant logic & potential memory leaks

Author: Mapacheee

src/main/java/me/mapacheee/extendedhorizons/fakechunks/dispatch/ChunkSendQueueEntry.java

@@ -8,7 +8,11 @@
 public record ChunkSendQueueEntry(long chunkKey, CompletableFuture<ByteBuf> buildFuture) {
 
 	public void releaseFuture() {
-		this.buildFuture.thenAccept(ReferenceCountUtil::release);
+		this.buildFuture.thenAccept(buf -> {
+			if (buf != null && buf.refCnt() > 0) {
+				ReferenceCountUtil.release(buf);
+			}
+		});
 	}
 }
 

src/main/java/me/mapacheee/extendedhorizons/fakechunks/listener/ChunkInvalidationListener.java

@@ -3,16 +3,17 @@
 import com.google.inject.Inject;
 import com.thewinterframework.paper.listener.ListenerComponent;
 import me.mapacheee.extendedhorizons.fakechunks.cache.ChunkBuildCacheService;
-import me.mapacheee.extendedhorizons.fakechunks.session.PlayerSession;
 import me.mapacheee.extendedhorizons.fakechunks.session.SessionRegistry;
 import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
+import net.minecraft.world.level.ChunkPos;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.BlockBreakEvent;
 import org.bukkit.event.block.BlockPlaceEvent;
 
+import java.util.UUID;
+
 @ListenerComponent
 public final class ChunkInvalidationListener implements Listener {
 
@@ -38,15 +39,14 @@ public void onPlace(BlockPlaceEvent event) {
     private void invalidate(Block block) {
         int chunkX = block.getX() >> 4;
         int chunkZ = block.getZ() >> 4;
-        long chunkKey = net.minecraft.world.level.ChunkPos.asLong(chunkX, chunkZ);
-        this.cacheService.invalidate(block.getWorld().getUID(), chunkKey);
+        long chunkKey = ChunkPos.asLong(chunkX, chunkZ);
+        UUID worldId = block.getWorld().getUID();
+        this.cacheService.invalidate(worldId, chunkKey);
 
-        for (Player player : block.getWorld().getPlayers()) {
-            PlayerSession session = this.sessionRegistry.get(player.getUniqueId());
-            if (session == null) {
-                continue;
+        this.sessionRegistry.forEachSession(session -> {
+            if (worldId.equals(session.worldId())) {
+                session.invalidateChunk(chunkKey);
             }
-            session.invalidateChunk(chunkKey);
-        }
+        });
     }
 }

src/main/java/me/mapacheee/extendedhorizons/fakechunks/listener/PlayerLifecycleListener.java

@@ -2,6 +2,7 @@
 
 import com.google.inject.Inject;
 import com.thewinterframework.paper.listener.ListenerComponent;
+import me.mapacheee.extendedhorizons.fakechunks.farplayers.cache.FarPlayerCacheService;
 import me.mapacheee.extendedhorizons.fakechunks.netty.ChannelInjectionService;
 import me.mapacheee.extendedhorizons.fakechunks.session.PlayerSession;
 import me.mapacheee.extendedhorizons.fakechunks.session.SessionRegistry;
@@ -18,11 +19,17 @@ public final class PlayerLifecycleListener implements Listener {
 
     private final SessionRegistry sessionRegistry;
     private final ChannelInjectionService channelInjectionService;
+    private final FarPlayerCacheService farPlayerCacheService;
 
     @Inject
-    public PlayerLifecycleListener(SessionRegistry sessionRegistry, ChannelInjectionService channelInjectionService) {
+    public PlayerLifecycleListener(
+            SessionRegistry sessionRegistry,
+            ChannelInjectionService channelInjectionService,
+            FarPlayerCacheService farPlayerCacheService
+    ) {
         this.sessionRegistry = sessionRegistry;
         this.channelInjectionService = channelInjectionService;
+        this.farPlayerCacheService = farPlayerCacheService;
     }
 
     @EventHandler(priority = EventPriority.MONITOR)
@@ -44,6 +51,7 @@ public void onQuit(PlayerQuitEvent event) {
         Player player = event.getPlayer();
         this.channelInjectionService.uninject(player);
         this.sessionRegistry.remove(player.getUniqueId());
+        this.farPlayerCacheService.removePlayer(player.getUniqueId());
     }
 }
 

src/main/java/me/mapacheee/extendedhorizons/fakechunks/session/PlayerSession.java

@@ -5,36 +5,37 @@
 import net.minecraft.world.level.ChunkPos;
 
 import java.util.Deque;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
 import java.util.UUID;
-import java.util.stream.LongStream;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.LongStream;
 
 public final class PlayerSession {
 
     private static final long[] EMPTY_LONG_ARRAY = new long[0];
-    private static final ChunkState[] EMPTY_STATE_ARRAY = new ChunkState[0];
-
+    private static final ChunkState DUMMY_STATE = new ChunkState();
     private final UUID playerId;
     private volatile UUID worldId;
     private final AtomicLong epoch = new AtomicLong(0L);
-
     private volatile long chunkKey = ChunkPos.asLong(Integer.MIN_VALUE, Integer.MIN_VALUE);
     private volatile int distance;
     private volatile int storageRadius;
     private volatile int storageDiameter;
     private volatile int iterationIndex;
-
+    private volatile int trackingTicker = 0;
     private volatile boolean enabled;
     private volatile boolean initiated;
-
     private volatile long[] chunksInDistance = EMPTY_LONG_ARRAY;
-    private volatile ChunkState[] chunkStates = EMPTY_STATE_ARRAY;
-
+    private volatile ChunkState[] chunkStates = new ChunkState[0];
     private volatile int lastAdvertisedDistance = -1;
     private volatile int serverViewDistance = 2;
-
     private final Deque<ChunkSendQueueEntry> chunkQueue = new ConcurrentLinkedDeque<>();
+    private final Map<UUID, Integer> trackedFarPlayers = new ConcurrentHashMap<>();
+    private final Set<UUID> trackingBuffer = new HashSet<>();
 
     public PlayerSession(UUID playerId, UUID worldId) {
         this.playerId = playerId;
@@ -57,6 +58,14 @@ public void bumpEpoch() {
         this.epoch.incrementAndGet();
     }
 
+    public int incrementTrackingTicker() {
+        return this.trackingTicker = (this.trackingTicker + 1) & Integer.MAX_VALUE;
+    }
+
+    public Set<UUID> trackingBuffer() {
+        return this.trackingBuffer;
+    }
+
     public boolean enabled() {
         return this.enabled;
     }
@@ -113,6 +122,10 @@ public Deque<ChunkSendQueueEntry> chunkQueue() {
         return this.chunkQueue;
     }
 
+    public Map<UUID, Integer> trackedFarPlayers() {
+        return this.trackedFarPlayers;
+    }
+
     public void updateDistance(int newDistance) {
         this.distance = Math.max(2, newDistance);
         this.storageRadius = Math.max(2, this.distance) + 3;
@@ -189,7 +202,7 @@ public void moveTo(int chunkX, int chunkZ) {
     }
 
     public void serverChunkAdd(int chunkX, int chunkZ) {
-        if (!this.canStore(chunkX, chunkZ)) {
+        if (this.chunkStates.length == 0 || !this.canStore(chunkX, chunkZ)) {
             return;
         }
         ChunkState state = this.getState(chunkX, chunkZ);
@@ -200,6 +213,9 @@ public void serverChunkAdd(int chunkX, int chunkZ) {
     }
 
     public boolean serverChunkRemove(int chunkX, int chunkZ) {
+        if (this.chunkStates.length == 0) {
+            return false;
+        }
         int centerX = ChunkPos.getX(this.chunkKey);
         int centerZ = ChunkPos.getZ(this.chunkKey);
         if (!ChunkPlannerService.isWithinRange(chunkX - centerX, chunkZ - centerZ, this.distance)) {
@@ -240,10 +256,6 @@ public Long pollNextChunkKey() {
         return null;
     }
 
-    public void onChunkQueued(long chunkKey) {
-        // state is already set to BV_QUEUED by pollNextChunkKey.
-    }
-
     public void onChunkBuildFailed(long chunkKey) {
         ChunkState state = this.getStateByKey(chunkKey);
         if (state.lifecycle() == ChunkLifecycle.BV_QUEUED) {
@@ -336,7 +348,7 @@ private ChunkState getStateByKey(long chunkKey) {
 
     private ChunkState getState(int chunkX, int chunkZ) {
         if (this.chunkStates.length == 0) {
-            return new ChunkState();
+            return DUMMY_STATE;
         }
         return this.chunkStates[calcIndex(chunkX, chunkZ, this.storageDiameter)];
     }

src/main/java/me/mapacheee/extendedhorizons/fakechunks/session/SessionRegistry.java

@@ -6,6 +6,7 @@
 import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
 
 @Service
 public final class SessionRegistry {
@@ -32,6 +33,9 @@ public PlayerSession ensureFor(Player player, boolean bumpEpoch) {
         });
     }
 
+    public void forEachSession(Consumer<PlayerSession> action) {
+        this.sessions.values().forEach(action);
+    }
 
     public PlayerSession get(UUID playerId) {
         return this.sessions.get(playerId);