Merge branch 'master' of https://github.com/Timongcraft/AxiomPaperPlugin

# Conflicts:
#	build.gradle.kts

Author: Timongcraft

build.gradle.kts

@@ -8,7 +8,7 @@ plugins {
 }
 
 group = "com.moulberry.axiom"
-version = "1.5.7.1"
+version = "1.5.8"
 description = "Serverside component for Axiom on Paper"
 
 java {

src/main/java/com/moulberry/axiom/AxiomPaper.java

@@ -1,11 +1,10 @@
 package com.moulberry.axiom;
 
 import com.google.common.util.concurrent.RateLimiter;
-import com.mojang.brigadier.StringReader;
-import com.moulberry.axiom.buffer.BlockBuffer;
 import com.moulberry.axiom.buffer.CompressedBlockEntity;
 import com.moulberry.axiom.event.AxiomCreateWorldPropertiesEvent;
 import com.moulberry.axiom.event.AxiomModifyWorldEvent;
+import com.moulberry.axiom.integration.plotsquared.PlotSquaredIntegration;
 import com.moulberry.axiom.packet.*;
 import com.moulberry.axiom.world_properties.server.ServerWorldPropertiesRegistry;
 import io.netty.buffer.Unpooled;
@@ -15,20 +14,15 @@
 import io.papermc.paper.network.ChannelInitializeListener;
 import io.papermc.paper.network.ChannelInitializeListenerHolder;
 import net.kyori.adventure.key.Key;
-import net.minecraft.commands.arguments.blocks.BlockPredicateArgument;
-import net.minecraft.commands.arguments.blocks.BlockStateArgument;
-import net.minecraft.commands.arguments.blocks.BlockStateParser;
+import net.minecraft.core.BlockPos;
 import net.minecraft.core.IdMapper;
-import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.network.Connection;
 import net.minecraft.network.ConnectionProtocol;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.protocol.Packet;
 import net.minecraft.network.protocol.PacketFlow;
 import net.minecraft.network.protocol.common.ServerboundCustomPayloadPacket;
 import net.minecraft.server.MinecraftServer;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.block.Blocks;
 import net.minecraft.world.level.block.state.BlockState;
 import org.bukkit.*;
 import org.bukkit.configuration.Configuration;
@@ -43,15 +37,14 @@
 
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
 
 public class AxiomPaper extends JavaPlugin implements Listener {
 
     public static AxiomPaper PLUGIN; // tsk tsk tsk
 
     public final Set<UUID> activeAxiomPlayers = Collections.newSetFromMap(new ConcurrentHashMap<>());
     public final Map<UUID, RateLimiter> playerBlockBufferRateLimiters = new ConcurrentHashMap<>();
+    public final Map<UUID, Restrictions> playerRestrictions = new ConcurrentHashMap<>();
     public Configuration configuration;
 
     public IdMapper<BlockState> allowedBlockRegistry = null;
@@ -90,6 +83,7 @@ public void onEnable() {
         msg.registerOutgoingPluginChannel(this, "axiom:register_world_properties");
         msg.registerOutgoingPluginChannel(this, "axiom:set_world_property");
         msg.registerOutgoingPluginChannel(this, "axiom:ack_world_properties");
+        msg.registerOutgoingPluginChannel(this, "axiom:restrictions");
 
         if (configuration.getBoolean("packet-handlers.hello")) {
             msg.registerIncomingPluginChannel(this, "axiom:hello", new HelloPacketListener(this));
@@ -124,6 +118,15 @@ public void onEnable() {
         if (configuration.getBoolean("packet-handlers.request-chunk-data")) {
             msg.registerIncomingPluginChannel(this, "axiom:request_chunk_data", new RequestChunkDataPacketListener(this));
         }
+        if (configuration.getBoolean("packet-handlers.spawn-entity")) {
+            msg.registerIncomingPluginChannel(this, "axiom:spawn_entity", new SpawnEntityPacketListener(this));
+        }
+        if (configuration.getBoolean("packet-handlers.manipulate-entity")) {
+            msg.registerIncomingPluginChannel(this, "axiom:manipulate_entity", new ManipulateEntityPacketListener(this));
+        }
+        if (configuration.getBoolean("packet-handlers.delete-entity")) {
+            msg.registerIncomingPluginChannel(this, "axiom:delete_entity", new DeleteEntityPacketListener(this));
+        }
 
         if (configuration.getBoolean("packet-handlers.set-buffer")) {
             SetBlockBufferPacketListener setBlockBufferPacketListener = new SetBlockBufferPacketListener(this);
@@ -153,6 +156,13 @@ public void afterInitChannel(@NonNull Channel channel) {
         Bukkit.getScheduler().scheduleSyncRepeatingTask(this, () -> {
             HashSet<UUID> stillActiveAxiomPlayers = new HashSet<>();
 
+            int rateLimit = this.configuration.getInt("block-buffer-rate-limit");
+            if (rateLimit > 0) {
+                // Reduce by 20% just to prevent synchronization/timing issues
+                rateLimit = rateLimit * 8/10;
+                if (rateLimit <= 0) rateLimit = 1;
+            }
+
             for (Player player : Bukkit.getServer().getOnlinePlayers()) {
                 if (activeAxiomPlayers.contains(player.getUniqueId())) {
                     if (!player.hasPermission("axiom.*")) {
@@ -162,13 +172,70 @@ public void afterInitChannel(@NonNull Channel channel) {
                         buf.getBytes(0, bytes);
                         player.sendPluginMessage(this, "axiom:enable", bytes);
                     } else {
-                        stillActiveAxiomPlayers.add(player.getUniqueId());
+                        UUID uuid = player.getUniqueId();
+                        stillActiveAxiomPlayers.add(uuid);
+
+                        boolean send = false;
+
+                        Restrictions restrictions = playerRestrictions.get(uuid);
+                        if (restrictions == null) {
+                            restrictions = new Restrictions();
+                            playerRestrictions.put(uuid, restrictions);
+                            send = true;
+                        }
+
+                        BlockPos boundsMin = null;
+                        BlockPos boundsMax = null;
+
+                        if (!player.hasPermission("axiom.allow_copying_other_plots")) {
+                            if (PlotSquaredIntegration.isPlotWorld(player.getWorld())) {
+                                PlotSquaredIntegration.PlotBounds editable = PlotSquaredIntegration.getCurrentEditablePlot(player);
+                                if (editable != null) {
+                                    restrictions.lastPlotBounds = editable;
+                                    boundsMin = editable.min();
+                                    boundsMax = editable.max();
+                                } else if (restrictions.lastPlotBounds != null && restrictions.lastPlotBounds.worldName().equals(player.getWorld().getName())) {
+                                    boundsMin = restrictions.lastPlotBounds.min();
+                                    boundsMax = restrictions.lastPlotBounds.max();
+                                } else {
+                                    boundsMin = BlockPos.ZERO;
+                                    boundsMax = BlockPos.ZERO;
+                                }
+                            }
+
+                            int min = Integer.MIN_VALUE;
+                            int max = Integer.MAX_VALUE;
+                            if (boundsMin != null && boundsMax != null &&
+                                    boundsMin.getX() == min && boundsMin.getY() == min && boundsMin.getZ() == min &&
+                                    boundsMax.getX() == max && boundsMax.getY() == max && boundsMax.getZ() == max) {
+                                boundsMin = null;
+                                boundsMax = null;
+                            }
+                        }
+
+                        boolean allowImportingBlocks = player.hasPermission("axiom.can_import_blocks");
+
+                        if (restrictions.maxSectionsPerSecond != rateLimit ||
+                                restrictions.canImportBlocks != allowImportingBlocks ||
+                                !Objects.equals(restrictions.boundsMin, boundsMin) ||
+                                !Objects.equals(restrictions.boundsMax, boundsMax)) {
+                            restrictions.maxSectionsPerSecond = rateLimit;
+                            restrictions.canImportBlocks = allowImportingBlocks;
+                            restrictions.boundsMin = boundsMin;
+                            restrictions.boundsMax = boundsMax;
+                            send = true;
+                        }
+
+                        if (send) {
+                            restrictions.send(this, player);
+                        }
                     }
                 }
             }
 
             activeAxiomPlayers.retainAll(stillActiveAxiomPlayers);
             playerBlockBufferRateLimiters.keySet().retainAll(stillActiveAxiomPlayers);
+            playerRestrictions.keySet().retainAll(stillActiveAxiomPlayers);
         }, 20, 20);
 
         int maxChunkRelightsPerTick = configuration.getInt("max-chunk-relights-per-tick");

src/main/java/com/moulberry/axiom/Restrictions.java

@@ -0,0 +1,64 @@
+package com.moulberry.axiom;
+
+import com.moulberry.axiom.integration.plotsquared.PlotSquaredIntegration;
+import io.netty.buffer.Unpooled;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.FriendlyByteBuf;
+import org.bukkit.entity.Player;
+
+public class Restrictions {
+
+    public boolean canImportBlocks = true;
+    public boolean canUseEditor = true;
+    public boolean canEditDisplayEntities = true;
+    public int maxSectionsPerSecond = 0;
+    public BlockPos boundsMin = null;
+    public BlockPos boundsMax = null;
+
+    public PlotSquaredIntegration.PlotBounds lastPlotBounds = null;
+
+    public void send(AxiomPaper plugin, Player player) {
+        if (player.getListeningPluginChannels().contains("axiom:restrictions")) {
+            FriendlyByteBuf buf = new FriendlyByteBuf(Unpooled.buffer());
+            buf.writeBoolean(this.canImportBlocks);
+            buf.writeBoolean(this.canUseEditor);
+            buf.writeBoolean(this.canEditDisplayEntities);
+
+            buf.writeVarInt(this.maxSectionsPerSecond);
+
+            if (this.boundsMin == null || this.boundsMax == null) {
+                buf.writeBoolean(false);
+            } else {
+                buf.writeBoolean(true);
+                int minX = this.boundsMin.getX();
+                int minY = this.boundsMin.getY();
+                int minZ = this.boundsMin.getZ();
+                int maxX = this.boundsMax.getX();
+                int maxY = this.boundsMax.getY();
+                int maxZ = this.boundsMax.getZ();
+
+                if (minX < -33554431) minX = -33554431;
+                if (minX > 33554431) minX = 33554431;
+                if (minY < -2047) minY = -2047;
+                if (minY > 2047) minY = 2047;
+                if (minZ < -33554431) minZ = -33554431;
+                if (minZ > 33554431) minZ = 33554431;
+
+                if (maxX < -33554431) maxX = -33554431;
+                if (maxX > 33554431) maxX = 33554431;
+                if (maxY < -2047) maxY = -2047;
+                if (maxY > 2047) maxY = 2047;
+                if (maxZ < -33554431) maxZ = -33554431;
+                if (maxZ > 33554431) maxZ = 33554431;
+
+                buf.writeBlockPos(new BlockPos(minX, minY, minZ));
+                buf.writeBlockPos(new BlockPos(maxX, maxY, maxZ));
+            }
+
+            byte[] bytes = new byte[buf.writerIndex()];
+            buf.getBytes(0, bytes);
+            player.sendPluginMessage(plugin, "axiom:restrictions", bytes);
+        }
+    }
+
+}

src/main/java/com/moulberry/axiom/integration/plotsquared/PlotSquaredIntegration.java

@@ -2,14 +2,35 @@
 
 
 import com.moulberry.axiom.integration.SectionPermissionChecker;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import net.minecraft.core.BlockPos;
 import org.bukkit.Bukkit;
+import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Player;
 
 
 public class PlotSquaredIntegration {
 
+    public record PlotBounds(BlockPos min, BlockPos max, String worldName) {
+        public PlotBounds(CuboidRegion cuboidRegion, String worldName) {
+            this(
+                new BlockPos(
+                    cuboidRegion.getMinimumPoint().getBlockX(),
+                    cuboidRegion.getMinimumPoint().getBlockY(),
+                    cuboidRegion.getMinimumPoint().getBlockZ()
+                ),
+                new BlockPos(
+                    cuboidRegion.getMaximumPoint().getBlockX(),
+                    cuboidRegion.getMaximumPoint().getBlockY(),
+                    cuboidRegion.getMaximumPoint().getBlockZ()
+                ),
+                worldName
+            );
+        }
+    }
+
     public static boolean canBreakBlock(Player player, Block block) {
         if (!Bukkit.getPluginManager().isPluginEnabled("PlotSquared")) {
             return true;
@@ -31,6 +52,13 @@ public static boolean isPlotWorld(World world) {
         return PlotSquaredIntegrationImpl.isPlotWorld(world);
     }
 
+    public static PlotSquaredIntegration.PlotBounds getCurrentEditablePlot(Player player) {
+        if (!Bukkit.getPluginManager().isPluginEnabled("PlotSquared")) {
+            return null;
+        }
+        return PlotSquaredIntegrationImpl.getCurrentEditablePlot(player);
+    }
+
     public static SectionPermissionChecker checkSection(Player player, World world, int sectionX, int sectionY, int sectionZ) {
         if (!Bukkit.getPluginManager().isPluginEnabled("PlotSquared")) {
             return SectionPermissionChecker.ALL_ALLOWED;

src/main/java/com/moulberry/axiom/integration/plotsquared/PlotSquaredIntegrationImpl.java

@@ -135,6 +135,52 @@ static boolean isPlotWorld(World world) {
         return isPlotWorld;
     }
 
+    static PlotSquaredIntegration.PlotBounds getCurrentEditablePlot(Player player) {
+        org.bukkit.Location loc = player.getLocation();
+
+        Location location = BukkitUtil.adapt(loc);
+        PlotArea area = location.getPlotArea();
+        if (area == null) {
+            return null;
+        }
+
+        BukkitPlayer pp = BukkitUtil.adapt(player);
+        Plot plot = area.getPlot(location);
+        if (plot != null) {
+            Location bottom = plot.getExtendedBottomAbs();
+            Location top = plot.getExtendedTopAbs();
+            CuboidRegion cuboidRegion = new CuboidRegion(bottom.getBlockVector3(), top.getBlockVector3());
+
+            // check unowned plots
+            if (!plot.hasOwner()) {
+                if (!pp.hasPermission(Permission.PERMISSION_ADMIN_BUILD_UNOWNED, false)) {
+                    return null;
+                } else {
+                    return new PlotSquaredIntegration.PlotBounds(cuboidRegion, player.getWorld().getName());
+                }
+            }
+            // player is breaking another player's plot
+            if (!plot.isAdded(pp.getUUID())) {
+                if (!pp.hasPermission(Permission.PERMISSION_ADMIN_BUILD_OTHER, false)) {
+                    return null;
+                } else {
+                    return new PlotSquaredIntegration.PlotBounds(cuboidRegion, player.getWorld().getName());
+                }
+            }
+            // plot is 'done'
+            if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
+                if (!pp.hasPermission(Permission.PERMISSION_ADMIN_BUILD_OTHER, false)) {
+                    return null;
+                } else {
+                    return new PlotSquaredIntegration.PlotBounds(cuboidRegion, player.getWorld().getName());
+                }
+            }
+            return new PlotSquaredIntegration.PlotBounds(cuboidRegion, player.getWorld().getName());
+        }
+
+        return null;
+    }
+
     static SectionPermissionChecker checkSection(Player player, World world, int sectionX, int sectionY, int sectionZ) {
         int minX = sectionX * 16;
         int minY = sectionY * 16;
@@ -220,4 +266,4 @@ static SectionPermissionChecker checkSection(Player player, World world, int sec
 
         return SectionPermissionChecker.fromAllowedBoxes(allowed);
     }
-}
+}