Updates to how blocks are sent

Kooperlol · Kooperlol · commit 8e35acae626e · 2024-07-10T16:14:51.000-05:00
diff --git a/build.gradle b/build.gradle
@@ -4,7 +4,7 @@ plugins {
 }
 
 group = 'codes.kooper'
-version = '1.0.0-alpha'
+version = '1.0.0-alpha-2'
 
 repositories {
     mavenCentral()
diff --git a/src/main/java/codes/kooper/blockify/managers/BlockChangeManager.java b/src/main/java/codes/kooper/blockify/managers/BlockChangeManager.java
@@ -16,6 +16,7 @@
 import com.github.retrooper.packetevents.protocol.world.states.WrappedBlockState;
 import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerChunkData;
 import io.github.retrooper.packetevents.util.SpigotConversionUtil;
+import io.papermc.paper.math.Position;
 import lombok.Getter;
 import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
@@ -61,14 +62,7 @@ public void sendViews(Stage stage, Player player) {
      */
     public void sendView(Player player, View view) {
         Audience audience = Audience.fromPlayers(new HashSet<>(Collections.singletonList(player)));
-        ConcurrentHashMap<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> blocks = new ConcurrentHashMap<>();
-        for (Map.Entry<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> entry : view.getBlocks().entrySet()) {
-            if (!blocks.containsKey(entry.getKey())) {
-                blocks.put(entry.getKey(), new ConcurrentHashMap<>());
-            }
-            blocks.get(entry.getKey()).putAll(entry.getValue());
-        }
-        sendBlockChanges(view.getStage(), audience, blocks);
+        sendBlockChanges(view.getStage(), audience, view.getBlocks().keySet());
     }
 
     /**
@@ -80,16 +74,7 @@ public void sendView(Player player, View view) {
      */
     public void hideView(Player player, View view) {
         Audience audience = Audience.fromPlayers(new HashSet<>(Collections.singletonList(player)));
-        ConcurrentHashMap<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> blocks = new ConcurrentHashMap<>();
-        for (Map.Entry<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> entry : view.getBlocks().entrySet()) {
-            if (!blocks.containsKey(entry.getKey())) {
-                blocks.put(entry.getKey(), new ConcurrentHashMap<>());
-            }
-            for (Map.Entry<BlockifyPosition, BlockData> blockEntry : entry.getValue().entrySet()) {
-                blocks.get(entry.getKey()).put(blockEntry.getKey(), view.getStage().getWorld().getBlockData(blockEntry.getKey().getX(), blockEntry.getKey().getY(), blockEntry.getKey().getZ()));
-            }
-        }
-        sendBlockChanges(view.getStage(), audience, blocks);
+        sendBlockChanges(view.getStage(), audience, view.getBlocks().keySet(), true);
     }
 
     /**
@@ -111,14 +96,10 @@ public void hideViews(Stage stage, Player player) {
      * @param stage     the stage
      * @param audience  the audience
      * @param position  the position
-     * @param blockData the block data
      */
-    public void sendBlockChange(Stage stage, Audience audience, BlockifyPosition position, BlockData blockData) {
-        ConcurrentHashMap<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> blockChanges = new ConcurrentHashMap<>();
+    public void sendBlockChange(Stage stage, Audience audience, BlockifyPosition position) {
         BlockifyChunk chunk = new BlockifyChunk(position.getX() >> 4, position.getZ() >> 4);
-        blockChanges.put(chunk, new ConcurrentHashMap<>());
-        blockChanges.get(chunk).put(position, blockData);
-        sendBlockChanges(stage, audience, blockChanges);
+        sendBlockChanges(stage, audience, Collections.singleton(chunk));
     }
 
     /**
@@ -127,12 +108,23 @@ public void sendBlockChange(Stage stage, Audience audience, BlockifyPosition pos
      *
      * @param stage        the stage
      * @param audience     the audience
-     * @param blockChanges the block changes
+     * @param chunks       the chunks to send
      */
-    public void sendBlockChanges(Stage stage, Audience audience, ConcurrentHashMap<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> blockChanges) {
-        if (blockChanges.isEmpty()) {
-            return;
-        }
+    public void sendBlockChanges(Stage stage, Audience audience, Collection<BlockifyChunk> chunks) {
+        sendBlockChanges(stage, audience, chunks, false);
+    }
+
+    /**
+     * Sends block changes to the audience.
+     * Call Asynchronously
+     *
+     * @param stage        the stage
+     * @param audience     the audience
+     * @param chunks       the chunks to send
+     * @param unload        whether to unload the chunks
+     */
+    public void sendBlockChanges(Stage stage, Audience audience, Collection<BlockifyChunk> chunks, boolean unload) {
+        ConcurrentHashMap<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> blockChanges = getBlockChanges(stage, chunks);
         Bukkit.getScheduler().runTask(Blockify.getInstance(), () -> new OnBlockChangeSendEvent(stage, blockChanges).callEvent());
 
         // If there is only one block change, send it to the player directly
@@ -152,6 +144,21 @@ public void sendBlockChanges(Stage stage, Audience audience, ConcurrentHashMap<B
             return;
         }
 
+        // Less than 3,000 blocks then use the player.sendBlockChanges method
+        if (blockCount < 3000) {
+            Map<Position, BlockData> multiBlockChange = new HashMap<>();
+            for (BlockifyChunk chunk : chunks) {
+                if (!stage.getWorld().isChunkLoaded(chunk.x(), chunk.z())) continue;
+                for (Map.Entry<BlockifyPosition, BlockData> entry : blockChanges.get(chunk).entrySet()) {
+                    multiBlockChange.put(entry.getKey().toPosition(), entry.getValue());
+                }
+            }
+            for (Player player : audience.getOnlinePlayers()) {
+                player.sendMultiBlockChange(multiBlockChange);
+            }
+            return;
+        }
+
         // Send multiple block changes to the players
         for (Player onlinePlayer : audience.getOnlinePlayers()) {
             Location playerLocation = onlinePlayer.getLocation();
@@ -160,7 +167,7 @@ public void sendBlockChanges(Stage stage, Audience audience, ConcurrentHashMap<B
             // The chunk index is used to keep track of the current chunk being sent
             AtomicInteger chunkIndex = new AtomicInteger(0);
             // Create an array of chunks to send from the block changes map
-            List<BlockifyChunk> chunksToSend = new ArrayList<>(List.of(blockChanges.keySet().toArray(new BlockifyChunk[0])));
+            List<BlockifyChunk> chunksToSend = new ArrayList<>(chunks.stream().toList());
             chunksToSend.sort((chunk1, chunk2) -> {
                 // Get distance from chunks to player
                 int x = playerLocation.getBlockX() / 16;
@@ -206,10 +213,10 @@ public void sendBlockChanges(Stage stage, Audience audience, ConcurrentHashMap<B
                     chunkIndex.getAndIncrement();
 
                     // Check if the chunk is loaded; if not, return
-                    if (!stage.getWorld().isChunkLoaded(chunk.x(), chunk.z())) return;
+                    if (!stage.getWorld().isChunkLoaded(chunk.x(), chunk.z())) continue;
 
                     // Send the chunk packet to the player
-                    Bukkit.getScheduler().runTaskAsynchronously(Blockify.getInstance(), () -> sendChunkPacket(onlinePlayer, chunk, blockChanges));
+                    Bukkit.getScheduler().runTaskAsynchronously(Blockify.getInstance(), () -> sendChunkPacket(stage, onlinePlayer, chunk, unload));
                 }
             }, 0L, 1L));
         }
@@ -219,14 +226,18 @@ public void sendBlockChanges(Stage stage, Audience audience, ConcurrentHashMap<B
      * Sends a chunk packet to the player.
      * Call Asynchronously
      *
+     * @param stage         the stage
      * @param player        the player
      * @param chunk         the chunk
-     * @param blockChanges  the block changes
      */
-    public void sendChunkPacket(Player player, BlockifyChunk chunk, ConcurrentHashMap<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> blockChanges) {
+    public void sendChunkPacket(Stage stage, Player player, BlockifyChunk chunk, boolean unload) {
         User packetUser = PacketEvents.getAPI().getPlayerManager().getUser(player);
-        ConcurrentHashMap<BlockifyPosition, BlockData> blockData = blockChanges.get(chunk);
         int ySections = packetUser.getTotalWorldHeight() >> 4;
+        ConcurrentHashMap<BlockifyPosition, BlockData> blockData = null;
+        if (!unload) {
+            ConcurrentHashMap<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> blockChanges = getBlockChanges(stage, Collections.singleton(chunk));
+            blockData = blockChanges.get(chunk);
+        }
         Map<BlockData, WrappedBlockState> blockDataToState = new HashMap<>();
         List<BaseChunk> chunks = new ArrayList<>();
         Chunk bukkitChunk = player.getWorld().getChunkAt(chunk.x(), chunk.z());
@@ -244,7 +255,7 @@ public void sendChunkPacket(Player player, BlockifyChunk chunk, ConcurrentHashMa
                         int worldY = (i << 4) + y + minHeight;
                         BlockifyPosition position = new BlockifyPosition(x + (chunk.x() << 4), worldY, z + (chunk.z() << 4));
 
-                        if (blockData.containsKey(position)) {
+                        if (!unload && blockData != null && blockData.containsKey(position)) {
                             BlockData data = blockData.get(position);
                             WrappedBlockState state = blockDataToState.computeIfAbsent(data, SpigotConversionUtil::fromBukkitBlockData);
                             baseChunk.set(x, y, z, state);
@@ -292,4 +303,15 @@ public void sendChunkPacket(Player player, BlockifyChunk chunk, ConcurrentHashMa
         WrapperPlayServerChunkData chunkData = new WrapperPlayServerChunkData(column, lightData);
         packetUser.sendPacketSilently(chunkData);
     }
+
+    private ConcurrentHashMap<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> getBlockChanges(Stage stage, Collection<BlockifyChunk> chunks) {
+        ConcurrentHashMap<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> blockChanges = new ConcurrentHashMap<>();
+        for (View view : stage.getViews()) {
+            for (Map.Entry<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> entry : view.getBlocks().entrySet()) {
+                if (!chunks.contains(entry.getKey())) continue;
+                blockChanges.put(entry.getKey(), entry.getValue());
+            }
+        }
+        return blockChanges;
+    }
 }
diff --git a/src/main/java/codes/kooper/blockify/models/Stage.java b/src/main/java/codes/kooper/blockify/models/Stage.java
@@ -7,11 +7,10 @@
 import lombok.Setter;
 import org.bukkit.Location;
 import org.bukkit.World;
-import org.bukkit.block.data.BlockData;
 
 import java.util.HashSet;
 import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
 
 @Getter
 @Setter
@@ -57,11 +56,7 @@ public boolean isLocationWithin(Location location) {
      * Send blocks to the audience. Should be called asynchronously.
      */
     public void sendBlocksToAudience() {
-        ConcurrentHashMap<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> blocks = new ConcurrentHashMap<>();
-        for (View view : views) {
-            blocks.putAll(view.getBlocks());
-        }
-        Blockify.getInstance().getBlockChangeManager().sendBlockChanges(this, audience, blocks);
+        Blockify.getInstance().getBlockChangeManager().sendBlockChanges(this, audience, getChunks());
     }
 
     /**
@@ -71,20 +66,8 @@ public void sendBlocksToAudience() {
      * @param blocks Blocks to refresh to the audience.
      */
     public void refreshBlocksToAudience(Set<BlockifyPosition> blocks) {
-        ConcurrentHashMap<BlockifyChunk, ConcurrentHashMap<BlockifyPosition, BlockData>> blockChanges = new ConcurrentHashMap<>();
-        for (View view : views) {
-            for (BlockifyPosition position : blocks) {
-                if (!view.hasBlock(position)) continue;
-                if (blockChanges.containsKey(position.toBlockifyChunk())) {
-                    blockChanges.get(position.toBlockifyChunk()).put(position, view.getBlock(position));
-                } else {
-                    ConcurrentHashMap<BlockifyPosition, BlockData> blockData = new ConcurrentHashMap<>();
-                    blockData.put(position, view.getBlock(position));
-                    blockChanges.put(position.toBlockifyChunk(), blockData);
-                }
-            }
-        }
-        Blockify.getInstance().getBlockChangeManager().sendBlockChanges(this, audience, blockChanges);
+        Set<BlockifyChunk> chunks = blocks.stream().map(BlockifyPosition::toBlockifyChunk).collect(Collectors.toSet());
+        Blockify.getInstance().getBlockChangeManager().sendBlockChanges(this, audience, chunks);
     }
 
     /**
diff --git a/src/main/java/codes/kooper/blockify/protocol/BlockDigAdapter.java b/src/main/java/codes/kooper/blockify/protocol/BlockDigAdapter.java
@@ -63,8 +63,8 @@ public void onPacketPlayReceive(PacketPlayReceiveEvent event) {
                                 blockifyBreakEvent.callEvent();
                                 // If block is not cancelled, break the block, otherwise, revert the block
                                 if (!blockifyBreakEvent.isCancelled()) {
-                                    Blockify.getInstance().getBlockChangeManager().sendBlockChange(view.getStage(), view.getStage().getAudience(), position, Material.AIR.createBlockData());
                                     view.setBlock(position, Material.AIR.createBlockData());
+                                    Blockify.getInstance().getBlockChangeManager().sendBlockChange(view.getStage(), view.getStage().getAudience(), position);
                                 } else {
                                     player.sendBlockChange(position.toLocation(player.getWorld()), blockData);
                                 }
diff --git a/src/main/java/codes/kooper/blockify/protocol/ChunkLoadAdapter.java b/src/main/java/codes/kooper/blockify/protocol/ChunkLoadAdapter.java
@@ -2,7 +2,6 @@
 
 import codes.kooper.blockify.Blockify;
 import codes.kooper.blockify.models.Stage;
-import codes.kooper.blockify.models.View;
 import codes.kooper.blockify.types.BlockifyChunk;
 import com.github.retrooper.packetevents.event.SimplePacketListenerAbstract;
 import com.github.retrooper.packetevents.event.simple.PacketPlaySendEvent;
@@ -37,17 +36,14 @@ public void onPacketPlaySend(PacketPlaySendEvent event) {
                 // If the chunk is not in the world, return.
                 if (!stage.getWorld().equals(player.getWorld())) return;
 
-                for (View view : stage.getViews()) {
-
-                    // Check if the view has any blocks in the bound in the first place
-                    if (!view.hasChunk(chunkX, chunkZ)) return;
+                if (stage.getChunks().contains(new BlockifyChunk(chunkX, chunkZ))) {
                     BlockifyChunk blockifyChunk = new BlockifyChunk(chunkX, chunkZ);
 
                     // Cancel the packet to prevent the player from seeing the chunk
                     event.setCancelled(true);
 
                     // Send the chunk packet to the player
-                    Bukkit.getServer().getScheduler().runTaskAsynchronously(Blockify.getInstance(), () -> Blockify.getInstance().getBlockChangeManager().sendChunkPacket(player, blockifyChunk, view.getBlocks()));
+                    Bukkit.getServer().getScheduler().runTaskAsynchronously(Blockify.getInstance(), () -> Blockify.getInstance().getBlockChangeManager().sendChunkPacket(stage, player, blockifyChunk, false));
                 }
             }
         }
diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml
@@ -1,5 +1,5 @@
 name: Blockify
-version: '1.0.0-alpha'
+version: '1.0.0-alpha-2'
 main: codes.kooper.blockify.Blockify
 api-version: '1.20'
 depend:

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ plugins {`
`4`	`4`	`}`
`5`	`5`
`6`	`6`	`group = 'codes.kooper'`
`7`		`-version = '1.0.0-alpha'`
	`7`	`+version = '1.0.0-alpha-2'`
`8`	`8`
`9`	`9`	`repositories {`
`10`	`10`	`mavenCentral()`