player update optimized

This reverts commit 9e1e12b177.

src/engine/mobileAI/MobAI.java

@@ -109,7 +109,6 @@ public class MobAI {
 
             if(target.getPet() != null && target.getPet().isAlive()){
                 mob.setCombatTarget(target.getPet());
-                return;
             }
 
             if (mob.BehaviourType.callsForHelp)
@@ -265,6 +264,9 @@ public class MobAI {
                     target.setCombatTarget(mob);
                 }
             }
+
+            if(target.combatTarget == null)
+                target.setCombatTarget(mob);
         } catch (Exception e) {
             Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackMob" + " " + e.getMessage());
         }
@@ -724,8 +726,8 @@ public class MobAI {
                     DefaultLogic(mob);
                     break;
             }
-            if(mob.isAlive())
-                RecoverHealth(mob);
+            //if(mob.isAlive())
+            //    RecoverHealth(mob);
         } catch (Exception e) {
             Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: DetermineAction" + " " + e.getMessage());
         }
@@ -735,6 +737,10 @@ public class MobAI {
 
         try {
 
+            //do not switch target if you already have one, dropping out of range is handled elsewhere
+            if(aiAgent.combatTarget != null)
+                return;
+
             //looks for and sets mobs combatTarget
 
             if (!aiAgent.isAlive())
@@ -1102,17 +1108,17 @@ public class MobAI {
             if (mob.getCombatTarget() == null)
                 CheckForPlayerGuardAggro(mob);
 
-            AbstractWorldObject newTarget = ChangeTargetFromHateValue(mob);
+            //AbstractWorldObject newTarget = ChangeTargetFromHateValue(mob);
 
-            if (newTarget != null) {
+            //if (newTarget != null) {
 
-                if (newTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {
-                    if (GuardCanAggro(mob, (PlayerCharacter) newTarget))
-                        mob.setCombatTarget(newTarget);
-                } else
-                    mob.setCombatTarget(newTarget);
+            //    if (newTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {
+            //        if (GuardCanAggro(mob, (PlayerCharacter) newTarget))
+            //            mob.setCombatTarget(newTarget);
+            //    } else
+            //        mob.setCombatTarget(newTarget);
 
-            }
+            //}
             CheckMobMovement(mob);
             CheckForAttack(mob);
         } catch (Exception e) {
@@ -1198,25 +1204,24 @@ public class MobAI {
         try {
 
             //check for players that can be aggroed if mob is agressive and has no target
-
-            if (mob.getCombatTarget() != null && mob.playerAgroMap.containsKey(mob.getCombatTarget().getObjectUUID()) == false)
+            if (mob.getCombatTarget() != null && mob.playerAgroMap.containsKey(mob.getCombatTarget().getObjectUUID()) == false && !mob.getCombatTarget().getObjectType().equals(Enum.GameObjectType.Mob))
                 mob.setCombatTarget(null);
 
-            if (mob.BehaviourType.isAgressive) {
+            //if (mob.BehaviourType.isAgressive) {
 
-                AbstractWorldObject newTarget = ChangeTargetFromHateValue(mob);
+             //   AbstractWorldObject newTarget = ChangeTargetFromHateValue(mob);
 
-                if (newTarget != null)
-                    mob.setCombatTarget(newTarget);
-                else {
-                    if (mob.getCombatTarget() == null) {
-                        if (mob.BehaviourType == Enum.MobBehaviourType.HamletGuard)
-                            SafeGuardAggro(mob);  //safehold guard
-                        else
-                            CheckForAggro(mob);   //normal aggro
-                    }
-                }
-            }
+             //   if (newTarget != null)
+             //       mob.setCombatTarget(newTarget);
+            //    else {
+            //        if (mob.getCombatTarget() == null) {
+            //            if (mob.BehaviourType == Enum.MobBehaviourType.HamletGuard)
+             //               SafeGuardAggro(mob);  //safehold guard
+            //            else
+            //                CheckForAggro(mob);   //normal aggro
+            //        }
+            //    }
+            //}
 
             //check if mob can move for patrol or moving to target
 

src/engine/objects/Experience.java

@@ -367,6 +367,9 @@ public class Experience {
                 if (member.getLevel() >= MBServerStatics.LEVELCAP)
                     continue;
 
+                if(!member.isAlive())
+                    continue;
+
                 if(member.level >= 75 && !mob.getObjectType().equals(Enum.GameObjectType.PlayerCharacter))
                     continue; // cannot PVE higher than level 75
 

src/engine/objects/PlayerCharacter.java

@@ -5177,8 +5177,8 @@ public class PlayerCharacter extends AbstractCharacter {
                         } else {
                             this.combatStats.update();
                         }
-                        //this.doRegen();
-                        this.combatStats.regenerate();
+                        this.doRegen();
+                        //this.combatStats.regenerate();
                     }
 
                     if (this.getStamina() < 10) {

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

@@ -17,6 +17,8 @@ import engine.objects.PlayerCharacter;
 import engine.objects.PlayerCombatStats;
 import org.pmw.tinylog.Logger;
 
+import java.util.concurrent.*;
+
 public class UpdateThread implements Runnable {
 
     private volatile Long lastRun;
@@ -27,36 +29,35 @@ public class UpdateThread implements Runnable {
     }
 
 
-    public void processPlayerUpdate() {
+    private static final long INSTANCE_DELAY = 1500; // Adjust as needed
 
+    public void processPlayerUpdate() {
         try {
-            for(PlayerCharacter player : SessionManager.getAllActivePlayerCharacters()){
+            for (PlayerCharacter player : SessionManager.getAllActivePlayerCharacters()) {
                 if (player != null) {
-                    player.update(true);
+                    try {
+                        player.update(true);
+                    } catch (Exception e) {
+                        Logger.error(e);
+                    }
                 }
             }
-        } catch (Exception e) {
-            Logger.error("UPDATE ERROR",e);
+        }catch(Exception e){
+            Logger.error(e);
         }
 
-
+        //for (PlayerCharacter player : SessionManager.getAllActivePlayerCharacters()) {
+        //    ProcessUpdate.startUpdate(player);
+        //}
     }
 
+    @Override
     public void run() {
-        lastRun = System.currentTimeMillis();
-        while (true) {
-            if (System.currentTimeMillis() >= lastRun + instancedelay) { // Correct condition
-                this.processPlayerUpdate();
-                lastRun = System.currentTimeMillis(); // Update lastRun after processing
-            }else {
-                try {
-                    Thread.sleep(100); // Pause for 100ms to reduce CPU usage
-                } catch (InterruptedException e) {
-                    Logger.error("Thread interrupted", e);
-                    Thread.currentThread().interrupt();
-                }
-            }
-            Thread.yield();
+        try {
+            processPlayerUpdate();
+            Thread.sleep(100);
+        } catch (Exception e) {
+            Logger.error("Thread Execution Error", e);
         }
     }