update: add per-player spawner limit functionality and related commands

Author: ptthanh02

README.md

@@ -1,63 +1,122 @@
-# 🎯 SSAddon SpawnerLimiter
+# SSAddon SpawnerLimiter
 
-SSAddon (SmartSpawner Addon) that limits spawner placement per chunk based on spawner stacks, with Folia support!
+SSAddon (SmartSpawner Addon) that limits spawner placement per chunk and per player based on spawner stacks, with Folia support!
 
 [![Minecraft](https://img.shields.io/badge/Minecraft-1.21.4+-green.svg)](https://www.minecraft.net/)
 [![Paper](https://img.shields.io/badge/Server-Paper%20%7C%20Folia-blue.svg)](https://papermc.io/)
 [![Java](https://img.shields.io/badge/Java-21+-orange.svg)](https://www.oracle.com/java/)
 
-## 📋 Requirements
+## Requirements
 
 - **Minecraft**: 1.21.4+
 - **Server**: Paper or Folia
 - **Java**: 21+
 - **SmartSpawner**: 1.5.7.1+
 
-## 📦 Installation
+## Installation
 
 1. Install [SmartSpawner](https://modrinth.com/plugin/smart-spawner-plugin) plugin
 2. Download SSASpawnerLimiter
 3. Place the `.jar` file in your `plugins` folder
 4. Restart the server
 5. Configure settings in `plugins/SSASpawnerLimiter/config.yml`
 
-## 🎮 Commands
+## Commands
 
 | Command | Description | Aliases |
 |---------|-------------|---------|
 | `/ssaspawnerlimiter reload` | Reload plugin configuration | `/ssalimiter reload` |
 | `/ssaspawnerlimiter info` | Check spawner count in current chunk | `/ssalimiter info` |
-| `/ssaspawnerlimiter check <player>` | Check spawner limit for a specific player | `/ssalimiter check <player>` |
+| `/ssaspawnerlimiter check <player>` | Check spawner limit for player's chunk | `/ssalimiter check <player>` |
+| `/ssaspawnerlimiter checkplayer <player>` | Check player's global spawner count | `/ssalimiter checkplayer <player>` |
 | `/ssaspawnerlimiter stats` | View plugin statistics | `/ssalimiter stats` |
 
-## 🔐 Permissions
+## Permissions
 
+### Bypass Permissions
 | Permission | Description | Default |
 |------------|-------------|---------|
 | `ssaspawnerlimiter.bypass` | Bypass spawner chunk limit | `false` |
+| `ssaspawnerlimiter.perplayer.bypass` | Bypass per-player spawner limit (unlimited) | `false` |
+
+### Per-Player Limit Tiers
+You can create **custom limit tiers** using the permission pattern: `ssaspawnerlimiter.perplayer.<number>`
+
+**Examples:**
+- `ssaspawnerlimiter.perplayer.1500` → Allows 1500 spawners globally
+- `ssaspawnerlimiter.perplayer.2000` → Allows 2000 spawners globally
+- `ssaspawnerlimiter.perplayer.5000` → Allows 5000 spawners globally
+- `ssaspawnerlimiter.perplayer.10000` → Allows 10000 spawners globally
+- Any number you want!
+
+> **Note:** Players with multiple tier permissions will get the highest value. Default limit is configured in `config.yml` as `max_spawners_per_player`.
+
+### Command Permissions
+| Permission | Description | Default |
+|------------|-------------|---------|
 | `ssaspawnerlimiter.command.use` | Base permission for all commands | `op` |
 | `ssaspawnerlimiter.command.reload` | Use reload command | `op` |
 | `ssaspawnerlimiter.command.info` | Use info command | `op` |
 | `ssaspawnerlimiter.command.check` | Use check command | `op` |
+| `ssaspawnerlimiter.command.checkplayer` | Use checkplayer command | `op` |
 | `ssaspawnerlimiter.command.stats` | Use stats command | `op` |
 
-## 📖 How It Works
+## How It Works
+
+SSASpawnerLimiter provides **two independent limit systems**:
 
-SSASpawnerLimiter counts **spawner stacks** instead of just spawner blocks:
+### Chunk-Based Limit
+Limits spawner stacks per chunk to prevent chunk overloading:
 - 1 spawner block with 64 stacks = **64 count**
 - 1 spawner block with 6 stacks = **6 count**
 - **Total in chunk**: 70 count
+- Default: 100 spawners per chunk
+
+### Per-Player Limit
+Limits total spawner stacks a player can place globally:
+- Tracks all spawners placed by each player across the entire server
+- Default: 1000 spawners per player
+- Can be increased via permission nodes (1500, 2000, 5000, etc.)
+- Bypass permission for unlimited spawners
+
+**Both systems can be enabled/disabled independently in `config.yml`:**
+```yaml
+enable_chunk_limit: true      # Enable chunk-based limiting
+enable_player_limit: true     # Enable per-player limiting
+```
+
+### Stack Counting Example
+- Player places 1 spawner with stack size 10 → **Adds 10** to both chunk and player count
+- Player breaks that spawner → **Removes 10** from both counts
+- Player stacks spawner from 10 to 20 → **Adds 10** more to both counts
+- Counts never go below 0 (zero-floor protection)
 
 This ensures fair limiting based on actual spawner capacity, not just physical blocks.
 
-## 🗄️ Database
+## Configuration
+
+**config.yml:**
+```yaml
+# Chunk limit settings
+enable_chunk_limit: true
+max_spawners_per_chunk: 1000
+verify_chunk_count_on_check: true  # Verify actual count from SmartSpawner API
+
+# Per-player limit settings  
+enable_player_limit: true
+max_spawners_per_player: 500      # Default limit for all players
+```
+
+## Database
 
-The plugin uses SQLite to store spawner chunk data. You can view and manage the database using:
+The plugin uses SQLite to store spawner data in two tables:
+- `spawner_chunks` - Chunk spawner counts
+- `player_spawners` - Per-player spawner counts
 
-**[SQLite Viewer](https://sqliteviewer.app/)** - A free online tool to view and edit SQLite databases
+**[SQLite Viewer](https://sqliteviewer.app/)** - Free online tool to view and edit SQLite databases
 
 Database location: `plugins/SSASpawnerLimiter/spawner_limits.db`
 
-## 📄 License
+## License
 
 This project is licensed under the CC-BY-NC-SA-4.0 License - see the [LICENSE](LICENSE) file for details.

src/main/java/github/io/ssaspawnerlimiter/SSASpawnerLimiter.java

@@ -4,6 +4,7 @@
 import github.io.ssaspawnerlimiter.database.DatabaseManager;
 import github.io.ssaspawnerlimiter.listener.SpawnerLimitListener;
 import github.io.ssaspawnerlimiter.service.ChunkLimitService;
+import github.io.ssaspawnerlimiter.service.PlayerLimitService;
 import lombok.Getter;
 import lombok.experimental.Accessors;
 import org.bukkit.Bukkit;
@@ -31,6 +32,7 @@ public final class SSASpawnerLimiter extends JavaPlugin {
     private SmartSpawnerAPI api;
     private DatabaseManager databaseManager;
     private ChunkLimitService chunkLimitService;
+    private PlayerLimitService playerLimitService;
     private BrigadierCommandManager commandManager;
     private Scheduler.Task cacheCleanupTask;
 
@@ -39,9 +41,7 @@ private void checkSmartSpawnerAPI() {
         if (api == null) {
             getLogger().warning("SmartSpawner not found! This addon requires SmartSpawner to work.");
             getServer().getPluginManager().disablePlugin(this);
-            return;
         }
-        getLogger().info("SmartSpawner found, integrated with SSA Spawner Limiter");
     }
 
     private void checkPluginUpdates() {
@@ -91,13 +91,17 @@ private void initializeServices() {
         // Initialize chunk limit service
         chunkLimitService = new ChunkLimitService(this, databaseManager);
 
+        // Initialize player limit service
+        playerLimitService = new PlayerLimitService(this, databaseManager);
+
         // Register event listeners
-        Bukkit.getPluginManager().registerEvents(new SpawnerLimitListener(this, chunkLimitService), this);
+        Bukkit.getPluginManager().registerEvents(new SpawnerLimitListener(this, chunkLimitService, playerLimitService), this);
 
         // Start cache cleanup task (hardcoded: 5 minutes = 6000 ticks)
         long cleanupInterval = 6000L; // 5 minutes in ticks
         cacheCleanupTask = Scheduler.runTaskTimerAsync(() -> {
             chunkLimitService.cleanupExpiredCache();
+            playerLimitService.cleanupExpiredCache();
         }, cleanupInterval, cleanupInterval);
     }
 

src/main/java/github/io/ssaspawnerlimiter/command/MainCommand.java

@@ -3,6 +3,7 @@
 import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import com.mojang.brigadier.tree.LiteralCommandNode;
 import github.io.ssaspawnerlimiter.SSASpawnerLimiter;
+import github.io.ssaspawnerlimiter.command.subcommands.CheckPlayerSubCommand;
 import github.io.ssaspawnerlimiter.command.subcommands.CheckSubCommand;
 import github.io.ssaspawnerlimiter.command.subcommands.InfoSubCommand;
 import github.io.ssaspawnerlimiter.command.subcommands.ReloadSubCommand;
@@ -33,6 +34,7 @@ public MainCommand(SSASpawnerLimiter plugin) {
                 new ReloadSubCommand(plugin),
                 new InfoSubCommand(plugin),
                 new CheckSubCommand(plugin),
+                new CheckPlayerSubCommand(plugin),
                 new StatsSubCommand(plugin)
         );
     }

src/main/java/github/io/ssaspawnerlimiter/command/subcommands/CheckPlayerSubCommand.java

@@ -0,0 +1,104 @@
+package github.io.ssaspawnerlimiter.command.subcommands;
+
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
+import com.mojang.brigadier.context.CommandContext;
+import github.io.ssaspawnerlimiter.Scheduler;
+import github.io.ssaspawnerlimiter.SSASpawnerLimiter;
+import github.io.ssaspawnerlimiter.command.BaseSubCommand;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.command.brigadier.Commands;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jspecify.annotations.NullMarked;
+
+import java.util.UUID;
+
+@NullMarked
+public class CheckPlayerSubCommand extends BaseSubCommand {
+
+    public CheckPlayerSubCommand(SSASpawnerLimiter plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public String getName() {
+        return "checkplayer";
+    }
+
+    @Override
+    public String getPermission() {
+        return "ssaspawnerlimiter.command.checkplayer";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Check per-player spawner count";
+    }
+
+    @Override
+    public LiteralArgumentBuilder<CommandSourceStack> build() {
+        LiteralArgumentBuilder<CommandSourceStack> builder = Commands.literal(getName());
+
+        builder.requires(source -> hasPermission(source.getSender()));
+
+        // Add player argument with suggestions
+        builder.then(Commands.argument("player", StringArgumentType.word())
+                .suggests((context, suggestionsBuilder) -> {
+                    for (Player p : Bukkit.getOnlinePlayers()) {
+                        suggestionsBuilder.suggest(p.getName());
+                    }
+                    return suggestionsBuilder.buildFuture();
+                })
+                .executes(this::executeWithPlayer));
+
+        // Add execute for when no player is provided (show usage)
+        builder.executes(this::execute);
+
+        return builder;
+    }
+
+    @Override
+    public int execute(CommandContext<CommandSourceStack> context) {
+        CommandSender sender = context.getSource().getSender();
+        plugin.getMessageService().sendMessage(sender, "command_usage_checkplayer");
+        return 0;
+    }
+
+    private int executeWithPlayer(CommandContext<CommandSourceStack> context) {
+        CommandSender sender = context.getSource().getSender();
+        String playerName = context.getArgument("player", String.class);
+
+        Player target = Bukkit.getPlayer(playerName);
+        if (target == null || !target.isOnline()) {
+            plugin.getMessageService().sendMessage(sender, "command_checkplayer_player_not_found");
+            return 0;
+        }
+
+        UUID targetUUID = target.getUniqueId();
+
+        // Run async to avoid blocking
+        Scheduler.runTaskAsync(() -> {
+            int count = plugin.getPlayerLimitService().getPlayerSpawnerCount(targetUUID);
+            int limit = plugin.getPlayerLimitService().getPlayerLimit(target);
+
+            // Send message on appropriate thread
+            java.util.Map<String, String> placeholders = new java.util.HashMap<>();
+            placeholders.put("player", target.getName());
+            placeholders.put("current", String.valueOf(count));
+            placeholders.put("limit", limit == Integer.MAX_VALUE ? "∞" : String.valueOf(limit));
+
+            if (sender instanceof Player player) {
+                Scheduler.runAtLocation(player.getLocation(), () ->
+                    plugin.getMessageService().sendMessage(sender, "command_checkplayer_result", placeholders)
+                );
+            } else {
+                plugin.getMessageService().sendMessage(sender, "command_checkplayer_result", placeholders);
+            }
+        });
+
+        return 1;
+    }
+}
+

src/main/java/github/io/ssaspawnerlimiter/command/subcommands/ReloadSubCommand.java

@@ -42,12 +42,18 @@ public int execute(CommandContext<CommandSourceStack> context) {
             // Reinitialize language system
             plugin.getLanguageManager().reloadLanguages();
 
-            // Clear cache
+            // Reload and clear cache for chunk limit service
             if (plugin.getChunkLimitService() != null) {
                 plugin.getChunkLimitService().loadSpawnerLimit();
                 plugin.getChunkLimitService().clearCache();
             }
 
+            // Reload and clear cache for player limit service
+            if (plugin.getPlayerLimitService() != null) {
+                plugin.getPlayerLimitService().loadConfiguration();
+                plugin.getPlayerLimitService().clearCache();
+            }
+
             plugin.getMessageService().sendMessage(sender, "reload_success");
             return 1;
         } catch (Exception e) {