feat: add StressCommand for simulating player load and enhance Learni…

AntiAFK-Core/src/main/java/com/bentahsin/antiafk/MainInitializer.java

@@ -6,6 +6,7 @@
 import com.bentahsin.antiafk.commands.AntiAFKBaseCommand;
 import com.bentahsin.antiafk.commands.CaptchaCommands;
 import com.bentahsin.antiafk.commands.PlayerAFKCommand;
+import com.bentahsin.antiafk.commands.StressCommand;
 import com.bentahsin.antiafk.commands.pattern.PatternCommand;
 import com.bentahsin.antiafk.gui.book.BookInputListener;
 import com.bentahsin.antiafk.gui.book.BookInputManager;
@@ -53,6 +54,7 @@ public class MainInitializer {
     private final Provider<PlayerAFKCommand> playerAFKCommandProvider;
     private final Provider<CaptchaCommands> captchaCommandsProvider;
     private final Provider<PatternCommand> patternCommandProvider;
+    private final Provider<StressCommand> stressCommandProvider;
 
     @Inject
     public MainInitializer(
@@ -67,7 +69,8 @@ public MainInitializer(
             Provider<AntiAFKBaseCommand> baseCommandProvider,
             Provider<PlayerAFKCommand> playerAFKCommandProvider,
             Provider<CaptchaCommands> captchaCommandsProvider,
-            Provider<PatternCommand> patternCommandProvider
+            Provider<PatternCommand> patternCommandProvider,
+            Provider<StressCommand> stressCommandProvider
     ) {
         this.plugin = plugin;
         this.configManager = configManager;
@@ -88,6 +91,7 @@ public MainInitializer(
         this.playerAFKCommandProvider = playerAFKCommandProvider;
         this.captchaCommandsProvider = captchaCommandsProvider;
         this.patternCommandProvider = patternCommandProvider;
+        this.stressCommandProvider = stressCommandProvider;
     }
 
     public void initialize() {
@@ -143,6 +147,7 @@ private void setupCommands() {
         acfManager.registerCommand(playerAFKCommandProvider.get());
         acfManager.registerCommand(captchaCommandsProvider.get());
         acfManager.registerCommand(patternCommandProvider.get());
+        acfManager.registerCommand(stressCommandProvider.get());
 
         debugManager.log(DebugManager.DebugModule.COMMAND_REGISTRATION, "Commands registered via ACF.");
     }

AntiAFK-Core/src/main/java/com/bentahsin/antiafk/commands/StressCommand.java

@@ -0,0 +1,76 @@
+package com.bentahsin.antiafk.commands;
+
+import co.aikar.commands.BaseCommand;
+import co.aikar.commands.annotation.CommandAlias;
+import co.aikar.commands.annotation.CommandPermission;
+import co.aikar.commands.annotation.Subcommand;
+import com.bentahsin.antiafk.AntiAFKPlugin;
+import com.bentahsin.antiafk.learning.PatternAnalysisTask;
+import com.bentahsin.antiafk.api.learning.MovementVector;
+import com.google.inject.Inject;
+import org.bukkit.command.CommandSender;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+@CommandAlias("antiafk")
+public class StressCommand extends BaseCommand {
+
+    private final AntiAFKPlugin plugin;
+    private final PatternAnalysisTask analysisTask;
+    private final List<UUID> fakePlayers = new ArrayList<>();
+    private boolean isRunning = false;
+
+    @Inject
+    public StressCommand(AntiAFKPlugin plugin, PatternAnalysisTask analysisTask) {
+        this.plugin = plugin;
+        this.analysisTask = analysisTask;
+
+        for (int i = 0; i < 500; i++) {
+            fakePlayers.add(UUID.randomUUID());
+        }
+    }
+
+    @Subcommand("stress")
+    @CommandPermission("antiafk.admin")
+    public void onStress(CommandSender sender, String action) {
+        if (action.equalsIgnoreCase("start")) {
+            if (isRunning) {
+                sender.sendMessage("§cTest zaten çalışıyor!");
+                return;
+            }
+            isRunning = true;
+            sender.sendMessage("§a500 Oyuncu Simülasyonu Başlatıldı! Profiler'ı açın.");
+            sender.sendMessage("§7(Bu test sadece AntiAFK'nın işlemci ve RAM yükünü ölçer.)");
+
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    if (!isRunning) {
+                        this.cancel();
+                        return;
+                    }
+
+                    for (UUID uuid : fakePlayers) {
+                        double dx = (Math.random() - 0.5) * 0.5;
+                        double dz = (Math.random() - 0.5) * 0.5;
+                        double dYaw = (Math.random() - 0.5) * 10;
+
+                        analysisTask.queueMovementData(
+                                uuid,
+                                dx, dz, dYaw, 0.0,
+                                MovementVector.PlayerAction.NONE,
+                                1
+                        );
+                    }
+                }
+            }.runTaskTimerAsynchronously(plugin, 0L, 1L);
+
+        } else if (action.equalsIgnoreCase("stop")) {
+            isRunning = false;
+            sender.sendMessage("§cTest durduruldu.");
+        }
+    }
+}

AntiAFK-Core/src/main/java/com/bentahsin/antiafk/learning/collector/LearningDataCollectorTask.java

@@ -20,15 +20,19 @@ public class LearningDataCollectorTask extends BukkitRunnable {
     private final Provider<PatternAnalysisTask> analysisTaskProvider;
     private final Map<UUID, LearningData> playerData = new ConcurrentHashMap<>();
 
+    private PatternAnalysisTask cachedAnalysisTask;
+
     @Inject
     public LearningDataCollectorTask(Provider<PatternAnalysisTask> analysisTaskProvider) {
         this.analysisTaskProvider = analysisTaskProvider;
     }
 
     @Override
     public void run() {
-        PatternAnalysisTask analysisTask = analysisTaskProvider.get();
-        if (analysisTask == null) return;
+        if (cachedAnalysisTask == null) {
+            cachedAnalysisTask = analysisTaskProvider.get();
+            if (cachedAnalysisTask == null) return;
+        }
 
         for (Player player : Bukkit.getOnlinePlayers()) {
             LearningData data = playerData.computeIfAbsent(player.getUniqueId(), k -> new LearningData());
@@ -83,7 +87,7 @@ private void createAndQueueVector(Player p, Location from, Location to, Movement
             dX = dZ = dYaw = dPitch = 0;
         }
 
-        analysisTaskProvider.get().queueMovementData(p.getUniqueId(), dX, dZ, dYaw, dPitch, action, duration);
+        cachedAnalysisTask.queueMovementData(p.getUniqueId(), dX, dZ, dYaw, dPitch, action, duration);
     }
 
     public void onPlayerQuit(Player player) {

AntiAFK-Core/src/main/java/com/bentahsin/antiafk/learning/pool/VectorPoolManager.java

@@ -1,18 +1,13 @@
 package com.bentahsin.antiafk.learning.pool;
 
 import com.bentahsin.antiafk.AntiAFKPlugin;
-import com.bentahsin.antiafk.language.Lang;
-import com.bentahsin.antiafk.language.SystemLanguageManager;
 import com.bentahsin.antiafk.api.learning.MovementVector;
 import com.bentahsin.antiafk.managers.DebugManager;
 import com.google.inject.Inject;
 import com.google.inject.Singleton;
 import org.apache.commons.pool2.impl.GenericObjectPool;
 import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
 
-import java.time.Duration;
-import java.util.logging.Level;
-
 /**
  * MovementVector nesne havuzunu yönetir.
  */
@@ -21,19 +16,19 @@ public class VectorPoolManager {
 
     private final GenericObjectPool<MovementVector> pool;
     private final AntiAFKPlugin plugin;
-    private final SystemLanguageManager sysLang;
     private final DebugManager debugMgr;
 
     @Inject
-    public VectorPoolManager(AntiAFKPlugin plugin, DebugManager debugMgr, SystemLanguageManager sysLang) {
+    public VectorPoolManager(AntiAFKPlugin plugin, DebugManager debugMgr) {
         this.plugin = plugin;
-        this.sysLang = sysLang;
         this.debugMgr = debugMgr;
 
         GenericObjectPoolConfig<MovementVector> config = new GenericObjectPoolConfig<>();
-        config.setMaxTotal(2000);
+        config.setMaxTotal(10000);
+        config.setMaxIdle(2000);
+        config.setMinIdle(100);
 
-        config.setMaxWait(Duration.ofMillis(100));
+        config.setBlockWhenExhausted(false);
 
         this.pool = new GenericObjectPool<>(new MovementVectorFactory(), config);
     }
@@ -58,7 +53,9 @@ public MovementVector borrowVector(double dx, double dz, double dYaw, double dPi
             );
             return vector;
         } catch (Exception e) {
-            plugin.getLogger().log(Level.WARNING, sysLang.getSystemMessage(Lang.VECTOR_POOL_BORROW_ERROR), e);
+            if (debugMgr.isEnabled(DebugManager.DebugModule.LEARNING_MODE)) {
+                plugin.getLogger().warning("Pool exhausted, creating fresh vector. (High Load)");
+            }
             return new MovementVector(dx, dz, dYaw, dPitch, action, durationTicks);
         }
     }