player update optimized

src/engine/mobileAI/MobAI.java

@@ -1204,7 +1204,6 @@ public class MobAI {
         try {
 
             //check for players that can be aggroed if mob is agressive and has no target
-            Enum.GameObjectType targetType = mob.getCombatTarget().getObjectType();
             if (mob.getCombatTarget() != null && mob.playerAgroMap.containsKey(mob.getCombatTarget().getObjectUUID()) == false && !mob.getCombatTarget().getObjectType().equals(Enum.GameObjectType.Mob))
                 mob.setCombatTarget(null);
 

src/engine/workthreads/ProcessUpdate.java

@@ -0,0 +1,42 @@
+package engine.workthreads;
+
+import engine.job.AbstractJob;
+import engine.job.JobThread;
+import engine.objects.PlayerCharacter;
+import org.pmw.tinylog.Logger;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class ProcessUpdate implements Runnable{
+    private final ReentrantLock lock = new ReentrantLock();
+    private PlayerCharacter playerCharacter;
+    public ProcessUpdate(PlayerCharacter pc){
+        this.playerCharacter = pc;
+    }
+
+    public void run() {
+        try {
+            if (this.playerCharacter != null) {
+                if (lock.tryLock(10, TimeUnit.SECONDS)) { // Timeout to prevent deadlock
+                    try {
+                        this.playerCharacter.update(true);
+                    } finally {
+                        lock.unlock();
+                    }
+                } else {
+                    Logger.warn("JobThread could not acquire lock in time, skipping job.");
+                }
+            }
+        } catch (Exception e) {
+            Logger.error(e);
+        }
+    }
+
+    public static void startUpdate(PlayerCharacter pc) {
+        ProcessUpdate updateThread = new ProcessUpdate(pc);
+        Thread thread = new Thread(updateThread);
+        thread.setName(pc.getObjectUUID() + " UPDATE");
+        thread.start();
+    }
+}

src/engine/workthreads/UpdateThread.java

@@ -32,33 +32,22 @@ public class UpdateThread implements Runnable {
     private static final long INSTANCE_DELAY = 1500; // Adjust as needed
 
     public void processPlayerUpdate() {
-        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
+        //try {
+        //    for (PlayerCharacter player : SessionManager.getAllActivePlayerCharacters()) {
+        //        if (player != null) {
+        //            try {
+        //                player.update(true);
+        //            } catch (Exception e) {
+        //                Logger.error(e);
+        //            }
+        //        }
+         //   }
+        //}catch(Exception e){
+        //    Logger.error(e);
+        //}
 
-        try {
+        for (PlayerCharacter player : SessionManager.getAllActivePlayerCharacters()) {
-            for (PlayerCharacter player : SessionManager.getAllActivePlayerCharacters()) {
+            ProcessUpdate.startUpdate(player);
-                if (player != null) {
-                    Future<?> future = executor.submit(() -> {
-                        try {
-                            player.update(true);
-                        } catch (Exception e) {
-                            Logger.error(e);
-                        }
-                    });
-
-                    try {
-                        future.get(10, TimeUnit.SECONDS); // Enforce max execution time
-                    } catch (TimeoutException e) {
-                        Logger.error("Player update timed out for: " + player.getName());
-                        future.cancel(true); // Attempt to cancel the task
-                    } catch (Exception e) {
-                        Logger.error(e);
-                    }
-                }
-            }
-        } catch (Exception e) {
-            Logger.error("UPDATE ERROR", e);
-        } finally {
-            executor.shutdown();
         }
     }
 
@@ -66,6 +55,7 @@ public class UpdateThread implements Runnable {
     public void run() {
         try {
             processPlayerUpdate();
+            Thread.sleep(1000);
         } catch (Exception e) {
             Logger.error("Thread Execution Error", e);
         }