Merge pull request #10 from Kooperlol/1.0.0

Kooperlol · web-flow · commit b1e77b3568c0 · 2024-07-10T17:15:09.000-04:00
1.0.0
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/events/BlockifyBreakEvent.java b/src/main/java/codes/kooper/blockify/events/BlockifyBreakEvent.java
@@ -2,7 +2,7 @@
 
 import codes.kooper.blockify.models.Stage;
 import codes.kooper.blockify.models.View;
-import io.papermc.paper.math.Position;
+import codes.kooper.blockify.types.BlockifyPosition;
 import lombok.Getter;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.entity.Player;
@@ -16,7 +16,7 @@ public class BlockifyBreakEvent extends Event implements Cancellable {
     private static final HandlerList HANDLERS = new HandlerList();
     private boolean cancelled = false;
     private final Player player;
-    private final Position position;
+    private final BlockifyPosition position;
     private final BlockData blockData;
     private final View view;
     private final Stage stage;
@@ -30,7 +30,7 @@ public class BlockifyBreakEvent extends Event implements Cancellable {
      * @param view The view that the player is in.
      * @param stage The stage that the player is in.
      */
-    public BlockifyBreakEvent(Player player, Position position, BlockData blockData, View view, Stage stage) {
+    public BlockifyBreakEvent(Player player, BlockifyPosition position, BlockData blockData, View view, Stage stage) {
         this.player = player;
         this.position = position;
         this.blockData = blockData;
diff --git a/src/main/java/codes/kooper/blockify/events/BlockifyInteractEvent.java b/src/main/java/codes/kooper/blockify/events/BlockifyInteractEvent.java
@@ -2,7 +2,7 @@
 
 import codes.kooper.blockify.models.Stage;
 import codes.kooper.blockify.models.View;
-import io.papermc.paper.math.Position;
+import codes.kooper.blockify.types.BlockifyPosition;
 import lombok.Getter;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.entity.Player;
@@ -16,7 +16,7 @@ public class BlockifyInteractEvent extends Event implements Cancellable {
     private static final HandlerList HANDLERS = new HandlerList();
     private boolean cancelled = false;
     private final Player player;
-    private final Position position;
+    private final BlockifyPosition position;
     private final BlockData blockData;
     private final View view;
     private final Stage stage;
@@ -30,7 +30,7 @@ public class BlockifyInteractEvent extends Event implements Cancellable {
      * @param view The view that the player is currently in.
      * @param stage The stage that the player is currently in.
      */
-    public BlockifyInteractEvent(Player player, Position position, BlockData blockData, View view, Stage stage) {
+    public BlockifyInteractEvent(Player player, BlockifyPosition position, BlockData blockData, View view, Stage stage) {
         this.player = player;
         this.position = position;
         this.blockData = blockData;
diff --git a/src/main/java/codes/kooper/blockify/events/BlockifyPlaceEvent.java b/src/main/java/codes/kooper/blockify/events/BlockifyPlaceEvent.java
@@ -2,7 +2,7 @@
 
 import codes.kooper.blockify.models.Stage;
 import codes.kooper.blockify.models.View;
-import io.papermc.paper.math.Position;
+import codes.kooper.blockify.types.BlockifyPosition;
 import lombok.Getter;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Event;
@@ -13,7 +13,7 @@
 public class BlockifyPlaceEvent extends Event {
     private static final HandlerList HANDLERS = new HandlerList();
     private final Player player;
-    private final Position position;
+    private final BlockifyPosition position;
     private final View view;
     private final Stage stage;
 
@@ -25,7 +25,7 @@ public class BlockifyPlaceEvent extends Event {
      * @param view The view that the player is currently in.
      * @param stage The stage that the player is currently in.
      */
-    public BlockifyPlaceEvent(Player player, Position position, View view, Stage stage) {
+    public BlockifyPlaceEvent(Player player, BlockifyPosition position, View view, Stage stage) {
         this.player = player;
         this.position = position;
         this.view = view;
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);
@@ -272,21 +283,35 @@ public void sendChunkPacket(Player player, BlockifyChunk chunk, ConcurrentHashMa
         // TODO: Implement Tile Entities
         Column column = new Column(chunk.x(), chunk.z(), true, chunks.toArray(new BaseChunk[0]), null);
         LightData lightData = new LightData();
-        byte[][] emptyLightArray = new byte[ySections][0];
+        byte[][] fullLightArray = new byte[ySections][2048];
+        for (int i = 0; i < ySections; i++) {
+            Arrays.fill(fullLightArray[i], (byte) 0xFF);
+        }
+        BitSet fullBitSet = new BitSet();
         BitSet emptyBitSet = new BitSet();
-        BitSet lightBitSet = new BitSet();
         for (int i = 0; i < ySections; i++) {
-            emptyBitSet.set(i, true);
+            fullBitSet.set(i, true);
         }
-        lightData.setBlockLightArray(emptyLightArray);
-        lightData.setSkyLightArray(emptyLightArray);
+        lightData.setBlockLightArray(fullLightArray);
+        lightData.setSkyLightArray(fullLightArray);
         lightData.setBlockLightCount(ySections);
         lightData.setSkyLightCount(ySections);
-        lightData.setBlockLightMask(lightBitSet);
-        lightData.setSkyLightMask(lightBitSet);
+        lightData.setBlockLightMask(fullBitSet);
+        lightData.setSkyLightMask(fullBitSet);
         lightData.setEmptyBlockLightMask(emptyBitSet);
         lightData.setEmptySkyLightMask(emptyBitSet);
         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
@@ -47,7 +47,7 @@ public void onPacketPlayReceive(PacketPlayReceiveEvent event) {
                         BlockData blockData = view.getBlock(position);
 
                         // Call BlockifyInteractEvent to handle custom interaction
-                        Bukkit.getScheduler().runTask(Blockify.getInstance(), () -> new BlockifyInteractEvent(player, position.toPosition(), blockData, view, view.getStage()).callEvent());
+                        Bukkit.getScheduler().runTask(Blockify.getInstance(), () -> new BlockifyInteractEvent(player, position, blockData, view, view.getStage()).callEvent());
 
                         // Check if block is breakable, if not, send block change packet to cancel the break
                         if (!view.isBreakable()) {
@@ -59,12 +59,12 @@ public void onPacketPlayReceive(PacketPlayReceiveEvent event) {
                         if (actionType == DiggingAction.FINISHED_DIGGING || canInstantBreak(player, blockData)) {
                             Bukkit.getScheduler().runTask(Blockify.getInstance(), () -> {
                                 // Call BlockifyBreakEvent
-                                BlockifyBreakEvent blockifyBreakEvent = new BlockifyBreakEvent(player, position.toPosition(), blockData, view, view.getStage());
+                                BlockifyBreakEvent blockifyBreakEvent = new BlockifyBreakEvent(player, position, blockData, view, view.getStage());
                                 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/BlockPlaceAdapter.java b/src/main/java/codes/kooper/blockify/protocol/BlockPlaceAdapter.java
diff --git a/src/main/java/codes/kooper/blockify/protocol/ChunkLoadAdapter.java b/src/main/java/codes/kooper/blockify/protocol/ChunkLoadAdapter.java
diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml

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()`