fix charge bug

# Conflicts:
#	src/engine/gameManager/CombatManager.java
#	src/engine/gameManager/PowersManager.java
#	src/engine/mobileAI/MobAI.java
#	src/engine/objects/Experience.java
#	src/engine/objects/PlayerCharacter.java
#	src/engine/objects/PlayerCombatStats.java
#	src/engine/util/KeyCloneAudit.java
#	src/engine/workthreads/UpdateThread.java

src/engine/Enum.java

@@ -2325,8 +2325,7 @@ public class Enum {
 
         GRID(544),
         ZONE(672),
-        PLACEMENT(673),
-        SIEGEBOUNDS(1750);
+        PLACEMENT(673);
 
         public final float extents;
 

src/engine/InterestManagement/InterestManager.java

@@ -511,15 +511,15 @@ public enum InterestManager implements Runnable {
         if (player == null)
             return;
 
-        //for(PlayerCharacter pc : SessionManager.getAllActivePlayerCharacters()){
-        //    if(pc.equals(player)){
-        //        try{
-        //            WorldGrid.RemoveWorldObject(player);
-        //        }catch(Exception e){
+        for(PlayerCharacter pc : SessionManager.getAllActivePlayerCharacters()){
+            if(pc.equals(player)){
+                try{
+                    WorldGrid.RemoveWorldObject(player);
+                }catch(Exception e){
 
-        //        }
-        //    }
-        //}
+                }
+            }
+        }
 
 
 
@@ -567,4 +567,23 @@ public enum InterestManager implements Runnable {
             playerCharacter.setDirtyLoad(true);
         }
     }
+
+    public void RefreshLoadedObjects(PlayerCharacter player){
+        try {
+            if (player == null)
+                return;
+
+            ClientConnection origin = player.getClientConnection();
+
+            if (origin == null)
+                return;
+
+            // Update loaded upbjects lists
+            player.setDirtyLoad(true);
+            updateStaticList(player, origin);
+            updateMobileList(player, origin);
+        }catch(Exception e){
+            Logger.error(e.getMessage());
+        }
+    }
 }

src/engine/devcmd/cmds/AddGoldCmd.java

@@ -14,6 +14,7 @@ import engine.gameManager.ChatManager;
 import engine.objects.AbstractGameObject;
 import engine.objects.Item;
 import engine.objects.PlayerCharacter;
+import engine.server.MBServerStatics;
 
 /**
  * @author Eighty
@@ -46,10 +47,10 @@ public class AddGoldCmd extends AbstractDevCmd {
             throwbackError(pc, "Quantity must be a number, " + words[0] + " is invalid");
             return;
         }
-        if (amt < 1 || amt > 10000000) {
-            throwbackError(pc, "Quantity must be between 1 and 10000000 (10 million)");
+        if (amt < 1 || amt > MBServerStatics.PLAYER_GOLD_LIMIT) {
+            throwbackError(pc, "Quantity must be between 1 and " + MBServerStatics.PLAYER_GOLD_LIMIT);
             return;
-        } else if ((curAmt + amt) > 10000000) {
+        } else if ((curAmt + amt) > MBServerStatics.PLAYER_GOLD_LIMIT) {
             throwbackError(pc, "This would place your inventory over 10,000,000 gold.");
             return;
         }

src/engine/devcmd/cmds/AddMobCmd.java

@@ -9,12 +9,17 @@
 
 package engine.devcmd.cmds;
 
+import engine.Enum;
 import engine.Enum.GameObjectType;
+import engine.InterestManagement.InterestManager;
+import engine.InterestManagement.WorldGrid;
 import engine.devcmd.AbstractDevCmd;
 import engine.gameManager.ChatManager;
 import engine.gameManager.DbManager;
+import engine.gameManager.LootManager;
 import engine.gameManager.ZoneManager;
 import engine.math.Vector3fImmutable;
+import engine.mobileAI.utilities.MovementUtilities;
 import engine.objects.*;
 import org.pmw.tinylog.Logger;
 
@@ -83,13 +88,41 @@ public class AddMobCmd extends AbstractDevCmd {
         }
 
 
-        Mob mob = Mob.createMob(loadID, pc.getLoc(),
-                null, true, zone, null, 0, "", 1);
+        Mob mob = Mob.createMob(loadID, pc.getLoc(),null, true, zone, null, 0, "", 1);
+        //Mob mob = Mob.createStrongholdMob(loadID,pc.loc,Guild.getErrantGuild(),true,zone,null,0,"Whitehorn Militant",75);
         if (mob != null) {
             mob.updateDatabase();
             ChatManager.chatSayInfo(pc,
                     "Mob with ID " + mob.getDBID() + " added");
             this.setResult(String.valueOf(mob.getDBID()));
+
+            mob.parentZone = zone;
+            mob.bindLoc = pc.loc;
+            mob.setLoc(pc.loc);
+            mob.equipmentSetID = 6327;
+            mob.runAfterLoad();
+            mob.setLevel((short)75);
+            mob.setResists(new Resists("Elite"));
+            mob.spawnTime = 10;
+            mob.BehaviourType = Enum.MobBehaviourType.Aggro;
+            zone.zoneMobSet.add(mob);
+            mob.isHellgateMob = true;
+            LootManager.GenerateStrongholdLoot(mob,false,false);
+            mob.healthMax  = mob.mobBase.getHealthMax();
+            mob.setHealth(mob.healthMax);
+            mob.maxDamageHandOne = 1550;
+            mob.minDamageHandOne = 750;
+            mob.atrHandOne = 1800;
+            mob.defenseRating = 2200;
+            mob.setFirstName("Whitehorn Militant");
+            //InterestManager.setObjectDirty(mob);
+            //WorldGrid.addObject(mob,pc.loc.x,pc.loc.z);
+            //WorldGrid.updateObject(mob);
+            //guard.stronghold = mine;
+            mob.mobPowers.clear();
+            mob.mobPowers.put(429399948,20); // find weakness
+
+
         } else {
             throwbackError(pc, "Failed to create mob of type " + loadID);
             Logger.error("Failed to create mob of type "

src/engine/devcmd/cmds/GimmeCmd.java

@@ -17,6 +17,7 @@ import engine.gameManager.ChatManager;
 import engine.gameManager.DbManager;
 import engine.objects.*;
 import engine.powers.EffectsBase;
+import engine.server.MBServerStatics;
 
 import java.util.ArrayList;
 
@@ -34,7 +35,7 @@ public class GimmeCmd extends AbstractDevCmd {
                           AbstractGameObject target) {
         int amt = 0;
         int currentGold = pc.getCharItemManager().getGoldInventory().getNumOfItems();
-        amt = 10000000 - currentGold;
+        amt = MBServerStatics.PLAYER_GOLD_LIMIT - currentGold;
         if (!pc.getCharItemManager().addGoldToInventory(amt, true)) {
             throwbackError(pc, "Failed to add gold to inventory");
             return;

src/engine/devcmd/cmds/InfoCmd.java

@@ -346,7 +346,8 @@ public class InfoCmd extends AbstractDevCmd {
                 output += "Hidden : " + targetPC.getHidden() + newline;
                 output += "Target Loc: " + targetPC.loc + newline;
                 output += "Player Loc: " + pc.loc + newline;
-                output += "Distance Squared: " + pc.loc.distanceSquared(targetPC.loc);
+                output += "Distance Squared: " + pc.loc.distanceSquared(targetPC.loc) + newline;
+                output += "IsBoxed: " + targetPC.isBoxed;
                 break;
 
             case NPC:

src/engine/devcmd/cmds/PrintEffectsCmd.java

@@ -0,0 +1,75 @@
+// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
+// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
+// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
+// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
+// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
+//      Magicbane Emulator Project © 2013 - 2022
+//                www.magicbane.com
+
+
+package engine.devcmd.cmds;
+
+import engine.Enum;
+import engine.Enum.BuildingGroup;
+import engine.Enum.GameObjectType;
+import engine.Enum.TargetColor;
+import engine.devcmd.AbstractDevCmd;
+import engine.gameManager.BuildingManager;
+import engine.gameManager.PowersManager;
+import engine.gameManager.SessionManager;
+import engine.math.Vector3fImmutable;
+import engine.objects.*;
+import engine.powers.EffectsBase;
+import engine.server.MBServerStatics;
+import engine.util.StringUtils;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.concurrent.ConcurrentHashMap;
+
+
+/**
+ * @author
+ */
+public class PrintEffectsCmd extends AbstractDevCmd {
+
+    public PrintEffectsCmd() {
+        super("printeffects");
+    }
+
+    @Override
+    protected void _doCmd(PlayerCharacter pc, String[] words,
+                          AbstractGameObject target) {
+
+        if(!target.getObjectType().equals(GameObjectType.PlayerCharacter)) {
+            throwbackInfo(pc, "Target Must PlayerCharacter");
+            return;
+        }
+        String newline = "\r\n ";
+        String output = "Effects for Player:" + newline;
+
+        AbstractCharacter absTar = (AbstractCharacter) target;
+
+        for(String key : absTar.effects.keySet()){
+            Effect eff = absTar.effects.get(key);
+            if(eff.getJobContainer() != null) {
+                output += "[" + key + "] " + eff.getName() + " (" + eff.getTrains() + ") " + eff.getJobContainer().timeToExecutionLeft() * 0.001f + newline;
+            }else{
+                output += eff.getName() + " (" + eff.getTrains() + ") " + "PERMANENT" + newline;
+            }
+        }
+
+        throwbackInfo(pc, output);
+    }
+
+    @Override
+    protected String _getHelpString() {
+        return "Gets information on an Object.";
+    }
+
+    @Override
+    protected String _getUsageString() {
+        return "' /info targetID'";
+    }
+
+}

src/engine/devcmd/cmds/PrintStatsCmd.java

@@ -87,6 +87,7 @@ public class PrintStatsCmd extends AbstractDevCmd {
         newOut += "MAX: " + tar.combatStats.maxDamageHandTwo + newline;
         newOut += "RANGE: " + tar.combatStats.rangeHandTwo + newline;
         newOut += "ATTACK SPEED: " + tar.combatStats.attackSpeedHandTwo + newline;
+        newOut += "IS BOXED: " + tar.isBoxed + newline;
         newOut += "=== POWERS ===" + newline;
         for(CharacterPower power : pc.getPowers().values()){
             if(power.getPower().requiresHitRoll) {

src/engine/gameManager/ArenaManager.java

@@ -18,8 +18,6 @@ public class ArenaManager {
     public static Long pulseDelay = 180000L;
     public static Long lastExecution = 0L;
 
-    public static float arena_radius = 500f;
-
     public static void pulseArenas() {
         if(lastExecution == 0L){
             lastExecution = System.currentTimeMillis();
@@ -112,10 +110,13 @@ public class ArenaManager {
 
         if(winner != null){
             ChatManager.chatPVP("[ARENA] " + winner.getName() + " has slain " + loser.getName() + " in the arena!");
-            //handle prize distribution of wrapped rune gift
-            //ItemBase specialLoot = ItemBase.getItemBase(971070);
-            //MobLoot winnings = new MobLoot(winner,specialLoot,false);
-            //winner.getCharItemManager().addItemToInventory(winnings.promoteToItem(winner));
+            //handle prize distribution
+            //ItemBase specialLoot = ItemBase.getItemBase(866);
+            //Item promoted = new MobLoot(winner, specialLoot, 1, false).promoteToItem(winner);
+            //promoted.setNumOfItems(21235);
+            //promoted.setName("Special Banker(21235)");
+            //DbManager.ItemQueries.UPDATE_NUM_ITEMS(promoted,21235);
+            //winner.getCharItemManager().addItemToInventory(promoted);
             //winner.getCharItemManager().updateInventory();
         }
     }
@@ -131,7 +132,7 @@ public class ArenaManager {
                 float y = 0; // Y coordinate is always 0
 
                 loc = new Vector3fImmutable(x, y, z * -1);
-                HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(loc,arena_radius, MBServerStatics.MASK_PLAYER);
+                HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(loc,500f, MBServerStatics.MASK_PLAYER);
                 if(inRange.isEmpty() && !isUnderWater(loc))
                     locSet = true;
                 //}

src/engine/gameManager/BaneManager.java

@@ -1,45 +0,0 @@
-package engine.gameManager;
-
-import engine.Enum;
-import engine.objects.Bane;
-import org.joda.time.DateTime;
-
-public class BaneManager {
-
-    public static void default_check(){
-        for(Bane bane : Bane.banes.values()){
-            if(!bane.daySet || !bane.timeSet || !bane.capSet){
-                DateTime placementDate = bane.getPlacementDate();
-                if(DateTime.now().isAfter(placementDate.plusHours(48))){
-                    //set bane for default time
-                    if(!bane.daySet){
-                        bane.daySet = true;
-                        DbManager.BaneQueries.SET_BANE_DAY_NEW(3,bane.getCityUUID());
-                    }
-
-                    if(!bane.timeSet){
-                        bane.timeSet = true;
-                        DbManager.BaneQueries.SET_BANE_TIME_NEW(9,bane.getCityUUID());
-                    }
-
-                    if(!bane.capSet){
-                        bane.capSet = true;
-                        bane.capSize = 20;
-                        DbManager.BaneQueries.SET_BANE_CAP_NEW(20,bane.getCityUUID());
-                    }
-                    bane.setLiveDate(DbManager.BaneQueries.getLiveDate(bane.getCityUUID()));
-                }
-            }
-        }
-    }
-
-    public static void pulse_banes(){
-        //used to pulse the anti-zerg mechanic of active banes
-        for(Bane bane : Bane.banes.values()){
-            if(bane.getSiegePhase().equals(Enum.SiegePhase.WAR)){
-                // bane is live, handle bane anti-zerg mechanic stuff
-                bane.applyZergBuffs();
-            }
-        }
-    }
-}

src/engine/gameManager/ChatManager.java

@@ -89,6 +89,11 @@ public enum ChatManager {
             return;
         }
 
+        if(msg.getMessage().equalsIgnoreCase("./zerg")){
+            ZergManager.PrintDetailsToClient(pc);
+            return;
+        }
+
         switch (protocolMsg) {
             case CHATSAY:
                 ChatManager.chatSay(pc, msg.getMessage(), isFlood);

src/engine/gameManager/CombatManager.java

@@ -432,7 +432,10 @@ public enum CombatManager {
 
             //Source can attack.
             //NOTE Don't 'return;' beyond this point until timer created
-
+            if(abstractCharacter.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                PlayerCharacter pc = (PlayerCharacter)abstractCharacter;
+                pc.updateMovementState();
+            }
             boolean attackFailure = (wb != null) && (wb.getRange() > 35f) && abstractCharacter.isMoving();
 
             //Target can't attack on move with ranged weapons.
@@ -470,18 +473,28 @@ public enum CombatManager {
 
             //Range check.
 
-            if(abstractCharacter.isMoving()){
-                range += (abstractCharacter.getSpeed() * 0.1f);
-            }
+            //if(abstractCharacter.isMoving()){
+            //    range += (abstractCharacter.getSpeed() * 0.1f); // add movement vector offset for moving attacker
+            //}
 
-            if(AbstractWorldObject.IsAbstractCharacter(target)) {
-                AbstractCharacter tarAc = (AbstractCharacter) target;
-                if(tarAc != null && tarAc.isMoving()){
-                    range += (tarAc.getSpeed() * 0.1f);
-                }
-            }
+            //if(AbstractWorldObject.IsAbstractCharacter(target)) {
+            //    AbstractCharacter tarAc = (AbstractCharacter) target;
+            //    if(tarAc != null && tarAc.isMoving()){
+            //        range += (tarAc.getSpeed() * 0.1f); // add movement vector offset for moving target
+           //     }
+            //}
+
+            //float attackerHitBox = abstractCharacter.calcHitBox(); // add attacker hitbox
+            //float targetHitBox = 0.0f;
+            //if(AbstractCharacter.IsAbstractCharacter(target)){
+            //    AbstractCharacter targetCharacter = (AbstractCharacter)target;
+            //    targetHitBox = targetCharacter.calcHitBox(); // add target hitbox
+            //}
+
+            //range += attackerHitBox + targetHitBox + 2.5f; // offset standard range to sync where client tries to stop
+
+            range += 2; //sync offset
 
-            range += 2;
             if (NotInRange(abstractCharacter, target, range)) {
 
                 //target is in stealth and can't be seen by source
@@ -950,9 +963,6 @@ public enum CombatManager {
 
                 //Subtract Damage from target's health
 
-                if(ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
-                    damage *= ((PlayerCharacter)ac).ZergMultiplier;
-                }
                 if (tarAc != null) {
 
                     if (tarAc.isSit())
@@ -1009,60 +1019,61 @@ public enum CombatManager {
                 //handle damage shields
 
                 if (ac.isAlive() && tarAc != null && tarAc.isAlive())
-                    try {
-                        handleDamageShields(ac, tarAc, damage);
-                    }catch(Exception e){
-                        Logger.error(e.getMessage());
+                    handleDamageShields(ac, tarAc, damage);
+
+                //handle mob hate values
+                if(target.getObjectType().equals(GameObjectType.Mob) && ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                    Mob mobTarget = (Mob)target;
+                    if(mobTarget.hate_values.containsKey((PlayerCharacter) ac)){
+                        mobTarget.hate_values.put((PlayerCharacter) ac,mobTarget.hate_values.get((PlayerCharacter) ac) + damage);
+                    }else{
+                        mobTarget.hate_values.put((PlayerCharacter) ac, damage);
                     }
+                }
 
             } else {
 
                 // Apply Weapon power effect if any.
                 // don't try to apply twice if dual wielding.
-                try {
-                    if (ac.getObjectType().equals(GameObjectType.PlayerCharacter) && (mainHand || wb.isTwoHanded())) {
-                        dpj = ((PlayerCharacter) ac).getWeaponPower();
 
-                        if (dpj != null) {
+                if (ac.getObjectType().equals(GameObjectType.PlayerCharacter) && (mainHand || wb.isTwoHanded())) {
+                    dpj = ((PlayerCharacter) ac).getWeaponPower();
 
-                            PowersBase wp = dpj.getPower();
+                    if (dpj != null) {
 
-                            if (wp.requiresHitRoll() == false) {
-                                PlayerBonuses bonus = ac.getBonuses();
-                                float attackRange = getWeaponRange(wb, bonus);
+                        PowersBase wp = dpj.getPower();
 
-                                if (ac.isMoving()) {
-                                    attackRange += (ac.getSpeed() * 0.1f);
-                                }
-
-                                if (AbstractWorldObject.IsAbstractCharacter(target)) {
-                                    AbstractCharacter tarAc = (AbstractCharacter) target;
-                                    if (tarAc != null && tarAc.isMoving()) {
-                                        attackRange += (tarAc.getSpeed() * 0.1f);
-                                    }
+                        if (wp.requiresHitRoll() == false) {
+                            PlayerBonuses bonus = ac.getBonuses();
+                            float attackRange = getWeaponRange(wb, bonus);
+
+                            if(ac.isMoving()){
+                                attackRange += (ac.getSpeed() * 0.1f);
+                            }
+
+                            if(AbstractWorldObject.IsAbstractCharacter(target)) {
+                                AbstractCharacter tarAc = (AbstractCharacter) target;
+                                if(tarAc != null && tarAc.isMoving()){
+                                    attackRange += (tarAc.getSpeed() * 0.1f);
                                 }
+                            }
 
 
-                                if (specialCaseHitRoll(dpj.getPowerToken())) {
-                                    if (hitLanded) {
-                                        dpj.attack(target, attackRange);
-                                    }
-                                } else {
+                            if(specialCaseHitRoll(dpj.getPowerToken())) {
+                                if(hitLanded) {
                                     dpj.attack(target, attackRange);
                                 }
-                            } else
-                                ((PlayerCharacter) ac).setWeaponPower(null);
-                        }
+                            }else{
+                                dpj.attack(target, attackRange);
+                            }
+                        } else
+                            ((PlayerCharacter) ac).setWeaponPower(null);
                     }
-                }catch(Exception e) {
-                    Logger.error(e.getMessage());
-                }
-                try {
-                    if (target.getObjectType() == GameObjectType.Mob)
-                        ((Mob) target).handleDirectAggro(ac);
-                }catch(Exception e){
-                    Logger.error(e.getMessage());
                 }
+
+                if (target.getObjectType() == GameObjectType.Mob)
+                    ((Mob) target).handleDirectAggro(ac);
+
                 errorTrack = 17;
 
                 //miss, Send miss message

src/engine/gameManager/DevCmdManager.java

@@ -56,6 +56,7 @@ public enum DevCmdManager {
         DevCmdManager.registerDevCmd(new PrintResistsCmd());
         DevCmdManager.registerDevCmd(new PrintLocationCmd());
         DevCmdManager.registerDevCmd(new InfoCmd());
+        DevCmdManager.registerDevCmd(new PrintEffectsCmd());
         DevCmdManager.registerDevCmd(new aiInfoCmd());
         DevCmdManager.registerDevCmd(new SimulateBootyCmd());
         DevCmdManager.registerDevCmd(new GetHeightCmd());

src/engine/gameManager/ForgeManager.java

@@ -1,15 +0,0 @@
-package engine.gameManager;
-
-import engine.objects.ForgeWorkOrder;
-import engine.objects.NPC;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-
-public class ForgeManager {
-    public HashMap<NPC, ArrayList<ForgeWorkOrder>> work_orders;
-
-    public static void add_work_order(NPC npc, ForgeWorkOrder workOrder){
-
-    }
-}

src/engine/gameManager/HellgateManager.java

@@ -0,0 +1,289 @@
+package engine.gameManager;
+
+import engine.mobileAI.MobAI;
+import engine.mobileAI.utilities.CombatUtilities;
+import engine.mobileAI.utilities.MovementUtilities;
+import engine.objects.*;
+import engine.server.MBServerStatics;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class HellgateManager {
+    public static ArrayList<Mob> hellgate_mobs;
+    public static ArrayList<Mob> hellgate_mini_bosses;
+    public static Mob hellgate_boss;
+
+    public static Long hellgate_time_completed = 0L;
+    public static final int citadel_ruins_zone_id = 993;
+    public static final int hell_portal_1_zone_id = 994;
+    public static final int hell_portal_2_zone_id = 996;
+    public static final int hell_portal_3_zone_id = 997;
+    public static final int hell_portal_4_zone_id = 998;
+
+    public static boolean initialized = false;
+
+    public static final ArrayList<Integer> static_rune_ids_low = new ArrayList<>(Arrays.asList(
+            250001, 250002, 250003, 250004, 250005, 250006, 250010, 250011,
+            250012, 250013, 250014, 250015, 250019, 250020, 250021, 250022,
+            250023, 250024, 250028, 250029, 250030, 250031, 250032, 250033,
+            250037, 250038, 250039, 250040, 250041, 250042
+    ));
+
+    public static final ArrayList<Integer> static_rune_ids_mid = new ArrayList<>(Arrays.asList(
+            250006, 250007, 250008,
+            250015, 250016, 250017,
+            250024, 250025, 250026,
+            250033, 250034, 250035,
+            250042, 250043, 250044
+    ));
+
+    public static final ArrayList<Integer> static_rune_ids_high = new ArrayList<>(Arrays.asList(
+            250007, 250008,
+            250016, 250017,
+            250025, 250026,
+            250034, 250035,
+            250043, 250044
+    ));
+    public static void confiureHellgate(){
+        compile_mob_list();
+    }
+    public static void pulseHellgates(){
+        if(!initialized){
+            confiureHellgate();
+            if(hellgate_boss != null)
+                initialized = true;
+            return;
+        }
+
+        if(hellgate_mobs == null) {
+            return;
+        }
+        if(hellgate_mini_bosses == null) {
+            return;
+        }
+        if(hellgate_boss == null){
+            return;
+        }
+
+        if(!hellgate_boss.isAlive() && hellgate_time_completed == 0L)
+            hellgate_time_completed = System.currentTimeMillis();
+
+        if(hellgate_time_completed != 0L && System.currentTimeMillis() > hellgate_time_completed + MBServerStatics.THIRTY_MINUTES){
+            ResetHellgate();
+        }
+    }
+
+    public static void compile_mob_list(){
+        if(hellgate_mobs == null) {
+            hellgate_mobs =new ArrayList<>();
+        }
+        if(hellgate_mini_bosses == null) {
+            hellgate_mini_bosses =new ArrayList<>();
+        }
+        Zone hellgate_zone = ZoneManager.getZoneByUUID(citadel_ruins_zone_id);
+        if(hellgate_zone == null)
+            return;
+
+        for(Mob mob : hellgate_zone.zoneMobSet){
+            switch(mob.getMobBaseID()){
+                case 14163: // basic saetor warrior
+                    mob.getCharItemManager().clearInventory();
+                    SpecialLootHandler(mob,false,false);
+                    mob.setResists(new Resists("Elite"));
+                    mob.healthMax = 8500;
+                    mob.setHealth(mob.healthMax);
+                    hellgate_mobs.add(mob);
+                    break;
+                case 12770: // minotaur mini boss
+                    mob.getCharItemManager().clearInventory();
+                    SpecialLootHandler(mob,true,false);
+                    mob.setResists(new Resists("Elite"));
+                    mob.healthMax = 12500;
+                    mob.setHealth(mob.healthMax);
+                    hellgate_mini_bosses.add(mob);
+                    break;
+                case 14180: // mordoth, son of morlock
+                    mob.getCharItemManager().clearInventory();
+                    SpecialLootHandler(mob,false,true);
+                    mob.setResists(new Resists("Elite"));
+                    mob.healthMax = mob.mobBase.getHealthMax();
+                    mob.setHealth(mob.healthMax);
+                    hellgate_boss = mob;
+                    break;
+            }
+        }
+    }
+
+    public static void ResetHellgate(){
+        hellgate_time_completed = 0L;
+        for(Mob mob : hellgate_mobs){
+            if(!mob.isAlive()){
+                if(!mob.despawned){
+                    mob.despawn();
+                }
+                mob.respawn();
+            }
+            mob.setHealth(mob.healthMax);
+            SpecialLootHandler(mob,false,false);
+        }
+        for(Mob mob : hellgate_mini_bosses){
+            if(!mob.isAlive()){
+                if(!mob.despawned){
+                    mob.despawn();
+                }
+                mob.respawn();
+            }
+            mob.setHealth(mob.healthMax);
+            SpecialLootHandler(mob,true,false);
+        }
+        if(!hellgate_boss.isAlive()){
+            if(!hellgate_boss.despawned){
+                hellgate_boss.despawn();
+            }
+            hellgate_boss.respawn();
+        }
+        hellgate_boss.setHealth(hellgate_boss.healthMax);
+        SpecialLootHandler(hellgate_boss,false,true);
+    }
+
+    public static void SpecialMobAIHandler(Mob mob){
+
+        if(mob.playerAgroMap.isEmpty())
+            return;
+
+        if(!mob.isAlive())
+            return;
+
+        if(mob.combatTarget == null)
+            MobAI.NewAggroMechanic(mob);
+
+        if(MovementUtilities.canMove(mob) &&  mob.combatTarget != null && !CombatUtilities.inRangeToAttack(mob,mob.combatTarget))
+            MobAI.chaseTarget(mob);
+
+        if(mob.combatTarget != null)
+            MobAI.CheckForAttack(mob);
+
+        if(mob.combatTarget == null && mob.loc.distanceSquared(mob.bindLoc) > 1024) {//32 units
+            mob.teleport(mob.bindLoc);
+            mob.setCombatTarget(null);
+            MovementUtilities.aiMove(mob,mob.bindLoc,true);
+        }
+    }
+
+    public static void SpecialLootHandler(Mob mob, Boolean commander, Boolean epic){
+        mob.getCharItemManager().clearInventory();
+        int contractRoll = ThreadLocalRandom.current().nextInt(1,101);
+        if(contractRoll <= 25){
+            //generate random contract
+
+        }
+
+        int runeRoll = ThreadLocalRandom.current().nextInt(1,101);
+        ItemBase runeBase = null;
+        int roll;
+        int itemId;
+        if(runeRoll <= 60 && !commander && !epic) {
+            //generate random rune (standard 5-30)
+            roll = ThreadLocalRandom.current().nextInt(static_rune_ids_low.size() + 1);
+            itemId = static_rune_ids_low.get(0);
+            try {
+                itemId = static_rune_ids_low.get(roll);
+            } catch (Exception e) {
+
+            }
+            runeBase = ItemBase.getItemBase(itemId);
+            if (runeBase != null) {
+                MobLoot rune = new MobLoot(mob, runeBase, true);
+
+                if (rune != null)
+                    mob.getCharItemManager().addItemToInventory(rune);
+            }
+        }
+        if(runeRoll <= 50 && commander) {
+            //generate random rune (30-40)
+            roll = ThreadLocalRandom.current().nextInt(static_rune_ids_mid.size() + 1);
+            itemId = static_rune_ids_mid.get(0);
+            try {
+                itemId = static_rune_ids_mid.get(roll);
+            } catch (Exception e) {
+
+            }
+            runeBase = ItemBase.getItemBase(itemId);
+            if (runeBase != null) {
+                MobLoot rune = new MobLoot(mob, runeBase, true);
+
+                if (rune != null)
+                    mob.getCharItemManager().addItemToInventory(rune);
+            }
+        }
+
+        if(runeRoll <= 80 && epic) {
+            //generate random rune (35-40)
+            roll = ThreadLocalRandom.current().nextInt(static_rune_ids_high.size() + 1);
+            itemId = static_rune_ids_high.get(0);
+            try {
+                itemId = static_rune_ids_high.get(roll);
+            } catch (Exception e) {
+
+            }
+            runeBase = ItemBase.getItemBase(itemId);
+            if (runeBase != null) {
+                MobLoot rune = new MobLoot(mob, runeBase, true);
+
+                if (rune != null)
+                    mob.getCharItemManager().addItemToInventory(rune);
+            }
+        }
+
+        if(commander || epic) {
+            //handle special case for racial guards
+
+            roll = ThreadLocalRandom.current().nextInt(LootManager.racial_guard_uuids.size() + 1);
+            itemId = LootManager.racial_guard_uuids.get(0);
+            try {
+                itemId = LootManager.racial_guard_uuids.get(roll);
+            } catch (Exception e) {
+
+            }
+            runeBase = ItemBase.getItemBase(itemId);
+            if (runeBase != null) {
+                MobLoot rune = new MobLoot(mob, runeBase, true);
+
+                if (rune != null)
+                    mob.getCharItemManager().addItemToInventory(rune);
+            }
+        }
+
+        if(epic){
+            //handle glass chance for epic
+            int glassRoll = ThreadLocalRandom.current().nextInt(1,101);
+            if(glassRoll < 5){
+                int glassID = LootManager.rollRandomItem(126);
+                ItemBase glassItem = ItemBase.getItemBase(glassID);
+                if (glassItem != null) {
+                    MobLoot glass = new MobLoot(mob, glassItem, true);
+
+                    if (glass != null)
+                        mob.getCharItemManager().addItemToInventory(glass);
+                }
+            }
+        }
+
+        //handle gold drops
+        int goldDrop;
+        if(!commander && !epic){
+            goldDrop = ThreadLocalRandom.current().nextInt(25000);
+            mob.getCharItemManager().addGoldToInventory(goldDrop,false);
+        }
+        if(commander){
+            goldDrop = ThreadLocalRandom.current().nextInt(100000,250000);
+            mob.getCharItemManager().addGoldToInventory(goldDrop,false);
+        }
+        if(epic){
+            goldDrop = ThreadLocalRandom.current().nextInt(2500000,5000000);
+            mob.getCharItemManager().addGoldToInventory(goldDrop,false);
+        }
+    }
+}

src/engine/gameManager/HotzoneManager.java

@@ -0,0 +1,238 @@
+package engine.gameManager;
+
+import engine.Enum;
+import engine.InterestManagement.WorldGrid;
+import engine.math.Vector3fImmutable;
+import engine.net.Dispatch;
+import engine.net.DispatchMessage;
+import engine.net.client.msg.HotzoneChangeMsg;
+import engine.net.client.msg.chat.ChatSystemMsg;
+import engine.objects.*;
+import engine.server.MBServerStatics;
+import org.pmw.tinylog.Logger;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class HotzoneManager {
+    public static Long lastPulseTime = 0L;
+    public static HashMap<Guild, ArrayList<PlayerCharacter>> playersPresent;
+    public static Mob hotzoneMob = null;
+    public static boolean three_quarter_health = false;
+    public static boolean half_health = false;
+    public static boolean quarter_health = false;
+    public static void SelectRandomHotzone(){
+        if(hotzoneMob != null){
+            hotzoneMob.killCharacter("Hotzone Over");
+            hotzoneMob.despawn();
+            hotzoneMob.spawnTime = 1000000000;
+            DbManager.MobQueries.DELETE_MOB( hotzoneMob);
+        }
+        Random random = new Random();
+        Zone newHotzone = null;
+        while (newHotzone == null || newHotzone.getObjectUUID() == 931 || newHotzone.getObjectUUID() == 913)
+            newHotzone = (Zone) ZoneManager.macroZones.toArray()[random.nextInt(ZoneManager.macroZones.size())];
+        ZoneManager.setHotZone(newHotzone);
+        ZoneManager.hotZone = newHotzone;
+        int R8UUId = 0;
+        switch(random.nextInt(5)) {
+            case 1:
+                R8UUId = 14152;
+                break;
+            case 2:
+                R8UUId = 14179;
+                break;
+            case 3:
+                R8UUId = 14180;
+                break;
+            case 4:
+                R8UUId = 14220;
+                break;
+            default:
+                R8UUId = 14319;
+                break;
+        }
+        Mob created = Mob.createMob(R8UUId,newHotzone.getLoc(), Guild.getErrantGuild(),true,newHotzone,null,0,"",85);
+        if(created == null){
+            Logger.error("Failed To Generate Hotzone R8 Mob");
+            return;
+        }
+        ChatSystemMsg chatMsg = new ChatSystemMsg(null, created.getFirstName() + " has spawned in " + newHotzone.getName() + ". Glory and riches await adventurers who dare defeat it!");
+        chatMsg.setMessageType(10);
+        chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+        DispatchMessage.dispatchMsgToAll(chatMsg);
+
+        created.bindLoc = newHotzone.getLoc();
+        created.runAfterLoad();
+        WorldGrid.addObject(created,created.bindLoc.x,created.bindLoc.z);
+        created.teleport(created.bindLoc);
+        created.BehaviourType = Enum.MobBehaviourType.Aggro;
+        hotzoneMob = created;
+        created.setHealth(100000);
+        created.setResists(new Resists("Dropper"));
+        GenerateHotzoneEpicLoot(created);
+        ZoneManager.hotZone = newHotzone;
+
+        for(PlayerCharacter player : SessionManager.getAllActivePlayerCharacters()) {
+            HotzoneChangeMsg hcm = new HotzoneChangeMsg(Enum.GameObjectType.Zone.ordinal(), ZoneManager.hotZone.getObjectUUID());
+            Dispatch dispatch = Dispatch.borrow(player, hcm);
+            DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
+        }
+        three_quarter_health = false;
+        half_health = false;
+        quarter_health = false;
+    }
+
+    public static void GenerateHotzoneEpicLoot(Mob mob) {
+        mob.getCharItemManager().clearInventory();
+        Random random = new Random();
+        int roll;
+        int itemId;
+        //wrapped rune:
+        ItemBase runeBase = ItemBase.getItemBase(971070);
+        if (runeBase != null) {
+            MobLoot rune = new MobLoot(mob, runeBase, true);
+
+            if (rune != null)
+                mob.getCharItemManager().addItemToInventory(rune);
+        }
+
+        roll = ThreadLocalRandom.current().nextInt(1, 101);
+        if (roll >= 95) {
+            //glass
+            int glassID = LootManager.rollRandomItem(126);
+            ItemBase glassItem = ItemBase.getItemBase(glassID);
+            if (glassItem != null) {
+                MobLoot glass = new MobLoot(mob, glassItem, true);
+
+                if (glass != null)
+                    mob.getCharItemManager().addItemToInventory(glass);
+            }
+        }
+
+        roll = ThreadLocalRandom.current().nextInt(1, 101);
+        if (roll >= 95) {
+            //r8 banescroll
+            int baneID = 910018;
+            ItemBase baneItem = ItemBase.getItemBase(baneID);
+            if (baneItem != null) {
+                MobLoot bane = new MobLoot(mob, baneItem, true);
+
+                if (bane != null)
+                    mob.getCharItemManager().addItemToInventory(bane);
+            }
+        }
+
+        roll = ThreadLocalRandom.current().nextInt(1, 101);
+        if (roll >= 95) {
+            //guard captain
+            roll = ThreadLocalRandom.current().nextInt(LootManager.racial_guard_uuids.size() + 1);
+            itemId = LootManager.racial_guard_uuids.get(0);
+            try {
+                itemId = LootManager.racial_guard_uuids.get(roll);
+            } catch (Exception e) {
+
+            }
+            runeBase = ItemBase.getItemBase(itemId);
+            if (runeBase != null) {
+                MobLoot rune = new MobLoot(mob, runeBase, true);
+
+                if (rune != null)
+                    mob.getCharItemManager().addItemToInventory(rune);
+            }
+        }
+    }
+
+    public static void ClearHotzone(){
+        ZoneManager.hotZone = null;
+        for(PlayerCharacter player : SessionManager.getAllActivePlayerCharacters()) {
+            HotzoneChangeMsg hcm = new HotzoneChangeMsg(Enum.GameObjectType.Zone.ordinal(), 0);
+            Dispatch dispatch = Dispatch.borrow(player, hcm);
+            DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
+        }
+    }
+
+    public static void pulse(){
+        if(HotzoneManager.playersPresent == null)
+            HotzoneManager.playersPresent = new HashMap<>();
+
+        if(ZoneManager.hotZone == null)
+            return;
+
+        if(lastPulseTime + 5000L > System.currentTimeMillis())
+            return;
+
+        lastPulseTime = System.currentTimeMillis();
+
+        //handle world announcements for HZ boss
+        if(hotzoneMob != null){
+            float health = hotzoneMob.getHealth();
+            if(health < 75000 && health > 50000 && !three_quarter_health){
+                //mob at 50%-75% health
+                three_quarter_health = true;
+                String name = hotzoneMob.getName();
+                ChatSystemMsg chatMsg = new ChatSystemMsg(null, name + " In The Hotzone Is At 75% Health");
+                chatMsg.setMessageType(10);
+                chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+                DispatchMessage.dispatchMsgToAll(chatMsg);
+            }else if(health < 50000 && health > 25000 && !half_health){
+                //mob ta 25%-50% health
+                half_health = true;
+                String name = hotzoneMob.getName();
+                ChatSystemMsg chatMsg = new ChatSystemMsg(null, name + " In The Hotzone Is At 50% Health");
+                chatMsg.setMessageType(10);
+                chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+                DispatchMessage.dispatchMsgToAll(chatMsg);
+            }else if(health < 25000 && !quarter_health){
+                //mob under 25% health
+                quarter_health = true;
+                String name = hotzoneMob.getName();
+                ChatSystemMsg chatMsg = new ChatSystemMsg(null, name + " In The Hotzone Is At 25% Health");
+                chatMsg.setMessageType(10);
+                chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+                DispatchMessage.dispatchMsgToAll(chatMsg);
+            }else if (health > 75000){
+                //mob at 75% - 100% health
+
+            }
+        }
+
+        HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(ZoneManager.hotZone.getLoc(),ZoneManager.hotZone.getBounds().getHalfExtents().x * 2, MBServerStatics.MASK_PLAYER);
+
+        //clear out old players who aren't here anymore
+        for(Guild nation : HotzoneManager.playersPresent.keySet()){
+            for(PlayerCharacter pc : HotzoneManager.playersPresent.get(nation)){
+                if (!inRange.contains(pc)) {
+                    HotzoneManager.playersPresent.get(nation).remove(pc);
+                    if(HotzoneManager.playersPresent.get(nation).size() < 1){
+                        HotzoneManager.playersPresent.remove(nation);
+                    }
+                }
+            }
+        }
+
+        //check status of current players/nation in vicinity
+        for(AbstractWorldObject awo : inRange){
+            PlayerCharacter pc = (PlayerCharacter)awo;
+            Guild nation = pc.guild.getNation();
+            if(HotzoneManager.playersPresent.containsKey(nation)){
+                //nation already here, add to list
+                if(HotzoneManager.playersPresent.get(nation).size() >= 5 && !HotzoneManager.playersPresent.get(nation).contains(pc)){
+                    //more than 5, boot player out
+                    MovementManager.translocate(pc, Vector3fImmutable.getRandomPointOnCircle(ZoneManager.getZoneByUUID(656).getLoc(),30f),Regions.GetRegionForTeleport(ZoneManager.getZoneByUUID(656).getLoc()));
+                }
+                if(!HotzoneManager.playersPresent.get(nation).contains(pc)){
+                    //less than 5, allow player in
+                    HotzoneManager.playersPresent.get(nation).add(pc);
+                }
+            }else{
+                ArrayList<PlayerCharacter> newList = new ArrayList<>();
+                newList.add(pc);
+                HotzoneManager.playersPresent.put(nation,newList);
+            }
+        }
+    }
+}

src/engine/gameManager/LootManager.java

@@ -92,7 +92,6 @@ public enum LootManager {
             SpecialLootHandler.RollGlass(mob);
             SpecialLootHandler.RollRune(mob);
             SpecialLootHandler.RollRacialGuard(mob);
-            SpecialLootHandler.ResourceDrop(mob);
         }
 
         //determine if mob is in hotzone
@@ -187,6 +186,90 @@ public enum LootManager {
         }
     }
 
+    public static void SpecialCaseContractDrop(Mob mob,ArrayList<BootySetEntry> entries){
+
+        int lootTableID = 0;
+        for(BootySetEntry entry : entries){
+            if(entry.bootyType.equals("LOOT")){
+                lootTableID = entry.genTable;
+                break;
+            }
+        }
+
+        if(lootTableID == 0)
+            return;
+
+        int ContractTableID = 0;
+        for(GenTableEntry entry : _genTables.get(lootTableID)){
+            try {
+                if (ItemBase.getItemBase(_itemTables.get(entry.itemTableID).get(0).cacheID).getType().equals(Enum.ItemType.CONTRACT)) {
+                    ContractTableID = entry.itemTableID;
+                    break;
+                }
+            }catch(Exception e){
+
+            }
+        }
+
+        if(ContractTableID == 0)
+            return;
+
+        ItemBase ib = ItemBase.getItemBase(rollRandomItem(ContractTableID));
+        if(ib != null){
+            MobLoot toAdd = new MobLoot(mob,ib,false);
+            mob.getCharItemManager().addItemToInventory(toAdd);
+        }
+    }
+
+    public static void SpecialCaseRuneDrop(Mob mob,ArrayList<BootySetEntry> entries){
+        int roll = ThreadLocalRandom.current().nextInt(static_rune_ids.size() + 1);
+        int itemId = static_rune_ids.get(0);
+        try {
+            itemId = static_rune_ids.get(roll);
+        }catch(Exception e){
+
+        }
+        ItemBase ib = ItemBase.getItemBase(itemId);
+        if(ib != null){
+            MobLoot toAdd = new MobLoot(mob,ib,false);
+            mob.getCharItemManager().addItemToInventory(toAdd);
+        }
+    }
+
+    public static void SpecialCaseResourceDrop(Mob mob,ArrayList<BootySetEntry> entries){
+        int lootTableID = 0;
+        for(BootySetEntry entry : entries){
+            if(entry.bootyType.equals("LOOT")){
+                lootTableID = entry.genTable;
+                break;
+            }
+        }
+
+        if(lootTableID == 0)
+            return;
+
+        int ResourceTableID = 0;
+        for(GenTableEntry entry : _genTables.get(lootTableID)){
+            try {
+                if (ItemBase.getItemBase(_itemTables.get(entry.itemTableID).get(0).cacheID).getType().equals(Enum.ItemType.RESOURCE)) {
+                    ResourceTableID = entry.itemTableID;
+                    break;
+                }
+            }catch(Exception e){
+
+            }
+        }
+
+        if(ResourceTableID == 0)
+            return;
+
+        ItemBase ib = ItemBase.getItemBase(rollRandomItem(ResourceTableID));
+        if(ib != null){
+            MobLoot toAdd = new MobLoot(mob,ib,false);
+            mob.getCharItemManager().addItemToInventory(toAdd);
+        }
+    }
+
     public static MobLoot getGenTableItem(int genTableID, AbstractCharacter mob, Boolean inHotzone) {
 
         if (mob == null || _genTables.containsKey(genTableID) == false)
@@ -222,11 +305,24 @@ public enum LootManager {
         if (itemUUID == 0)
             return null;
 
-        ItemBase ib = ItemBase.getItemBase(itemUUID);
-        if (ib == null || ib.getType().equals(Enum.ItemType.RESOURCE) || ib.getName().equals("Mithril") || ib.getType().equals(Enum.ItemType.RUNE) || ib.getType().equals(Enum.ItemType.CONTRACT))
-            return null;
-
-        outItem = new MobLoot(mob, ib, false);
+        if (ItemBase.getItemBase(itemUUID).getType().equals(Enum.ItemType.RESOURCE) || ItemBase.getItemBase(itemUUID).getName().equals("Mithril")) {
+            if(ThreadLocalRandom.current().nextInt(1,101) < 91)
+                return null; // cut down world drops rates of resources by 90%
+            int amount = ThreadLocalRandom.current().nextInt(tableRow.minSpawn, tableRow.maxSpawn + 1);
+            return new MobLoot(mob, ItemBase.getItemBase(itemUUID), amount, false);
+        }
+        if(ItemBase.getItemBase(itemUUID).getType().equals(Enum.ItemType.RUNE)){
+            int randomRune = rollRandomItem(itemTableId);
+            if(randomRune != 0) {
+                itemUUID = randomRune;
+            }
+        } else if(ItemBase.getItemBase(itemUUID).getType().equals(Enum.ItemType.CONTRACT)){
+            int randomContract = rollRandomItem(itemTableId);
+            if(randomContract != 0) {
+                itemUUID = randomContract;
+            }
+        }
+        outItem = new MobLoot(mob, ItemBase.getItemBase(itemUUID), false);
 
         if(selectedRow.pModTable != 0){
             try {
@@ -245,6 +341,11 @@ public enum LootManager {
             }
         }
 
+        if(outItem.getItemBase().getType().equals(Enum.ItemType.CONTRACT) || outItem.getItemBase().getType().equals(Enum.ItemType.RUNE)){
+            if(ThreadLocalRandom.current().nextInt(1,101) < 66)
+                return null; // cut down world drops rates of resources by 65%
+        }
+
         return outItem;
     }
 
@@ -516,10 +617,10 @@ public enum LootManager {
                 ItemBase runeBase;
                  if (roll >= 90) {
                 //35 or 40
-                     roll = ThreadLocalRandom.current().nextInt(SpecialLootHandler.static_rune_ids_high.size() + 1);
-                     itemId = SpecialLootHandler.static_rune_ids_high.get(0);
+                     roll = ThreadLocalRandom.current().nextInt(HellgateManager.static_rune_ids_high.size() + 1);
+                     itemId = HellgateManager.static_rune_ids_high.get(0);
                     try {
-                        itemId = SpecialLootHandler.static_rune_ids_high.get(roll);
+                        itemId = HellgateManager.static_rune_ids_high.get(roll);
                    } catch (Exception e) {
 
                     }
@@ -532,10 +633,10 @@ public enum LootManager {
                    }
                 } else if (roll >= 65 && roll <= 89) {
                 //30,35 or 40
-                    roll = ThreadLocalRandom.current().nextInt(SpecialLootHandler.static_rune_ids_mid.size() + 1);
-                    itemId = SpecialLootHandler.static_rune_ids_mid.get(0);
+                    roll = ThreadLocalRandom.current().nextInt(HellgateManager.static_rune_ids_mid.size() + 1);
+                    itemId = HellgateManager.static_rune_ids_mid.get(0);
                     try {
-                        itemId = SpecialLootHandler.static_rune_ids_mid.get(roll);
+                        itemId = HellgateManager.static_rune_ids_mid.get(roll);
                    } catch (Exception e) {
 
                     }
@@ -544,14 +645,14 @@ public enum LootManager {
                         MobLoot rune = new MobLoot(playerCharacter, runeBase, true);
 
                         if (rune != null)
-                            playerCharacter.getCharItemManager().addItemToInventory(rune.promoteToItem(playerCharacter));
+                            playerCharacter.getCharItemManager().addItemToInventory(rune);
                     }
                  } else {
                 //5-30
-                     roll = ThreadLocalRandom.current().nextInt(SpecialLootHandler.static_rune_ids_low.size() + 1);
-                     itemId = SpecialLootHandler.static_rune_ids_low.get(0);
+                     roll = ThreadLocalRandom.current().nextInt(HellgateManager.static_rune_ids_low.size() + 1);
+                     itemId = HellgateManager.static_rune_ids_low.get(0);
                     try {
-                        itemId = SpecialLootHandler.static_rune_ids_low.get(roll);
+                        itemId = HellgateManager.static_rune_ids_low.get(roll);
                     } catch (Exception ignored) {
 
                    }
@@ -560,7 +661,7 @@ public enum LootManager {
                        MobLoot rune = new MobLoot(playerCharacter, runeBase, true);
 
                         if (rune != null)
-                            playerCharacter.getCharItemManager().addItemToInventory(rune.promoteToItem(playerCharacter));
+                            playerCharacter.getCharItemManager().addItemToInventory(rune);
                     }
                 }
                 break;

src/engine/gameManager/LoreMineManager.java

@@ -0,0 +1,130 @@
+package engine.gameManager;
+
+import engine.Enum;
+import engine.math.Vector3fImmutable;
+import engine.objects.Guild;
+import engine.objects.Mine;
+import engine.objects.PlayerCharacter;
+import engine.objects.Regions;
+
+import java.util.*;
+
+public class LoreMineManager {
+
+    //Saetor Allowed Charters:
+    //BARBARIAN
+    //MILITARY
+    //RANGER
+    //AMAZON
+    //WIZARD
+    //MERCENARY
+    //THIEVES
+    //SCOURGE
+    //UNHOLY
+    public static final Map<Enum.GuildType, List<String>> GUILD_RACES = new HashMap<>();
+    public static final Map<Enum.GuildType, List<String>> GUILD_CLASSES = new HashMap<>();
+    public static final Map<Enum.GuildType, Boolean> GUILD_GENDER_RESTRICTION = new HashMap<>();
+
+    static {
+        GUILD_RACES.put(Enum.GuildType.CATHEDRAL, Arrays.asList("Aelfborn", "Centaur", "Elf", "Half Giant", "Human"));
+        GUILD_CLASSES.put(Enum.GuildType.CATHEDRAL, Arrays.asList("Bard", "Channeler", "Crusader", "Nightstalker", "Prelate", "Priest", "Scout", "Sentinel"));
+
+        GUILD_RACES.put(Enum.GuildType.MILITARY, Arrays.asList("Centaur", "Half Giant", "Human", "Saetor"));
+        GUILD_CLASSES.put(Enum.GuildType.MILITARY, Arrays.asList("Bard", "Priest", "Scout", "Warlock", "Warrior", "Wizard"));
+
+        GUILD_RACES.put(Enum.GuildType.TEMPLE, Arrays.asList("Half Giant", "Human"));
+        GUILD_CLASSES.put(Enum.GuildType.TEMPLE, Arrays.asList("Assassin", "Bard", "Channeler", "Confessor", "Nightstalker", "Priest", "Scout", "Templar"));
+
+        GUILD_RACES.put(Enum.GuildType.BARBARIAN, Arrays.asList("Aelfborn", "Half Giant", "Human", "Minotaur", "Saetor"));
+        GUILD_CLASSES.put(Enum.GuildType.BARBARIAN, Arrays.asList("Barbarian", "Bard", "Doomsayer", "Fury", "Priest", "Scout", "Thief", "Warrior"));
+
+        GUILD_RACES.put(Enum.GuildType.RANGER, Arrays.asList("Aelfborn", "Elf", "Half Giant", "Human", "Shade", "Saetor"));
+        GUILD_CLASSES.put(Enum.GuildType.RANGER, Arrays.asList("Bard", "Channeler", "Druid", "Priest", "Ranger", "Scout", "Warrior"));
+
+        GUILD_RACES.put(Enum.GuildType.AMAZON, Arrays.asList("Aelfborn", "Elf", "Half Giant", "Human", "Saetor"));
+        GUILD_CLASSES.put(Enum.GuildType.AMAZON, Arrays.asList("Bard", "Druid", "Fury", "Huntress", "Priest", "Scout", "Warrior", "Wizard"));
+        GUILD_GENDER_RESTRICTION.put(Enum.GuildType.AMAZON, true); // Female only
+
+        GUILD_RACES.put(Enum.GuildType.NOBLE, Arrays.asList("Aelfborn", "Half Giant", "Human"));
+        GUILD_CLASSES.put(Enum.GuildType.NOBLE, Arrays.asList("Assassin", "Bard", "Channeler", "Priest", "Scout", "Thief", "Warlock", "Warrior", "Wizard"));
+
+        GUILD_RACES.put(Enum.GuildType.WIZARD, Arrays.asList("Aelfborn", "Elf", "Human", "Nephilim", "Shade", "Saetor"));
+        GUILD_CLASSES.put(Enum.GuildType.WIZARD, Arrays.asList("Assassin", "Bard", "Channeler", "Doomsayer", "Fury", "Necromancer", "Priest", "Warlock", "Wizard"));
+
+        GUILD_RACES.put(Enum.GuildType.MERCENARY, Arrays.asList("Aelfborn", "Aracoix", "Half Giant", "Human", "Shade", "Saetor"));
+        GUILD_CLASSES.put(Enum.GuildType.MERCENARY, Arrays.asList("Assassin", "Bard", "Priest", "Scout", "Thief", "Warlock", "Warrior"));
+
+        GUILD_RACES.put(Enum.GuildType.THIEVES, Arrays.asList("Aelfborn", "Aracoix", "Elf", "Human", "Irekei", "Nephilim", "Shade", "Vampire", "Saetor"));
+        GUILD_CLASSES.put(Enum.GuildType.THIEVES, Arrays.asList("Assassin", "Barbarian", "Bard", "Priest", "Scout", "Thief", "Wizard"));
+
+        GUILD_RACES.put(Enum.GuildType.DWARF, Arrays.asList("Dwarf"));
+        GUILD_CLASSES.put(Enum.GuildType.DWARF, Arrays.asList("Crusader", "Prelate", "Priest", "Sentinel", "Warrior"));
+
+        GUILD_RACES.put(Enum.GuildType.HIGHCOURT, Arrays.asList("Elf", "Minotaur"));
+        GUILD_CLASSES.put(Enum.GuildType.HIGHCOURT, Arrays.asList("Assassin", "Bard", "Channeler", "Druid", "Necromancer", "Priest", "Ranger", "Scout", "Thief", "Warrior", "Wizard"));
+
+        GUILD_RACES.put(Enum.GuildType.VIRAKT, Arrays.asList("Irekei"));
+        GUILD_CLASSES.put(Enum.GuildType.VIRAKT, Arrays.asList("Assassin", "Bard", "Channeler", "Fury", "Huntress", "Nightstalker", "Priest", "Ranger", "Scout", "Thief", "Warrior", "Wizard"));
+
+        GUILD_RACES.put(Enum.GuildType.SCOURGE, Arrays.asList("Aelfborn", "Human", "Minotaur", "Nephilim", "Saetor"));
+        GUILD_CLASSES.put(Enum.GuildType.SCOURGE, Arrays.asList("Bard", "Channeler", "Doomsayer", "Priest", "Scout", "Warrior", "Wizard"));
+
+        GUILD_RACES.put(Enum.GuildType.KHREE, Arrays.asList("Aracoix"));
+        GUILD_CLASSES.put(Enum.GuildType.KHREE, Arrays.asList("Assassin", "Barbarian", "Bard", "Huntress", "Priest", "Ranger", "Scout", "Thief", "Warlock", "Warrior"));
+
+        GUILD_RACES.put(Enum.GuildType.CENTAUR, Arrays.asList("Centaur"));
+        GUILD_CLASSES.put(Enum.GuildType.CENTAUR, Arrays.asList("Barbarian", "Crusader", "Druid", "Huntress", "Prelate", "Priest", "Ranger", "Sentinel", "Warrior"));
+
+        GUILD_RACES.put(Enum.GuildType.UNHOLY, Arrays.asList("Human", "Shade", "Vampire", "Saetor"));
+        GUILD_CLASSES.put(Enum.GuildType.UNHOLY, Arrays.asList("Assassin", "Channeler", "Necromancer", "Priest", "Scout", "Thief", "Warlock", "Warrior", "Wizard"));
+    }
+
+    public static void AuditPlayer(PlayerCharacter pc, Mine mine){
+        Guild nation = pc.guild.getNation();
+
+        if(mine.chosen_charters == null){
+            mine.chosen_charters = new HashMap<>();
+        }
+
+        Enum.GuildType guildType;
+        if (mine.chosen_charters.containsKey(nation)) {
+            guildType = mine.chosen_charters.get(nation);
+        }else{
+            guildType = Enum.GuildType.getGuildTypeFromInt(pc.guild.getCharter());
+            mine.chosen_charters.put(nation,guildType);
+        }
+
+        if(!validForCharter(pc,guildType)){
+            //bounce out to SDR
+            Vector3fImmutable bounceLoc = Vector3fImmutable.getRandomPointOnCircle(ZoneManager.getZoneByUUID(656).getLoc(),30f);
+            pc.setLoc(bounceLoc);
+            MovementManager.translocate(pc, bounceLoc, Regions.GetRegionForTeleport(ZoneManager.getZoneByUUID(656).getLoc()));
+            ChatManager.chatSystemInfo(pc, "You Failed To Meet Lore Requirements");
+        }
+    }
+
+    public static boolean validForCharter(PlayerCharacter pc, Enum.GuildType guildType) {
+        if(pc.getPromotionClass() == null)
+            return false;
+
+        // Define the races and classes for each GuildType
+
+
+        // Get the allowed races and classes for this guildType
+        List<String> allowedRaces = GUILD_RACES.getOrDefault(guildType, Collections.emptyList());
+        List<String> allowedClasses = GUILD_CLASSES.getOrDefault(guildType, Collections.emptyList());
+
+        // Validate player's race and class
+        if (!allowedRaces.contains(pc.getRace().getName()) || !allowedClasses.contains(pc.getPromotionClass().getName())) {
+            return false;
+        }
+
+        // Gender restriction check for AMAZON
+        if (guildType.equals(Enum.GuildType.AMAZON) && pc.isMale() && pc.getRaceID() != 1999) {
+            return false;
+        }
+
+        return true;
+    }
+
+}

src/engine/gameManager/MovementManager.java

@@ -66,14 +66,6 @@ public enum MovementManager {
         if (!toMove.isAlive())
             return;
 
-        if (toMove.getObjectType().equals(GameObjectType.PlayerCharacter)) {
-            if (((PlayerCharacter) toMove).isCasting()) {
-                ((PlayerCharacter) toMove).updateLocation();
-                ((PlayerCharacter) toMove).updateMovementState();
-            }
-        }
-
-
         toMove.setIsCasting(false);
         toMove.setItemCasting(false);
 
@@ -107,6 +99,9 @@ public enum MovementManager {
         //    		((Mob)toMove).updateLocation();
         // get start and end locations for the move
         Vector3fImmutable startLocation = new Vector3fImmutable(msg.getStartLat(), msg.getStartAlt(), msg.getStartLon());
+        //if(toMove.isMoving()){
+        //    startLocation = toMove.getMovementLoc();
+        //}
         Vector3fImmutable endLocation = new Vector3fImmutable(msg.getEndLat(), msg.getEndAlt(), msg.getEndLon());
 
         //		if (toMove.getObjectType() == GameObjectType.PlayerCharacter)

src/engine/gameManager/PowersManager.java

@@ -28,7 +28,6 @@ import engine.net.client.ClientConnection;
 import engine.net.client.msg.*;
 import engine.objects.*;
 import engine.powers.*;
-import engine.powers.effectmodifiers.AbstractEffectModifier;
 import engine.powers.poweractions.AbstractPowerAction;
 import engine.powers.poweractions.TrackPowerAction;
 import engine.server.MBServerStatics;
@@ -170,10 +169,14 @@ public enum PowersManager {
         if(pc == null)
             return;
 
+        if(pc.getRecycleTimers().containsKey(msg.getPowerUsedID())) {
+            return;
+        }
         if(!pc.isFlying() && powersBaseByToken.get(msg.getPowerUsedID()) != null && powersBaseByToken.get(msg.getPowerUsedID()).isSpell) //cant be sitting if flying
             CombatManager.toggleSit(false,origin);
 
-
+        //if(pc.isMoving())
+            //pc.stopMovement(pc.getMovementLoc());
         if(msg.getPowerUsedID() != 421084024 && origin.getPlayerCharacter().getPromotionClassID() != 2513) {
             if (!origin.getPlayerCharacter().getPowers().containsKey(msg.getPowerUsedID())) {
                 Logger.error(origin.getPlayerCharacter().getFirstName() + " attempted to cast a power they do not have");
@@ -244,6 +247,12 @@ public enum PowersManager {
         if (playerCharacter == null)
             return false;
 
+        //if(playerCharacter.getRecycleTimers().containsKey(msg.getPowerUsedID())){
+       //     playerCharacter.setIsCasting(false);
+        //    playerCharacter.setItemCasting(false);
+        //    return false;
+        //}
+
         boolean CSRCast = false;
 
         if(msg.getPowerUsedID() == 430628895) {
@@ -845,6 +854,19 @@ public enum PowersManager {
     // called when a spell finishes casting. perform actions
     public static void finishUsePower(final PerformActionMsg msg, PlayerCharacter playerCharacter, int casterLiveCounter, int targetLiveCounter) {
 
+       // if(true) {
+        //    newFinishCast(msg);
+        //    return;
+        //}
+
+        //if(HandleItemEnchantments(playerCharacter, msg)) {
+        //    playerCharacter.setIsCasting(false);
+        //    PerformActionMsg castMsg = new PerformActionMsg(msg);
+        //    castMsg.setNumTrains(9999);
+        //    castMsg.setUnknown04(2);
+        //    DispatchMessage.dispatchMsgToInterestArea(playerCharacter, castMsg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
+        //    return;
+        //}
         PerformActionMsg performActionMsg;
         Dispatch dispatch;
 
@@ -1084,6 +1106,13 @@ public enum PowersManager {
 
             //Player didn't miss power, send finish cast. Miss cast already sent.
 
+            //if (playerCharacter.isBoxed) {
+            //    if (AbstractCharacter.IsAbstractCharacter(target)) {
+            //        if (target.getObjectType().equals(GameObjectType.PlayerCharacter)) {
+            //            return;
+             //       }
+             //   }
+            //}
 
             // finally Apply actions
             for (ActionsBase ab : pb.getActions()) {
@@ -1649,7 +1678,7 @@ public enum PowersManager {
                 it.remove();
             else if (awo.getObjectType().equals(GameObjectType.PlayerCharacter)) {
                 PlayerBonuses bonus = ((PlayerCharacter) awo).getBonuses();
-                if (bonus != null && bonus.getBool(ModType.CannotTrack, SourceType.None) || ((PlayerCharacter) awo).getAccount().status.equals(AccountStatus.ADMIN))
+                if (bonus != null && bonus.getBool(ModType.CannotTrack, SourceType.None))
                     it.remove();
             }
         }
@@ -1713,7 +1742,7 @@ public enum PowersManager {
             if(awo.equals(tracker))
                 continue;
             PlayerCharacter pc = (PlayerCharacter)awo;
-            if(!pc.isAlive() || pc.getAccount().status.equals(AccountStatus.ADMIN))
+            if(!pc.isAlive())
                 continue;
             if(guildsPresent.contains(pc.guild.getNation()))
                 list.add(pc);
@@ -1899,6 +1928,18 @@ public enum PowersManager {
     public static void finishApplyPowerA(AbstractCharacter ac,
                                          AbstractWorldObject target, Vector3fImmutable targetLoc,
                                          PowersBase pb, int trains, boolean fromChant) {
+
+
+        //if (ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
+         //   PlayerCharacter pc = (PlayerCharacter) ac;
+         //   if (pc.isBoxed && pb.token != -2133617927) {
+         //       if(AbstractCharacter.IsAbstractCharacter(target)){
+         //           if (target.getObjectType().equals(GameObjectType.PlayerCharacter)){
+         //               return;
+         //           }
+        //        }
+        //    }
+        //}
         // finally Apply actions
         ArrayList<ActionsBase> actions = pb.getActions();
         for (ActionsBase ab : actions) {
@@ -3090,6 +3131,70 @@ public enum PowersManager {
         }
         return true;
     }
+
+    public static boolean HandleItemEnchantments(PlayerCharacter pc, PerformActionMsg msg){
+        switch(msg.getPowerUsedID()){
+            case 429505998: // Reinforce Item
+            case 429407694: // hone weapon
+            case 429440462: // hone armor
+            case 429016905: //poison blade
+            case 429505610: // poison blade
+            case 427908971: // consecrate weapon
+            case 429439055: // mark of slaying
+            case 429605702: // annoint blade
+            case 429414682: // slay rat
+            case 429594877: // consecrate weapon
+            case 429440895: // charm of slaying
+            case 429491437: // infuse with power
+                PowersBase pb = PowersManager.getPowerByToken(msg.getPowerUsedID());
+                if(pb == null)
+                    return false;
+                for (ActionsBase action : pb.getActions()){
+                    try {
+                        if(msg.getNumTrains() > action.maxTrains)
+                            continue;
+                        EffectsBase eb = action.getPowerAction().getEffectsBase();
+                        if(eb == null)
+                            return false;
+                        //Effect eff = pc.addEffectNoTimer(eb.getName(),eb,msg.getNumTrains(),false);
+                        //if(eff == null){
+                        //    Logger.error(pc.getFirstName() + " failed to apply self buff: " + msg.getPowerUsedID());
+                        //}
+
+                        UsePowerJob asj = new UsePowerJob(pc,msg,pb.getToken(),pb,pc.getLiveCounter(),pc.getLiveCounter());
+
+                        JobContainer jc = JobScheduler.getInstance().scheduleJob(asj, 1800000);
+                        Effect eff = new Effect(jc, eb, msg.getNumTrains());
+                       // pc.effects.put("CASTABLE", eff);
+                        pc.addEffect("CASTABLE",1800,asj,eb,msg.getNumTrains());
+                        pc.applyAllBonuses();
+
+                        ApplyEffectMsg pum = new ApplyEffectMsg();
+                        pum.setEffectID(eff.getEffectToken());
+                        pum.setSourceType(pc.getObjectType().ordinal());
+                        pum.setSourceID(pc.getObjectUUID());
+                        pum.setTargetType(pc.getObjectType().ordinal());
+                        pum.setTargetID(pc.getObjectUUID());
+                        pum.setNumTrains(eff.getTrains());
+                        pum.setUnknown05(1);
+                        pum.setUnknown02(2);
+                        pum.setUnknown06((byte) 1);
+                        pum.setEffectSourceType(GameObjectType.PlayerCharacter.ordinal());
+                        pum.setEffectSourceID(pc.getObjectUUID());
+                        pum.setDuration(1800);
+
+
+                        DispatchMessage.dispatchMsgToInterestArea(pc, pum, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
+                    }
+                    catch(Exception e){
+
+                    }
+                }
+                return true;
+        }
+        return false;
+    }
+
 }
 
 

src/engine/gameManager/SimulationManager.java

@@ -91,13 +91,13 @@ public enum SimulationManager {
                     "Fatal error in City Pulse: DISABLED. Error Message : "
                             + e.getMessage());
         }
-        try {
+        //try {
 
-            if ((_updatePulseTime != 0) && (System.currentTimeMillis() > _updatePulseTime))
-                pulseUpdate();
-        } catch (Exception e) {
-            Logger.error("Fatal error in Update Pulse: DISABLED");
-        }
+        //    if ((_updatePulseTime != 0) && (System.currentTimeMillis() > _updatePulseTime))
+        //        pulseUpdate();
+        //} catch (Exception e) {
+         //   Logger.error("Fatal error in Update Pulse: DISABLED");
+        //}
 
         try {
             if ((_runegatePulseTime != 0)
@@ -130,6 +130,25 @@ public enum SimulationManager {
 
         }
 
+        //try{
+        //    HellgateManager.pulseHellgates();
+        //}catch(Exception e){
+        //    Logger.error("Failed to pulse hellgates");
+       //     Logger.error(e.getMessage());
+        //}
+
+        try{
+            if(ZoneManager.hotZone != null && HotzoneManager.hotzoneMob != null && !HotzoneManager.hotzoneMob.isAlive()){
+                HotzoneManager.ClearHotzone();
+            }
+        }catch(Exception e){
+
+        }
+        try{
+            HotzoneManager.pulse();
+        }catch(Exception e){
+//
+        }
         SimulationManager.executionTime = Duration.between(startTime, Instant.now());
 
         if (executionTime.compareTo(executionMax) > 0)

src/engine/gameManager/SpecialLootHandler.java

@@ -1,107 +1,89 @@
 package engine.gameManager;
+
 import engine.InterestManagement.WorldGrid;
 import engine.math.Vector3fImmutable;
 import engine.objects.*;
 import engine.server.MBServerStatics;
-import org.pmw.tinylog.Logger;
 
 import java.util.*;
 import java.util.concurrent.ThreadLocalRandom;
-public class SpecialLootHandler {
 
-    public static final ArrayList<Integer> static_rune_ids_low = new ArrayList<>(Arrays.asList(
-            250001, 250002, 250003, 250004, 250005, 250006, 250010, 250011,
-            250012, 250013, 250014, 250015, 250019, 250020, 250021, 250022,
-            250023, 250024, 250028, 250029, 250030, 250031, 250032, 250033,
-            250037, 250038, 250039, 250040, 250041, 250042
-    ));
-    public static final ArrayList<Integer> static_rune_ids_mid = new ArrayList<>(Arrays.asList(
-            250006, 250007, 250008,
-            250015, 250016, 250017,
-            250024, 250025, 250026,
-            250033, 250034, 250035,
-            250042, 250043, 250044
-    ));
-    public static final ArrayList<Integer> static_rune_ids_high = new ArrayList<>(Arrays.asList(
-            250007, 250008,
-            250016, 250017,
-            250025, 250026,
-            250034, 250035,
-            250043, 250044
-    ));
+public class SpecialLootHandler {
     public static final List<Integer> DWARVEN_contracts = Arrays.asList(
             35250, 35251, 35252, 35253, 35254, 35255, 35256, 35257, 35258, 35259, 35260, 35261, 35262, 35263
     );
+
     public static final List<Integer> INVORRI_contracts = Arrays.asList(
             35050, 35051, 35052, 35053, 35054, 35055, 35056, 35057, 35058, 35059, 35060, 35061, 35062, 35063
     );
+
     public static final List<Integer> SHADE_contracts = Arrays.asList(
             35400, 35401, 35402, 35403, 35404, 35405, 35406, 35407, 35408, 35409, 35410, 35411, 35412, 35413,
             35414, 35415, 35416, 35417, 35418, 35419, 35420, 35421, 35422, 35423, 35424, 35425, 35426, 35427
     );
+
     public static final List<Integer> VAMPIRE_contracts = Arrays.asList(
             35545, 35546, 35547, 35548, 35549, 35550, 35551, 35552, 35553, 35554, 35555, 35556, 35557, 35558,
             35559, 35560, 35561, 35562, 35563, 35564, 35565, 35566, 35567, 35568, 35569, 35570
     );
+
     public static final List<Integer> IREKEI_contracts = Arrays.asList(
             35100, 35101, 35102, 35103, 35104, 35105, 35106, 35107, 35108, 35109, 35110, 35111, 35112, 35113,
             35114, 35115, 35116, 35117, 35118, 35119, 35120, 35121, 35122, 35123, 35124, 35125, 35126, 35127
     );
+
     public static final List<Integer> AMAZON_contracts = Arrays.asList(
             35200, 35201, 35202, 35203, 35204, 35205, 35206, 35207, 35208, 35209, 35210, 35211, 35212, 35213
     );
+
     public static final List<Integer> GWENDANNEN_contracts = Arrays.asList(
             35350, 35351, 35352, 35353, 35354, 35355, 35356, 35357, 35358, 35359, 35360, 35361, 35362, 35363,
             35364, 35365, 35366, 35367, 35368, 35369, 35370, 35371, 35372, 35373, 35374, 35375, 35376, 35377
     );
+
     public static final List<Integer> NEPHILIM_contracts = Arrays.asList(
             35500, 35501, 35502, 35503, 35504, 35505, 35506, 35507, 35508, 35509, 35510, 35511, 35512, 35513,
             35514, 35515, 35516, 35517, 35518, 35519, 35520, 35521, 35522, 35523, 35524, 35525
     );
+
     public static final List<Integer> ELVEN_contracts = Arrays.asList(
             35000, 35001, 35002, 35003, 35004, 35005, 35006, 35007, 35008, 35009, 35010, 35011, 35012, 35013,
             35014, 35015, 35016, 35017, 35018, 35019, 35020, 35021, 35022, 35023, 35024, 35025, 35026, 35027
     );
+
     public static final List<Integer> CENTAUR_contracts = Arrays.asList(
             35150, 35151, 35152, 35153, 35154, 35155, 35156, 35157, 35158, 35159, 35160, 35161, 35162, 35163,
             35164, 35165, 35166, 35167, 35168, 35169, 35170, 35171, 35172, 35173, 35174, 35175, 35176, 35177
     );
+
     public static final List<Integer> LIZARDMAN_contracts = Arrays.asList(
             35300, 35301, 35302, 35303, 35304, 35305, 35306, 35307, 35308, 35309, 35310, 35311, 35312, 35313
     );
+
     public static final List<Integer> GLASS_ITEMS = Arrays.asList(
             7000100, 7000110, 7000120, 7000130, 7000140, 7000150, 7000160, 7000170, 7000180, 7000190,
             7000200, 7000210, 7000220, 7000230, 7000240, 7000250, 7000270, 7000280
     );
+
     public static final List<Integer> STAT_RUNES = Arrays.asList(
             250001, 250002, 250003, 250004, 250005, 250006, 250007, 250008, 250010, 250011,
             250012, 250013, 250014, 250015, 250016, 250017, 250019, 250020, 250021, 250022,
             250023, 250024, 250025, 250026, 250028, 250029, 250030, 250031, 250032, 250033,
             250034, 250035, 250037, 250038, 250039, 250040, 250041, 250042, 250043, 250044
     );
+
     public static final List<Integer> racial_guard = Arrays.asList(
             841,951,952,1050,1052,1180,1182,1250,1252,1350,1352,1450,
             1452,1500,1502,1525,1527,1550,1552,1575,1577,1600,1602,1650,1652,1700,980100,
             980102
     );
 
-    public static final List<Integer> gold_resources = Arrays.asList(
-            1580000, 1580008, 1580009, 1580010, 1580011, 1580017
-    );
-    public static final List<Integer> lumber_resources = Arrays.asList(
-            1580004, 1580005, 1580006, 1580007, 1580018
-    );
-    public static final List<Integer> ore_resources = Arrays.asList(
-            1580000, 1580001, 1580002, 1580003, 1580019
-    );
-    public static final List<Integer> magic_resources = Arrays.asList(
-            1580012, 1580013, 1580014, 1580015, 1580016, 1580020
-    );
-
     public static void RollContract(Mob mob){
+
         Zone zone = getMacroZone(mob);
         if(zone == null)
             return;
+
         int contactId = 0;
         int roll = ThreadLocalRandom.current().nextInt(250);
         if(roll == 125){
@@ -109,23 +91,40 @@ public class SpecialLootHandler {
         }
         if(contactId == 0)
             return;
+
         ItemBase contractBase = ItemBase.getItemBase(contactId);
         if(contractBase == null)
             return;
+
         if(mob.getCharItemManager() == null)
             return;
+
         MobLoot contract = new MobLoot(mob,contractBase,false);
         mob.getCharItemManager().addItemToInventory(contract);
+
     }
+
     public static Zone getMacroZone(Mob mob){
+
         Zone parentZone = mob.parentZone;
         if(parentZone == null)
             return null;
+
         while(!parentZone.isMacroZone() && !parentZone.equals(ZoneManager.getSeaFloor())){
             parentZone = parentZone.getParent();
         }
+
         return parentZone;
+
+        //for(Zone zone : ZoneManager.macroZones){
+        //    HashSet<AbstractWorldObject> inZone = WorldGrid.getObjectsInRangePartial(zone.getLoc(),zone.getBounds().getHalfExtents().x * 2f, MBServerStatics.MASK_MOB);
+        //    if(inZone.contains(mob)){
+        //        return zone;
+         //   }
+        //}
+        //return null;
     }
+
     public static int getContractForZone(Zone zone){
         Random random = new Random();
         switch (zone.getObjectUUID())
@@ -217,20 +216,26 @@ public class SpecialLootHandler {
         }
         return 0;
     }
+
     public static void RollGlass(Mob mob){
+
         int roll = ThreadLocalRandom.current().nextInt(10000);
         if(roll != 5000)
             return;
+
         Random random = new Random();
         int glassId = GLASS_ITEMS.get(random.nextInt(GLASS_ITEMS.size()));
         ItemBase glassBase = ItemBase.getItemBase(glassId);
         if(glassBase == null)
             return;
+
         if(mob.getCharItemManager() == null)
             return;
+
         MobLoot glass = new MobLoot(mob,glassBase,false);
         mob.getCharItemManager().addItemToInventory(glass);
     }
+
     public static void RollRune(Mob mob){
         int runeID = 0;
         int roll = ThreadLocalRandom.current().nextInt(250);
@@ -240,157 +245,33 @@ public class SpecialLootHandler {
         }
         if(runeID == 0)
             return;
+
         ItemBase runeBase = ItemBase.getItemBase(runeID);
         if(runeBase == null)
             return;
+
         if(mob.getCharItemManager() == null)
             return;
+
         MobLoot rune = new MobLoot(mob,runeBase,false);
         mob.getCharItemManager().addItemToInventory(rune);
     }
+
     public static void RollRacialGuard(Mob mob){
         int roll = ThreadLocalRandom.current().nextInt(5000);
         if(roll != 2500)
             return;
+
         Random random = new Random();
         int guardId = racial_guard.get(random.nextInt(racial_guard.size()));
         ItemBase guardBase = ItemBase.getItemBase(guardId);
         if(guardBase == null)
             return;
+
         if(mob.getCharItemManager() == null)
             return;
+
         MobLoot guard = new MobLoot(mob,guardBase,false);
         mob.getCharItemManager().addItemToInventory(guard);
     }
-
-    public static void ResourceDrop(Mob mob){
-        Zone zone = getMacroZone(mob);
-        if(zone == null)
-            return;
-        int resourceId = 0;
-        int roll = ThreadLocalRandom.current().nextInt(125);
-        if(roll == 75){
-            resourceId = getResourceForZone(zone);
-        }
-        if(resourceId == 0)
-            return;
-        ItemBase resourceBase = ItemBase.getItemBase(resourceId);
-        if(resourceBase == null)
-            return;
-        if(mob.getCharItemManager() == null)
-            return;
-        MobLoot resource = new MobLoot(mob,resourceBase,false);
-    try {
-        int stackMax = (int) (getMaxResource(resourceId) * 0.02f);
-        if (stackMax > 100)
-            stackMax = 100;
-
-
-        int amount = ThreadLocalRandom.current().nextInt(stackMax);
-        resource.setNumOfItems(amount);
-
-        Logger.error("Set Stack Size For: " +resource.getName() + " To: " +  amount + ". Actual Amount = " + resource.getNumOfItems());
-
-    }catch(Exception e) {
-        Logger.error("Unable To Get Max Resource Stack Size For: " + resourceId);
-    }
-        mob.getCharItemManager().addItemToInventory(resource);
-    }
-
-    public static int getResourceForZone(Zone zone){
-        Random random = new Random();
-        switch (zone.getObjectUUID())
-        {
-            case 178:
-            case 717:
-            case 632:
-            case 952:
-            case 475:
-            case 371:
-            case 313:
-            case 234:
-                // Ecklund Wilds // ORE MINE
-                // Greensward Pyre // ORE MINE
-                // The Black Bog // ORE MINE
-                // Phaedra's Prize // ORE MINE
-                //plain of ashes ORE MINE
-                // Ashfell Plain // ORE MINE
-                // Kharsoom // ORE MINE
-                // Kralgaar Holm // ORE MINE
-                return ore_resources.get(random.nextInt(ore_resources.size()));
-            case 122:
-            case 824:
-            case 737:
-            case 569:
-            case 590:
-            case 437:
-            case 388:
-                // Sevaath Mere // LUMBER MINE
-                // Grimscairne // LUMBER MINE
-                // Fellgrim Forest // LUMBER MINE
-                // Aedroch Highlands // LUMBER MINE
-                // Leth'khalivar Desert // LUMBER MINE
-                // Western Battleground // LUMBER MINE
-                // Aurrochs Skrae // LUMBER MINE
-                return lumber_resources.get(random.nextInt(lumber_resources.size()));
-            case 197:
-            case 761:
-            case 616:
-            case 951:
-            case 532:
-            case 491:
-            case 353:
-            case 331:
-                // The Doomplain // GOLD MINE
-                // Thollok Marsh // GOLD MINE
-                // Holloch Forest // GOLD MINE
-                // Tainted Swamp // GOLD MINE
-                //Bone Marches // GOLD MINE
-                // Derros Plains // GOLD MINE
-                // The Blood Sands // GOLD MINE
-                // Ymur's Crown // GOLD MINE
-                return gold_resources.get(random.nextInt(gold_resources.size()));
-            case 418:
-            case 842:
-            case 785:
-            case 550:
-            case 508:
-                // Aeran Belendor // MAGIC MINE
-                // Aerath Hellendroth // MAGIC MINE
-                // Vale of Nar Addad // MAGIC MINE
-                // Pandemonium // MAGIC MINE
-                // Valkos Wilds // MAGIC MINE
-                return magic_resources.get(random.nextInt(magic_resources.size()));
-        }
-        return 0;
-    }
-
-    public static int getMaxResource(int key) {
-        switch (key) {
-            case 1580000: return 10000;
-            case 1580001: return 2000;
-            case 1580002: return 2000;
-            case 1580003: return 1000;
-            case 1580004: return 10000;
-            case 1580005: return 3000;
-            case 1580006: return 3000;
-            case 1580007: return 1000;
-            case 1580008: return 3000;
-            case 1580009: return 2000;
-            case 1580010: return 2000;
-            case 1580011: return 1000;
-            case 1580012: return 2000;
-            case 1580013: return 3000;
-            case 1580014: return 1000;
-            case 1580015: return 1000;
-            case 1580016: return 1000;
-            case 1580017: return 500;
-            case 1580018: return 500;
-            case 1580019: return 500;
-            case 1580020: return 500;
-            case 1580021: return 500;
-            default: return 0; // Default value if the key is not found
-        }
-    }
-
 }

src/engine/gameManager/ZergManager.java

@@ -1,5 +1,10 @@
 package engine.gameManager;
-import engine.objects.Guild;
+import engine.InterestManagement.WorldGrid;
+import engine.objects.*;
+import engine.server.MBServerStatics;
+
+import java.util.ArrayList;
+
 public class ZergManager {
 
     public static float getCurrentMultiplier(int count, int maxCount){
@@ -192,4 +197,78 @@ public class ZergManager {
             default: return 1.0f;
         }
     }
+
+    public static void MineTracker(Mine mine){
+        Building tower = BuildingManager.getBuildingFromCache(mine.getBuildingID());
+        if(tower == null)
+            return;
+
+        float affectedRange = MBServerStatics.CHARACTER_LOAD_RANGE * 3;
+        mine.zergTracker.compileCurrent(tower.loc, affectedRange);
+        mine.zergTracker.sortByNation();
+        mine.zergTracker.compileLeaveQue(tower.loc, affectedRange);
+        mine.zergTracker.processLeaveQue();
+        mine.zergTracker.applyMultiplier(mine.capSize);
+    }
+
+    public static void PrintDetailsToClient(PlayerCharacter pc){
+        String newline = "\r\n ";
+        String outstring = newline + "ZERG MANAGER DETAILS FOR: " + pc.getFirstName() + newline;
+        Mine attended = null;
+        for(Mine mine : Mine.getMines()){
+            Building tower = BuildingManager.getBuilding(mine.getBuildingID());
+            if(tower == null)
+                continue;
+
+            float rangeSquared = (MBServerStatics.CHARACTER_LOAD_RANGE * 3) * (MBServerStatics.CHARACTER_LOAD_RANGE * 3);
+
+            if(pc.loc.distanceSquared(tower.loc) < rangeSquared){
+                attended = mine;
+            }
+        }
+        if(attended != null){
+            outstring += "Mine Cap: " + attended.capSize + newline;
+            Building tower = BuildingManager.getBuilding(attended.getBuildingID());
+            if(tower == null)
+                return;
+
+            int count = 0;
+            ArrayList<PlayerCharacter> stillPresent = new ArrayList<>();
+            ArrayList<PlayerCharacter> gonePlayers = new ArrayList<>();
+            for(Integer countedID : attended.mineAttendees.keySet()){
+                PlayerCharacter counted = PlayerCharacter.getFromCache(countedID);
+                if(counted != null){
+                    if(counted.guild.getNation().equals(pc.guild.getNation())) {
+                        Long timeGone = System.currentTimeMillis() - attended.mineAttendees.get(countedID);
+                        if(timeGone > 5000){
+                            //outstring += counted.getFirstName() + " GONE FOR: " + timeGone/1000 + " SECONDS" + newline;
+                            gonePlayers.add(counted);
+                        }else{
+                            //outstring += counted.getFirstName() + " STILL PRESENT" + newline;
+                            stillPresent.add(counted);
+                        }
+                        count ++;
+                    }
+                }
+            }
+            outstring += newline + "TOTAL NATION MEMBERS COUNTED: " + count + newline;
+            outstring += newline + "PLAYERS PRESENT:" + newline;
+            for(PlayerCharacter present : stillPresent){
+                outstring += present.getFirstName() + newline;
+            }
+            outstring += newline + "PLAYERS GONE:" + newline;
+            for(PlayerCharacter gone : gonePlayers){
+                Long timeGone = System.currentTimeMillis() - attended.mineAttendees.get(gone.getObjectUUID());
+                if(timeGone > 5000) {
+                    outstring += gone.getFirstName() + " GONE FOR: " + timeGone / 1000 + " SECONDS" + newline;
+                }
+            }
+        }else{
+            outstring += "Mine: Not Within Mine Distance" + newline;
+        }
+
+        outstring += newline + "Zerg Multiplier: " + pc.ZergMultiplier + newline;
+
+        ChatManager.chatSystemInfo(pc, outstring);
+    }
 }

src/engine/jobs/AttackJob.java

@@ -9,11 +9,9 @@
 
 package engine.jobs;
 
-import engine.Enum;
 import engine.gameManager.CombatManager;
 import engine.job.AbstractJob;
 import engine.objects.AbstractCharacter;
-import engine.objects.PlayerCharacter;
 
 public class AttackJob extends AbstractJob {
 
@@ -30,17 +28,6 @@ public class AttackJob extends AbstractJob {
 
     @Override
     public void doJob() {
-
-        if(this.source.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)){
-            PlayerCharacter pc = (PlayerCharacter)source;
-            if(pc.combatTarget != null && pc.combatTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)){
-                PlayerCharacter target = (PlayerCharacter)pc.combatTarget;
-                if(!pc.canSee(target)) {
-                    this._cancelJob();
-                    return;
-                }
-            }
-        }
         CombatManager.doCombat(this.source, slot);
     }
 

src/engine/jobs/PersistentAoeJob.java

@@ -45,12 +45,11 @@ public class PersistentAoeJob extends AbstractEffectJob {
         if (this.aej == null || this.source == null || this.action == null || this.power == null || this.source == null || this.eb == null)
             return;
 
-        if(this.source.isAlive() && this.source.getObjectType().equals(GameObjectType.PlayerCharacter)){
-            PlayerCharacter pc = (PlayerCharacter)this.source;
-            if(pc.getPromotionClassID() == 2511){
-                this.cancelJob();
-                return;
-            }
+        try {
+            if (!this.target.isAlive())
+                PowersManager.finishEffectTime(this.source, this.target, this.action, this.trains);
+        }catch(Exception e){
+            PowersManager.finishEffectTime(this.source, this.target, this.action, this.trains);
         }
 
         if (!this.source.isAlive())

src/engine/mobileAI/Behaviours/StandardMob.java

@@ -0,0 +1,266 @@
+package engine.mobileAI.Behaviours;
+
+import engine.Enum;
+import engine.InterestManagement.InterestManager;
+import engine.InterestManagement.WorldGrid;
+import engine.math.Vector3fImmutable;
+import engine.mobileAI.utilities.CombatUtilities;
+import engine.mobileAI.utilities.MovementUtilities;
+import engine.objects.*;
+import engine.server.MBServerStatics;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+
+public class StandardMob {
+
+    public static void run(Mob mob){
+
+        HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(mob.loc, MBServerStatics.CHARACTER_LOAD_RANGE, MBServerStatics.MASK_PLAYER);
+
+        if(inRange.isEmpty())
+            return;
+
+        if(!mob.isAlive()){
+            CheckForRespawn(mob);
+            return;
+        }
+
+        if (mob.isMoving()) {
+            mob.setLoc(mob.getMovementLoc());
+            mob.updateLocation();
+        }
+
+        if(mob.combatTarget == null) {
+            if (!inRange.isEmpty()) {
+                CheckForAggro(mob);
+            }
+        }else{
+            CheckToDropCombatTarget(mob);
+            if(mob.combatTarget == null){
+                CheckForAggro(mob);
+            }
+        }
+
+        if(MovementUtilities.canMove(mob))
+            CheckForMovement(mob);
+
+        if(mob.combatTarget != null && !mob.isMoving())
+            CheckForAttack(mob);
+    }
+
+    public static void CheckToDropCombatTarget(Mob mob){
+
+        if(!mob.combatTarget.isAlive()){
+            mob.setCombatTarget(null);
+            return;
+        }
+
+        if(mob.combatTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)){
+            PlayerCharacter pcTarget = (PlayerCharacter) mob.combatTarget;
+            if (!mob.canSee(pcTarget)) {
+                mob.setCombatTarget(null);
+                return;
+            }
+        }
+
+        if(mob.bindLoc.distanceSquared(mob.combatTarget.loc) > 90 * 90){
+            mob.setCombatTarget(null);
+        }
+
+
+    }
+
+    public static void CheckForRespawn(Mob mob){
+        if (mob.deathTime == 0) {
+            mob.setDeathTime(System.currentTimeMillis());
+            return;
+        }
+
+        if (!mob.despawned) {
+            if (mob.getCharItemManager().getInventoryCount() > 0) {
+                if (System.currentTimeMillis() > mob.deathTime + MBServerStatics.DESPAWN_TIMER_WITH_LOOT) {
+                    mob.despawn();
+                    mob.deathTime = System.currentTimeMillis();
+                    return;
+                }
+                //No items in inventory.
+            } else if (mob.isHasLoot()) {
+                if (System.currentTimeMillis() > mob.deathTime + MBServerStatics.DESPAWN_TIMER_ONCE_LOOTED) {
+                    mob.despawn();
+                    mob.deathTime = System.currentTimeMillis();
+                    return;
+                }
+                //Mob never had Loot.
+            } else {
+                if (System.currentTimeMillis() > mob.deathTime + MBServerStatics.DESPAWN_TIMER_ONCE_LOOTED) {
+                    mob.despawn();
+                    mob.deathTime = System.currentTimeMillis();
+                    return;
+                }
+            }
+            return;
+        }
+
+        if(Mob.discDroppers.contains(mob))
+            return;
+        float baseRespawnTimer = mob.spawnTime;
+        float reduction = (100-mob.level) * 0.01f;
+        float reducedRespawnTime = baseRespawnTimer * (1.0f - reduction);
+        float respawnTimer = reducedRespawnTime * 1000f;
+        if (System.currentTimeMillis() > (mob.deathTime + respawnTimer)) {
+            Zone.respawnQue.add(mob);
+        }
+    }
+
+    public static void CheckForAggro(Mob mob){
+
+        if(mob == null || !mob.isAlive() || mob.playerAgroMap.isEmpty()){
+            return;
+        }
+
+        if(!mob.BehaviourType.isAgressive)
+            return;
+
+        if(mob.BehaviourType.equals(Enum.MobBehaviourType.HamletGuard)){
+            return;
+        }
+
+        if(mob.hate_values == null)
+            mob.hate_values = new HashMap<>();
+
+        if(mob.combatTarget != null)
+            return;
+
+        HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(mob.loc, 60f, MBServerStatics.MASK_PLAYER);
+
+        if(inRange.isEmpty()){
+            mob.setCombatTarget(null);
+            return;
+        }
+
+        //clear out any players who are not in hated range anymore
+        ArrayList<PlayerCharacter> toRemove = new ArrayList<>();
+        for(PlayerCharacter pc : mob.hate_values.keySet()){
+            if(!inRange.contains(pc))
+                toRemove.add(pc);
+        }
+        for(PlayerCharacter pc : toRemove){
+            mob.hate_values.remove(pc);
+        }
+
+        //find most hated target
+        PlayerCharacter mostHated = null;
+        for(AbstractWorldObject awo : inRange){
+            PlayerCharacter loadedPlayer = (PlayerCharacter)awo;
+            if (loadedPlayer == null)
+                continue;
+
+            //Player is Dead, Mob no longer needs to attempt to aggro. Remove them from aggro map.
+            if (!loadedPlayer.isAlive())
+                continue;
+
+            //Can't see target, skip aggro.
+            if (!mob.canSee(loadedPlayer))
+                continue;
+
+            // No aggro for this race type
+            if (mob.notEnemy != null && mob.notEnemy.size() > 0 && mob.notEnemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()))
+                continue;
+
+            //mob has enemies and this player race is not it
+            if (mob.enemy != null && mob.enemy.size() > 0 && !mob.enemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()))
+                continue;
+
+            if(mostHated == null)
+                mostHated = loadedPlayer;
+
+            if(mob.hate_values.containsKey(loadedPlayer))
+                if(mob.hate_values.get(loadedPlayer) > mob.hate_values.get(mostHated))
+                    mostHated = loadedPlayer;
+        }
+
+        if(mostHated != null)
+            mob.setCombatTarget(mostHated);
+    }
+
+    public static void CheckForMovement(Mob mob){
+
+        if(!mob.BehaviourType.canRoam)
+            return;
+
+        if(mob.combatTarget != null){
+            //chase player
+            if(!CombatUtilities.inRange2D(mob,mob.combatTarget,mob.getRange())) {
+                if(mob.combatTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {
+                    PlayerCharacter target = (PlayerCharacter)mob.combatTarget;
+                    if(target.isMoving()){
+                        MovementUtilities.aiMove(mob, mob.combatTarget.loc, false);
+                        return;
+                    }else{
+                        Vector3fImmutable smoothLoc = Vector3fImmutable.getRandomPointOnCircle(mob.combatTarget.loc,mob.getRange() -1);
+                        MovementUtilities.aiMove(mob, smoothLoc, false);
+                        return;
+                    }
+                }
+                MovementUtilities.aiMove(mob, mob.combatTarget.loc, false);
+            }
+
+        }else{
+            //patrol
+            if (mob.isMoving()) {
+                mob.stopPatrolTime = System.currentTimeMillis();
+                return;
+            }
+            if(mob.stopPatrolTime + 5000L < System.currentTimeMillis()) {
+                Vector3fImmutable patrolPoint = Vector3fImmutable.getRandomPointOnCircle(mob.bindLoc, 40f);
+                MovementUtilities.aiMove(mob, patrolPoint, true);
+            }
+        }
+    }
+
+    public static void CheckForAttack(Mob mob){
+
+        if(mob.isMoving())
+            return;
+
+        if(mob.getLastAttackTime() > System.currentTimeMillis())
+            return;
+
+        if (mob.BehaviourType.callsForHelp)
+            MobCallForHelp(mob);
+
+        ItemBase mainHand = mob.getWeaponItemBase(true);
+        ItemBase offHand = mob.getWeaponItemBase(false);
+
+        if(!CombatUtilities.inRangeToAttack(mob,mob.combatTarget))
+            return;
+
+        InterestManager.setObjectDirty(mob);
+
+        if (mainHand == null && offHand == null) {
+            CombatUtilities.combatCycle(mob, mob.combatTarget, true, null);
+            int delay = 3000;
+            mob.setLastAttackTime(System.currentTimeMillis() + delay);
+        } else if (mob.getWeaponItemBase(true) != null) {
+            int delay = 3000;
+            CombatUtilities.combatCycle(mob, mob.combatTarget, true, mob.getWeaponItemBase(true));
+            mob.setLastAttackTime(System.currentTimeMillis() + delay);
+        } else if (mob.getWeaponItemBase(false) != null) {
+            int attackDelay = 3000;
+            CombatUtilities.combatCycle(mob, mob.combatTarget, false, mob.getWeaponItemBase(false));
+            mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
+        }
+    }
+
+    public static void MobCallForHelp(Mob mob){
+        HashSet<AbstractWorldObject> mobs = WorldGrid.getObjectsInRangePartial(mob.loc,60f, MBServerStatics.MASK_MOB);
+        for(AbstractWorldObject awo : mobs){
+            Mob responder = (Mob)awo;
+            if(responder.combatTarget == null)
+                if(MovementUtilities.canMove(responder))
+                    MovementUtilities.aiMove(responder,mob.loc,false);
+        }
+    }
+}

src/engine/mobileAI/MobAI.java

@@ -14,7 +14,7 @@ import engine.InterestManagement.WorldGrid;
 import engine.gameManager.*;
 import engine.math.Vector3f;
 import engine.math.Vector3fImmutable;
-import engine.mobileAI.MobHandlers.MobHandler;
+import engine.mobileAI.Behaviours.StandardMob;
 import engine.mobileAI.Threads.MobAIThread;
 import engine.mobileAI.utilities.CombatUtilities;
 import engine.mobileAI.utilities.MovementUtilities;
@@ -52,18 +52,18 @@ public class MobAI {
             }
 
             //mob casting disabled
-            //if (target.getObjectType() == Enum.GameObjectType.PlayerCharacter && canCast(mob)) {
+            if (target.getObjectType() == Enum.GameObjectType.PlayerCharacter && canCast(mob)) {
 
-                //if (mob.isPlayerGuard() == false && MobCast(mob)) {
-                //    mob.updateLocation();
-                //    return;
-                //}
+                if (mob.isPlayerGuard() == false && MobCast(mob)) {
+                    mob.updateLocation();
+                    return;
+                }
 
-                //if (mob.isPlayerGuard() == true && GuardCast(mob)) {
-                //    mob.updateLocation();
-                //    return;
-                //}
-            //}
+                if (mob.isPlayerGuard() == true && GuardCast(mob)) {
+                    mob.updateLocation();
+                    return;
+                }
+            }
 
             if (!CombatUtilities.inRangeToAttack(mob, target))
                 return;
@@ -109,11 +109,11 @@ public class MobAI {
                 return;
             }
 
-            if(target.getPet() != null && target.getPet().isAlive() && !target.getPet().isSiege()){
-                mob.setCombatTarget(target.getPet());
-                AttackTarget(mob,mob.combatTarget);
-                return;
-            }
+            //if(target.getPet() != null && target.getPet().isAlive() && !target.getPet().isSiege()){
+                //mob.setCombatTarget(target.getPet());
+                //AttackTarget(mob,mob.combatTarget);
+                //return;
+            //}
 
             if (mob.BehaviourType.callsForHelp)
                 MobCallForHelp(mob);
@@ -246,6 +246,8 @@ public class MobAI {
 
             //no weapons, default mob attack speed 3 seconds.
 
+            //MobVsMobRetaliate(target,mob);
+
             ItemBase mainHand = mob.getWeaponItemBase(true);
             ItemBase offHand = mob.getWeaponItemBase(false);
 
@@ -339,12 +341,14 @@ public class MobAI {
             if (mob == null)
                 return false;
 
-            if (mob.nextCastTime == 0)
-                mob.nextCastTime = System.currentTimeMillis() - 1000L;
+            if (mob.mobPowers == null || mob.mobPowers.isEmpty())
+                return false;
 
             if(mob.nextCastTime > System.currentTimeMillis())
                 return false;
 
+            mob.nextCastTime = System.currentTimeMillis() + 30000L;
+
             if(mob.isPlayerGuard){
 
                 int contractID = 0;
@@ -358,15 +362,12 @@ public class MobAI {
                     return false;
             }
 
-            if (mob.mobPowers == null || mob.mobPowers.isEmpty())
-                return false;
-
             if (!mob.canSee((PlayerCharacter) mob.getCombatTarget())) {
                 mob.setCombatTarget(null);
                 return false;
             }
 
-            return mob.nextCastTime <= System.currentTimeMillis();
+            return true;
 
         } catch (Exception e) {
             ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: canCast" + " " + e.getMessage());
@@ -447,11 +448,11 @@ public class MobAI {
                 }
 
                 msg.setUnknown04(2);
-
-                PowersManager.finishUseMobPower(msg, mob, 0, 0);
-                long delay = 20000L;
-                mob.nextCastTime = System.currentTimeMillis() + delay;
-
+                try {
+                    PowersManager.finishUseMobPower(msg, mob, 0, 0);
+                }catch(Exception e) {
+                    return false;
+                }
                 return true;
             }
         } catch (Exception e) {
@@ -621,33 +622,35 @@ public class MobAI {
 
         try {
 
-            //if(mob.isSiege() || mob.isPet() || mob.isPlayerGuard()){
-            //    SuperSimpleMobAI.run(mob);
-            //    return;
-            //}
-            //boolean override;
+            if (HellgateManager.hellgate_mobs != null && HellgateManager.hellgate_mobs.contains(mob)) {
+                HellgateManager.SpecialMobAIHandler(mob);
+                return;
+            }
+
+            if (HellgateManager.hellgate_mini_bosses != null && HellgateManager.hellgate_mini_bosses.contains(mob)) {
+                HellgateManager.SpecialMobAIHandler(mob);
+                return;
+            }
+            if(HellgateManager.hellgate_boss != null && mob.equals(HellgateManager.hellgate_boss)){
+                HellgateManager.SpecialMobAIHandler(mob);
+                return;
+            }
+
+            //boolean override = true;
             //switch (mob.BehaviourType) {
-            //    case GuardCaptain:
+           //     case GuardCaptain:
             //    case GuardMinion:
             //    case GuardWallArcher:
-            //    case Pet1:
-            //    case HamletGuard:
-            //        override = false;
+           //     case Pet1:
+           //     case HamletGuard:
+           //         override = false;
             //        break;
-            //    default:
-             //       override = true;
-            //        break;
-            //}
-
-            //if(mob.isSiege())
-            //    override = false;
-
-            //if(mob.isPet())
-            //    override = false;
-
+           // }
             //if(override){
-            //    SuperSimpleMobAI.run(mob);
-            //    return;
+            //    if(!mob.isSiege()) {
+            //        StandardMob.run(mob);
+            //        return;
+            //    }
             //}
 
             //always check the respawn que, respawn 1 mob max per second to not flood the client
@@ -739,6 +742,7 @@ public class MobAI {
 
                 }
             }
+            //mob.refresh();
 
             switch (mob.BehaviourType) {
                 case GuardCaptain:
@@ -757,8 +761,6 @@ public class MobAI {
                     HamletGuardLogic(mob);
                     break;
                 default:
-                    //SuperSimpleMobAI.run(mob);
-                    //MobHandler.run(mob);
                     DefaultLogic(mob);
                     break;
             }
@@ -942,6 +944,8 @@ public class MobAI {
                     }
                 return;
                 }
+            for(Effect eff : aiAgent.effects.values())
+                eff.endEffect();
 
             if(Mob.discDroppers.contains(aiAgent))
                 return;
@@ -1047,7 +1051,7 @@ public class MobAI {
         }
     }
 
-    private static void chaseTarget(Mob mob) {
+    public static void chaseTarget(Mob mob) {
 
         try {
 
@@ -1459,7 +1463,7 @@ public class MobAI {
         if(mob.hate_values == null)
             mob.hate_values = new HashMap<>();
 
-        if(mob.combatTarget != null)
+        if(mob.combatTarget != null && mob.combatTarget.isAlive() && mob.combatTarget.loc.distanceSquared(mob.loc) < 90f)
             return;
 
         HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(mob.loc,60.0f,MBServerStatics.MASK_PLAYER);
@@ -1510,4 +1514,11 @@ public class MobAI {
         if(mostHated != null)
             mob.setCombatTarget(mostHated);
     }
+
+    public static void MobVsMobRetaliate(Mob retaliator, Mob attacker){
+        if(CombatUtilities.inRangeToAttack(retaliator,attacker)){
+            CombatUtilities.combatCycle(retaliator,attacker,true,null);
+        }
+
+    }
 }

src/engine/mobileAI/MobHandlers/MobHandler.java

@@ -1,282 +0,0 @@
-package engine.mobileAI.MobHandlers;
-
-import engine.InterestManagement.WorldGrid;
-import engine.gameManager.PowersManager;
-import engine.mobileAI.Threads.MobAIThread;
-import engine.mobileAI.utilities.CombatUtilities;
-import engine.mobileAI.utilities.MovementUtilities;
-import engine.objects.*;
-import engine.powers.PowersBase;
-import engine.server.MBServerStatics;
-
-import java.util.HashSet;
-import java.util.Map;
-import java.util.concurrent.ThreadLocalRandom;
-
-public class MobHandler {
-    public static void run(Mob mob){
-
-        if (!mob.isAlive()) {
-            CheckForRespawn(mob);
-            return;
-        }
-
-        if(mob.playerAgroMap.isEmpty())
-            return;
-
-        CheckToSendMobHome(mob);
-
-        if(mob.combatTarget == null || !mob.combatTarget.isAlive()){
-            CheckForAggro(mob);
-        }
-        if(mob.combatTarget != null)
-            CheckToDropAggro(mob);
-
-        if(MovementUtilities.canMove(mob))
-            CheckMobMovement(mob);
-
-        if(mob.combatTarget != null && CombatUtilities.inRangeToAttack(mob,mob.combatTarget))
-            CheckToAttack(mob);
-    }
-
-    public static void CheckToDropAggro(Mob mob){
-        if(mob.loc.distanceSquared(mob.combatTarget.loc) > (128f * 128f))
-            mob.setCombatTarget(null);
-    }
-
-    public static void CheckForRespawn(Mob mob){
-        try {
-
-            if (mob.deathTime == 0) {
-                mob.setDeathTime(System.currentTimeMillis());
-                return;
-            }
-
-            //handles checking for respawn of dead mobs even when no players have mob loaded
-            //Despawn Timer with Loot currently in inventory.
-
-            if (!mob.despawned) {
-
-                if (mob.getCharItemManager().getInventoryCount() > 0) {
-                    if (System.currentTimeMillis() > mob.deathTime + MBServerStatics.DESPAWN_TIMER_WITH_LOOT) {
-                        mob.despawn();
-                        mob.deathTime = System.currentTimeMillis();
-                        return;
-                    }
-                    //No items in inventory.
-                } else if (mob.isHasLoot()) {
-                    if (System.currentTimeMillis() > mob.deathTime + MBServerStatics.DESPAWN_TIMER_ONCE_LOOTED) {
-                        mob.despawn();
-                        mob.deathTime = System.currentTimeMillis();
-                        return;
-                    }
-                    //Mob never had Loot.
-                } else {
-                    if (System.currentTimeMillis() > mob.deathTime + MBServerStatics.DESPAWN_TIMER) {
-                        mob.despawn();
-                        mob.deathTime = System.currentTimeMillis();
-                        return;
-                    }
-                }
-                return;
-            }
-
-            if(Mob.discDroppers.contains(mob))
-                return;
-
-            if (mob.despawned && System.currentTimeMillis() > (mob.deathTime + (mob.spawnTime * 1000L))) {
-                if (!Zone.respawnQue.contains(mob)) {
-                    Zone.respawnQue.add(mob);
-                }
-            }
-        } catch (Exception e) {
-            //(aiAgent.getObjectUUID() + " " + aiAgent.getName() + " Failed At: CheckForRespawn" + " " + e.getMessage());
-        }
-    }
-
-    public static void CheckForAggro(Mob mob){
-        switch(mob.BehaviourType){
-            case SimpleStandingGuard:
-            case Simple:
-            case None:
-                return;
-        }
-        PlayerCharacter tar = null;
-        for(int id : mob.playerAgroMap.keySet()){
-            PlayerCharacter target = PlayerCharacter.getFromCache(id);
-
-            if(target.loc.distanceSquared(mob.loc) > mob.getAggroRange() * mob.getAggroRange())
-                continue;
-
-            if(tar == null || mob.loc.distanceSquared(tar.loc) < mob.loc.distanceSquared(target.loc))
-                if(MobCanAggro(mob,target))
-                    tar = target;
-        }
-        if(tar != null)
-            mob.setCombatTarget(tar);
-    }
-
-    public static Boolean MobCanAggro(Mob mob, PlayerCharacter loadedPlayer){
-        if (loadedPlayer == null)
-            return false;
-
-        //Player is Dead, Mob no longer needs to attempt to aggro. Remove them from aggro map.
-        if (!loadedPlayer.isAlive())
-            return false;
-
-        //Can't see target, skip aggro.
-        if (!mob.canSee(loadedPlayer))
-            return false;
-
-        // No aggro for this race type
-        if (mob.notEnemy != null && mob.notEnemy.size() > 0 && mob.notEnemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()))
-            return false;
-
-        //mob has enemies and this player race is not it
-        if (mob.enemy != null && mob.enemy.size() > 0 && !mob.enemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()))
-            return false;
-
-        return true;
-    }
-
-    public static void CheckMobMovement(Mob mob){
-        if(!mob.isAlive())
-            return;
-
-        mob.updateLocation();
-
-        if(mob.combatTarget == null){
-            //patrol
-            Patrol(mob);
-        }else{
-            //combat movement
-            if(CombatUtilities.inRangeToAttack(mob,mob.combatTarget)) {
-                return;
-            }else {
-                MovementUtilities.moveToLocation(mob, mob.combatTarget.loc, mob.getRange());
-            }
-        }
-    }
-
-    public static void CheckToAttack(Mob mob){
-        try {
-
-            if(mob.getLastAttackTime() > System.currentTimeMillis())
-                return;
-
-            PlayerCharacter target = (PlayerCharacter) mob.combatTarget;
-
-            if (!mob.canSee(target)) {
-                mob.setCombatTarget(null);
-                return;
-            }
-
-            //if (mob.BehaviourType.callsForHelp)
-            MobCallForHelp(mob);
-
-            if (mob.isMoving() && mob.getRange() > 20)
-                return;
-
-            if(target.combatStats == null)
-                target.combatStats = new PlayerCombatStats(target);
-
-            ItemBase mainHand = mob.getWeaponItemBase(true);
-            ItemBase offHand = mob.getWeaponItemBase(false);
-
-            if (mainHand == null && offHand == null) {
-                CombatUtilities.combatCycle(mob, target, true, null);
-                int delay = 3000;
-                mob.setLastAttackTime(System.currentTimeMillis() + delay);
-            } else if (mob.getWeaponItemBase(true) != null) {
-                int delay = 3000;
-                CombatUtilities.combatCycle(mob, target, true, mob.getWeaponItemBase(true));
-                mob.setLastAttackTime(System.currentTimeMillis() + delay);
-            } else if (mob.getWeaponItemBase(false) != null) {
-                int attackDelay = 3000;
-                CombatUtilities.combatCycle(mob, target, false, mob.getWeaponItemBase(false));
-                mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
-            }
-
-            if (target.getPet() != null)
-                if (target.getPet().getCombatTarget() == null && target.getPet().assist)
-                    target.getPet().setCombatTarget(mob);
-
-        } catch (Exception e) {
-            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackPlayer" + " " + e.getMessage());
-        }
-    }
-
-    public static void MobCallForHelp(Mob mob) {
-
-        try {
-            HashSet<AbstractWorldObject> helpers = WorldGrid.getObjectsInRangePartial(mob.loc,mob.getAggroRange() * 2, MBServerStatics.MASK_MOB);
-            for (AbstractWorldObject awo : helpers) {
-                if(awo.equals(mob))
-                    continue;
-                Mob helper = (Mob) awo;
-
-                if(helper.equals(mob))
-                    continue;
-
-                if(helper.combatTarget != null)
-                    continue;
-
-                helper.setCombatTarget(mob.getCombatTarget());
-            }
-
-        } catch (Exception e) {
-            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCallForHelp" + " " + e.getMessage());
-        }
-    }
-
-    private static void Patrol(Mob mob) {
-
-        try {
-
-            if(mob.isMoving())
-                return;
-            //make sure mob is out of combat stance
-
-            int patrolDelay = ThreadLocalRandom.current().nextInt((int) (MobAIThread.AI_PATROL_DIVISOR * 0.5f), MobAIThread.AI_PATROL_DIVISOR) + MobAIThread.AI_PATROL_DIVISOR;
-
-            //early exit while waiting to patrol again
-
-            if (mob.stopPatrolTime + (patrolDelay * 1000) > System.currentTimeMillis())
-                return;
-
-            if (mob.lastPatrolPointIndex > mob.patrolPoints.size() - 1)
-                mob.lastPatrolPointIndex = 0;
-
-            mob.destination = mob.patrolPoints.get(mob.lastPatrolPointIndex);
-            mob.lastPatrolPointIndex += 1;
-
-            MovementUtilities.aiMove(mob, mob.destination, true);
-
-        } catch (Exception e) {
-            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
-        }
-    }
-
-    private static void CheckToSendMobHome(Mob mob) {
-
-        if(mob.isNecroPet())
-            return;
-
-        try {
-
-            if (!MovementUtilities.inRangeOfBindLocation(mob)) {
-
-                PowersBase recall = PowersManager.getPowerByToken(-1994153779);
-                PowersManager.useMobPower(mob, mob, recall, 40);
-
-                for (Map.Entry playerEntry : mob.playerAgroMap.entrySet())
-                    PlayerCharacter.getFromCache((int) playerEntry.getKey()).setHateValue(0);
-
-                mob.setCombatTarget(null);
-            }
-        } catch (Exception e) {
-            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckToSendMobHome" + " " + e.getMessage());
-        }
-    }
-
-}

src/engine/mobileAI/MobHandlers/PetHandler.java

@@ -1,66 +0,0 @@
-package engine.mobileAI.MobHandlers;
-
-import engine.Enum;
-import engine.gameManager.MovementManager;
-import engine.gameManager.ZoneManager;
-import engine.mobileAI.utilities.CombatUtilities;
-import engine.mobileAI.utilities.MovementUtilities;
-import engine.objects.City;
-import engine.objects.Mob;
-import engine.objects.PlayerCharacter;
-
-public class PetHandler {
-
-    public static void run(Mob pet){
-        PlayerCharacter owner = pet.getOwner();
-
-        if(owner == null)
-            return;
-
-        if(!pet.isAlive()){
-            return;
-        }
-
-        if(!owner.isAlive()) {
-            owner.dismissPet();
-            return;
-        }
-
-        pet.updateLocation();
-
-        if(pet.combatTarget == null){
-            //follow owner
-            if(!CombatUtilities.inRangeToAttack(pet,owner)) {
-                MovementUtilities.moveToLocation(pet, owner.loc, pet.getRange());
-            }
-        }else{
-
-            if (pet.combatTarget.equals(pet)) {
-                pet.setCombatTarget(null);
-                return;
-            }
-
-            //chase target
-            if(!CombatUtilities.inRangeToAttack(pet,pet.combatTarget)) {
-                MovementUtilities.moveToLocation(pet, pet.combatTarget.loc, pet.getRange());
-            }else{
-                if(pet.getLastAttackTime() > System.currentTimeMillis())
-                    return;
-
-                pet.setLastAttackTime(System.currentTimeMillis() + 3000);
-
-                //attack target
-                if(pet.combatTarget.getObjectType().equals(Enum.GameObjectType.Building)){
-                    //attacking building
-                    City playercity = ZoneManager.getCityAtLocation(pet.getLoc());
-                    if (playercity != null)
-                        for (Mob guard : playercity.getParent().zoneMobSet)
-                            if (guard.combatTarget == null && guard.getGuild() != null && pet.getGuild() != null && !guard.getGuild().equals(pet.getGuild()))
-                                MovementUtilities.aiMove(guard,pet.loc,false);
-                }
-
-                CombatUtilities.combatCycle(pet,pet.combatTarget,true,null);
-            }
-        }
-    }
-}

src/engine/mobileAI/MobHandlers/PlayerGuardHandler.java

@@ -1,449 +0,0 @@
-package engine.mobileAI.MobHandlers;
-
-import engine.gameManager.PowersManager;
-import engine.math.Vector3fImmutable;
-import engine.mobileAI.Threads.MobAIThread;
-import engine.mobileAI.utilities.CombatUtilities;
-import engine.mobileAI.utilities.MovementUtilities;
-import engine.net.client.msg.PerformActionMsg;
-import engine.objects.*;
-import engine.powers.ActionsBase;
-import engine.powers.PowersBase;
-import engine.server.MBServerStatics;
-
-import java.util.ArrayList;
-import java.util.Map;
-import java.util.concurrent.ThreadLocalRandom;
-
-public class PlayerGuardHandler {
-    public static void run(Mob guard) {
-        if(!guard.isAlive() || guard.despawned){
-            CheckRespawn(guard);
-            return;
-        }
-
-        CheckForRecall(guard);
-
-        if (guard.contract != null && guard.contract.getName().contains("Wall Archer")) {
-            runWallArcherGuard(guard);
-            return;
-        }else if (guard.contract != null && guard.contract.getName().contains("Magister")) {
-            runMagisterGuard(guard);
-            return;
-        }else if (guard.contract != null && guard.contract.getName().contains("Archer")) {
-            runArcherGuard(guard);
-            return;
-        }
-        runMeleGuard(guard);
-    }
-
-    public static void runMeleGuard(Mob guard){
-        try {
-            if (guard.combatTarget != null)
-                checkToDropGuardAggro(guard);
-
-            if (guard.combatTarget == null)
-                CheckForPlayerGuardAggro(guard);
-
-            if(MovementUtilities.canMove(guard))
-                CheckGuardMovement(guard);
-
-            if (guard.combatTarget != null && CombatUtilities.inRangeToAttack(guard, guard.combatTarget))
-                CheckToAttack(guard);
-
-        } catch (Exception ignored) {
-
-        }
-    }
-
-    public static void runArcherGuard(Mob guard){
-        try {
-            if (guard.combatTarget != null)
-                checkToDropGuardAggro(guard);
-
-            if (guard.combatTarget == null)
-                CheckForPlayerGuardAggro(guard);
-
-            if(MovementUtilities.canMove(guard))
-                CheckGuardMovement(guard);
-
-            if (guard.combatTarget != null && CombatUtilities.inRangeToAttack(guard, guard.combatTarget))
-                CheckToAttack(guard);
-
-        } catch (Exception ignored) {
-
-        }
-    }
-
-    public static void runMagisterGuard(Mob guard){
-        try {
-            if (guard.combatTarget != null)
-                checkToDropGuardAggro(guard);
-
-            if (guard.combatTarget == null)
-                CheckForPlayerGuardAggro(guard);
-
-            if(MovementUtilities.canMove(guard))
-                CheckMagisterMovement(guard);
-
-            if (guard.combatTarget != null && inRangeToCast(guard, guard.combatTarget))
-                GuardCast(guard);
-
-        } catch (Exception ignored) {
-
-        }
-    }
-
-    public static void runWallArcherGuard(Mob guard){
-        try {
-            if (guard.combatTarget != null)
-                checkToDropGuardAggro(guard);
-
-            if (guard.combatTarget == null)
-                CheckForPlayerGuardAggro(guard);
-
-            if (guard.combatTarget != null && CombatUtilities.inRangeToAttack(guard, guard.combatTarget))
-                CheckToAttack(guard);
-
-        } catch (Exception ignored) {
-
-        }
-    }
-
-    public static void checkToDropGuardAggro(Mob guard){
-        if(guard.combatTarget.loc.distanceSquared(guard.loc) > (128f * 128f))
-            guard.setCombatTarget(null);
-    }
-
-    public static void CheckForPlayerGuardAggro(Mob guard){
-        PlayerCharacter tar = null;
-        for(int id : guard.playerAgroMap.keySet()){
-            PlayerCharacter target = PlayerCharacter.getFromCache(id);
-
-            float aggroRange = guard.getAggroRange();
-
-            if(guard.getEquip().get(2) != null && guard.getEquip().get(2).getItemBase().getRange() > 15)
-                aggroRange = guard.getEquip().get(2).getItemBase().getRange() * 1.5f;
-
-            float squared = aggroRange * aggroRange;
-
-            if(target.loc.distanceSquared(guard.loc) > squared)
-                continue;
-
-            if(tar == null || guard.loc.distanceSquared(tar.loc) < guard.loc.distanceSquared(target.loc))
-                if(GuardCanAggro(guard,target))
-                    tar = target;
-        }
-        if(tar != null)
-            guard.setCombatTarget(tar);
-    }
-
-    public static Boolean GuardCanAggro(Mob guard, PlayerCharacter loadedPlayer){
-        if (loadedPlayer == null)
-            return false;
-
-        //Player is Dead, Mob no longer needs to attempt to aggro. Remove them from aggro map.
-        if (!loadedPlayer.isAlive())
-            return false;
-
-        //Can't see target, skip aggro.
-        if (!guard.canSee(loadedPlayer))
-            return false;
-
-        if(guard.guardedCity != null && guard.guardedCity.cityOutlaws.contains(loadedPlayer.getObjectUUID()))
-            return true;
-
-        if(loadedPlayer.guild.getNation().equals(guard.guardedCity.getGuild().getNation()))
-            return false;
-
-        return !guard.guardedCity.isOpen();
-    }
-
-    public static void GuardCast(Mob mob) {
-
-        if(mob.nextCastTime > System.currentTimeMillis())
-            return;
-
-        try {
-            // Method picks a random spell from a mobile's list of powers
-            // and casts it on the current target (or itself).  Validation
-            // (including empty lists) is done previously within canCast();
-
-            ArrayList<Integer> powerTokens;
-            ArrayList<Integer> purgeTokens;
-            AbstractCharacter target = (AbstractCharacter) mob.getCombatTarget();
-
-            // Generate a list of tokens from the mob powers for this mobile.
-
-            powerTokens = new ArrayList<>(mob.mobPowers.keySet());
-            purgeTokens = new ArrayList<>();
-
-            // If player has this effect on them currently then remove
-            // this token from our list.
-
-            for (int powerToken : powerTokens) {
-
-                PowersBase powerBase = PowersManager.getPowerByToken(powerToken);
-
-                for (ActionsBase actionBase : powerBase.getActions()) {
-
-                    String stackType = actionBase.stackType;
-
-                    if (target.getEffects() != null && target.getEffects().containsKey(stackType))
-                        purgeTokens.add(powerToken);
-                }
-            }
-
-            powerTokens.removeAll(purgeTokens);
-
-            // Sanity check
-
-            if (powerTokens.isEmpty())
-                return;
-
-            int powerToken;
-            int nukeRoll = ThreadLocalRandom.current().nextInt(1,100);
-
-            if (nukeRoll < 55) {
-
-                //use direct damage spell
-                powerToken = powerTokens.get(powerTokens.size() - 1);
-
-            } else {
-                //use random spell
-                powerToken = powerTokens.get(ThreadLocalRandom.current().nextInt(powerTokens.size()));
-            }
-
-            int powerRank = 1;
-
-            switch(mob.getRank()){
-                case 1:
-                    powerRank = 10;
-                    break;
-                case 2:
-                    powerRank = 15;
-                    break;
-                case 3:
-                    powerRank = 20;
-                    break;
-                case 4:
-                    powerRank = 25;
-                    break;
-                case 5:
-                    powerRank = 30;
-                    break;
-                case 6:
-                    powerRank = 35;
-                    break;
-                case 7:
-                    powerRank = 40;
-                    break;
-            }
-
-            PowersBase mobPower = PowersManager.getPowerByToken(powerToken);
-
-            //check for hit-roll
-
-            if (mobPower.requiresHitRoll)
-                if (CombatUtilities.triggerDefense(mob, mob.getCombatTarget()))
-                    return;
-
-            // Cast the spell
-
-            if (CombatUtilities.inRange2D(mob, mob.getCombatTarget(), mobPower.getRange())) {
-
-                PerformActionMsg msg;
-
-                if (!mobPower.isHarmful() || mobPower.targetSelf) {
-
-                    if (mobPower.category.equals("DISPEL")) {
-                        PowersManager.useMobPower(mob, target, mobPower, powerRank);
-                        msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, target);
-                    } else {
-                        PowersManager.useMobPower(mob, mob, mobPower, powerRank);
-                        msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, mob);
-                    }
-                } else {
-                    PowersManager.useMobPower(mob, target, mobPower, powerRank);
-                    msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, target);
-                }
-
-                msg.setUnknown04(2);
-
-                PowersManager.finishUseMobPower(msg, mob, 0, 0);
-            }
-            mob.nextCastTime = (long) (System.currentTimeMillis() + MobAIThread.AI_CAST_FREQUENCY);
-        } catch (Exception e) {
-            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
-        }
-    }
-
-    public static void CheckToAttack(Mob guard){
-        try {
-
-            if(guard.getLastAttackTime() > System.currentTimeMillis())
-                return;
-
-            PlayerCharacter target = (PlayerCharacter) guard.combatTarget;
-
-            if (!guard.canSee(target)) {
-                guard.setCombatTarget(null);
-                return;
-            }
-
-            if (guard.isMoving() && guard.getRange() > 20)
-                return;
-
-            if(target.combatStats == null)
-                target.combatStats = new PlayerCombatStats(target);
-
-            ItemBase mainHand = guard.getWeaponItemBase(true);
-            ItemBase offHand = guard.getWeaponItemBase(false);
-
-            if (mainHand == null && offHand == null) {
-                CombatUtilities.combatCycle(guard, target, true, null);
-                int delay = 3000;
-                guard.setLastAttackTime(System.currentTimeMillis() + delay);
-            } else if (guard.getWeaponItemBase(true) != null) {
-                int delay = 3000;
-                CombatUtilities.combatCycle(guard, target, true, guard.getWeaponItemBase(true));
-                guard.setLastAttackTime(System.currentTimeMillis() + delay);
-            } else if (guard.getWeaponItemBase(false) != null) {
-                int attackDelay = 3000;
-                CombatUtilities.combatCycle(guard, target, false, guard.getWeaponItemBase(false));
-                guard.setLastAttackTime(System.currentTimeMillis() + attackDelay);
-            }
-
-            if (target.getPet() != null)
-                if (target.getPet().getCombatTarget() == null && target.getPet().assist)
-                    target.getPet().setCombatTarget(guard);
-
-        } catch (Exception e) {
-            ////(guard.getObjectUUID() + " " + guard.getName() + " Failed At: AttackPlayer" + " " + e.getMessage());
-        }
-    }
-
-    public static void CheckGuardMovement(Mob guard){
-        if (guard.getCombatTarget() == null) {
-            if (!guard.isMoving())
-                Patrol(guard);
-            else {
-                guard.stopPatrolTime = System.currentTimeMillis();
-            }
-        } else {
-            MovementUtilities.moveToLocation(guard, guard.combatTarget.loc, guard.getRange());
-        }
-    }
-
-    private static void Patrol(Mob mob) {
-
-        try {
-
-            if(mob.isMoving())
-                return;
-            //make sure mob is out of combat stance
-
-            int patrolDelay = ThreadLocalRandom.current().nextInt((int) (MobAIThread.AI_PATROL_DIVISOR * 0.5f), MobAIThread.AI_PATROL_DIVISOR) + MobAIThread.AI_PATROL_DIVISOR;
-
-            //early exit while waiting to patrol again
-
-            if (mob.stopPatrolTime + (patrolDelay * 1000L) > System.currentTimeMillis())
-                return;
-
-            if (mob.lastPatrolPointIndex > mob.patrolPoints.size() - 1)
-                mob.lastPatrolPointIndex = 0;
-
-            mob.destination = Vector3fImmutable.getRandomPointOnCircle(mob.patrolPoints.get(mob.lastPatrolPointIndex),16f);
-            mob.lastPatrolPointIndex += 1;
-
-            MovementUtilities.aiMove(mob, mob.destination, true);
-
-        } catch (Exception e) {
-            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
-        }
-    }
-
-    private static boolean inRangeToCast(Mob guard, AbstractWorldObject target){
-        float castRangeSquared = 50f * 50f;
-        float rangeSquared = guard.loc.distanceSquared(target.loc);
-        return castRangeSquared >= rangeSquared;
-    }
-
-    public static void CheckMagisterMovement(Mob guard){
-        if (guard.getCombatTarget() == null) {
-            if (!guard.isMoving())
-                Patrol(guard);
-            else {
-                guard.stopPatrolTime = System.currentTimeMillis();
-            }
-        } else {
-            if(guard.isMoving()){
-                float desiredRangeSquared = 40f * 40f;
-                float distance = guard.loc.distanceSquared(guard.combatTarget.loc);
-                if(distance <= desiredRangeSquared){
-                    guard.stopMovement(guard.getMovementLoc());
-                    guard.updateLocation();
-                }
-            }else {
-                MovementUtilities.moveToLocation(guard, guard.combatTarget.loc, guard.getRange());
-            }
-        }
-    }
-
-    public static void CheckForRecall(Mob guard){
-
-        if(guard.loc.distanceSquared(guard.parentZone.getLoc()) > (800 * 800)) {
-
-            PowersBase recall = PowersManager.getPowerByToken(-1994153779);
-            PowersManager.useMobPower(guard, guard, recall, 40);
-
-            for (Map.Entry playerEntry : guard.playerAgroMap.entrySet())
-                PlayerCharacter.getFromCache((int) playerEntry.getKey()).setHateValue(0);
-
-            guard.setCombatTarget(null);
-        }
-    }
-
-    public static void CheckRespawn(Mob guard){
-        if(!guard.despawned)
-            guard.despawn();
-
-        long respawnTime = 0L;
-
-        Building barracks = guard.building;
-        if(barracks == null){
-            respawnTime = MBServerStatics.FIFTEEN_MINUTES;
-        }else{
-            switch(barracks.getRank()) {
-                case 2:
-                    respawnTime = 750000; // 12.5 minutes
-                    break;
-                case 3:
-                    respawnTime = 660000; // 11 minutes
-                    break;
-                case 4:
-                    respawnTime = 570000; // 9.5 minutes
-                    break;
-                case 5:
-                    respawnTime = 480000; // 8 minutes
-                    break;
-                case 6:
-                    respawnTime = 450000; // 6.5 minutes
-                    break;
-                case 7:
-                    respawnTime = MBServerStatics.FIVE_MINUTES;
-                    break;
-                default:
-                    respawnTime = MBServerStatics.FIFTEEN_MINUTES;
-                    break;
-            }
-
-        }
-
-        if(guard.deathTime + respawnTime < System.currentTimeMillis()){
-            if (!Zone.respawnQue.contains(guard)) {
-                Zone.respawnQue.add(guard);
-            }
-        }
-    }
-}

src/engine/mobileAI/MobHandlers/SiegeHandler.java

@@ -1,56 +0,0 @@
-package engine.mobileAI.MobHandlers;
-
-import engine.Enum;
-import engine.gameManager.MovementManager;
-import engine.gameManager.ZoneManager;
-import engine.mobileAI.utilities.CombatUtilities;
-import engine.mobileAI.utilities.MovementUtilities;
-import engine.objects.Building;
-import engine.objects.City;
-import engine.objects.Mob;
-import engine.server.MBServerStatics;
-
-public class SiegeHandler {
-    public static void run(Mob engine){
-
-        if(!engine.isAlive()) {
-            check_siege_respawn(engine);
-            return;
-        }
-
-        if(engine.getOwner() == null || !engine.getOwner().isAlive() || !engine.playerAgroMap.containsKey(engine.getOwner().getObjectUUID()))
-            return;
-
-        if(engine.combatTarget == null || !engine.combatTarget.getObjectType().equals(Enum.GameObjectType.Building))
-            return;
-
-        siege_attack(engine);
-    }
-
-    public static void check_siege_respawn(Mob engine){
-        if(!engine.despawned) {
-            engine.despawn();
-        }else{
-            if(engine.deathTime + MBServerStatics.FIFTEEN_MINUTES > System.currentTimeMillis()){
-                engine.respawn();
-            }
-        }
-    }
-
-    public static void siege_attack(Mob engine){
-        if(engine.getLastAttackTime() > System.currentTimeMillis())
-            return;
-
-        if(CombatUtilities.inRangeToAttack(engine,engine.combatTarget)){
-            CombatUtilities.combatCycle(engine, engine.combatTarget, true, null);
-            engine.setLastAttackTime(System.currentTimeMillis() + 15000);
-            City playercity = ZoneManager.getCityAtLocation(engine.getLoc());
-            if (playercity != null)
-                for (Mob guard : playercity.getParent().zoneMobSet)
-                    if (guard.isPlayerGuard && guard.combatTarget == null && guard.getGuild() != null && engine.getGuild() != null && !guard.getGuild().equals(engine.getGuild()))
-                        MovementUtilities.aiMove(guard,engine.loc,false);
-
-            MovementManager.sendRWSSMsg(engine);
-        }
-    }
-}

src/engine/mobileAI/SuperSimpleMobAI.java

@@ -1,26 +0,0 @@
-package engine.mobileAI;
-
-import engine.mobileAI.MobHandlers.MobHandler;
-import engine.mobileAI.MobHandlers.PetHandler;
-import engine.mobileAI.MobHandlers.PlayerGuardHandler;
-import engine.mobileAI.MobHandlers.SiegeHandler;
-import engine.objects.Mob;
-
-public class SuperSimpleMobAI {
-
-    public static void run(Mob mob){
-        mob.updateLocation();
-        if(mob.isPet() && !mob.isSiege()) {
-            PetHandler.run(mob);
-            return;
-        }else if (mob.isSiege()) {
-            SiegeHandler.run(mob);
-            return;
-        }else if(mob.isPlayerGuard()){
-            PlayerGuardHandler.run(mob);
-            return;
-        }else {
-            MobHandler.run(mob);
-        }
-    }
-}

src/engine/mobileAI/Threads/MobAIThread.java

@@ -3,7 +3,6 @@ package engine.mobileAI.Threads;
 import engine.gameManager.ConfigManager;
 import engine.mobileAI.MobAI;
 import engine.gameManager.ZoneManager;
-import engine.mobileAI.SuperSimpleMobAI;
 import engine.objects.Mob;
 import engine.objects.Zone;
 import engine.server.MBServerStatics;
@@ -28,26 +27,26 @@ public class MobAIThread implements Runnable{
         AI_CAST_FREQUENCY = Float.parseFloat(ConfigManager.MB_AI_CAST_FREQUENCY.getValue());
         AI_BASE_AGGRO_RANGE = (int)(60 * Float.parseFloat(ConfigManager.MB_AI_AGGRO_RANGE.getValue()));
         while (true) {
-            try {
-                for (Zone zone : ZoneManager.getAllZones()) {
-                    if (zone != null && zone.zoneMobSet != null) {
-                        synchronized (zone.zoneMobSet) {
-                            for (Mob mob : zone.zoneMobSet) {
-                                try {
-                                    if (mob != null) {
-                                        //MobAI.DetermineAction(mob);
-                                        SuperSimpleMobAI.run(mob);
-                                    }
-                                } catch (Exception e) {
-                                    Logger.error("Error processing Mob [Name: {}, UUID: {}]", mob.getName(), mob.getObjectUUID(), e);
+            for (Zone zone : ZoneManager.getAllZones()) {
+                if (zone != null && zone.zoneMobSet != null) {
+                    synchronized (zone.zoneMobSet) {
+                        for (Mob mob : zone.zoneMobSet) {
+                            try {
+                                if (mob != null) {
+                                    MobAI.DetermineAction(mob);
                                 }
+                            } catch (Exception e) {
+                                Logger.error("Error processing Mob [Name: {}, UUID: {}]", mob.getName(), mob.getObjectUUID(), e);
                             }
                         }
                     }
                 }
+            }
+            try {
                 Thread.sleep(100);
-            }catch(Exception e){
-                Logger.error(e.getMessage());
+            } catch (InterruptedException e) {
+                Logger.error("AI Thread interrupted", e);
+                Thread.currentThread().interrupt();
             }
         }
     }

src/engine/mobileAI/utilities/CombatUtilities.java

@@ -132,6 +132,8 @@ public class CombatUtilities {
     }
 
     public static boolean canSwing(Mob agent) {
+        if(!CombatUtilities.inRange2D(agent,agent.combatTarget,agent.getRange()))
+            return false;
         return (agent.isAlive() && !agent.getBonuses().getBool(ModType.Stunned, SourceType.None));
     }
 

src/engine/mobileAI/utilities/MovementUtilities.java

@@ -13,6 +13,7 @@ import engine.Enum;
 import engine.Enum.GameObjectType;
 import engine.Enum.ModType;
 import engine.Enum.SourceType;
+import engine.InterestManagement.InterestManager;
 import engine.mobileAI.Threads.MobAIThread;
 import engine.exception.MsgSendException;
 import engine.gameManager.MovementManager;
@@ -193,6 +194,7 @@ public class MovementUtilities {
 
     public static void aiMove(Mob agent, Vector3fImmutable vect, boolean isWalking) {
 
+        //InterestManager.forceLoad(agent);
         //update our walk/run state.
         if (isWalking && !agent.isWalk()) {
             agent.setWalkMode(true);

src/engine/net/client/handlers/InviteToSubHandler.java

@@ -21,7 +21,6 @@ import engine.net.client.ClientConnection;
 import engine.net.client.msg.ClientNetMsg;
 import engine.net.client.msg.ErrorPopupMsg;
 import engine.net.client.msg.guild.InviteToSubMsg;
-import engine.objects.Bane;
 import engine.objects.Guild;
 import engine.objects.GuildStatusController;
 import engine.objects.PlayerCharacter;
@@ -113,12 +112,6 @@ public class InviteToSubHandler extends AbstractClientMsgHandler {
             return true;
         }
 
-        //ensure bane to be subbed does not have a bane dropped
-        for(Bane bane : Bane.banes.values()){
-            if(bane.getOwner().guild.getNation().equals(targetGuild))
-                return true;
-        }
-
         //all tests passed, let's send invite.
 
         if (target.getClientConnection() != null) {

src/engine/net/client/handlers/ItemProductionMsgHandler.java

@@ -24,7 +24,6 @@ import engine.net.client.msg.ErrorPopupMsg;
 import engine.net.client.msg.ItemProductionMsg;
 import engine.net.client.msg.ManageNPCMsg;
 import engine.objects.*;
-import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
 import java.util.HashMap;
@@ -362,7 +361,7 @@ public class ItemProductionMsgHandler extends AbstractClientMsgHandler {
                 vendor.removeItemFromForge(targetItem);
 
                 //refund the gold for cancelled item
-                if(vendor.building.getStrongboxValue() + targetItem.getItemBase().getBaseValue() < MBServerStatics.BUILDING_GOLD_LIMIT){
+                if(vendor.building.getStrongboxValue() + targetItem.getItemBase().getBaseValue() < 15000000){
                     vendor.building.setStrongboxValue(vendor.building.getStrongboxValue() + targetItem.getItemBase().getBaseValue());
                 }
 
@@ -416,6 +415,8 @@ public class ItemProductionMsgHandler extends AbstractClientMsgHandler {
             if (player.getCharItemManager().hasRoomInventory(targetItem.getItemBase().getWeight()) == false)
                 return;
 
+            targetItem.stripCastableEnchants();
+
             player.getCharItemManager().buyFromNPC(targetItem, vendor);
 
         }

src/engine/net/client/handlers/MoveToPointHandler.java

@@ -31,6 +31,8 @@ public class MoveToPointHandler extends AbstractClientMsgHandler {
         if (pc == null)
             return false;
 
+        pc.setIsCasting(false);
+        pc.setItemCasting(false);
         MovementManager.movement(msg, pc);
         return true;
     }

src/engine/net/client/handlers/ObjectActionMsgHandler.java

@@ -479,6 +479,7 @@ public class ObjectActionMsgHandler extends AbstractClientMsgHandler {
                             } else if (uuid == 910010) { //tears of saedron
                                 if (comps.size() > 1) {
                                     removeRune(player, origin, comps.get(1).intValue());
+                                    itemMan.consume(item);
                                 }
                                 break;
                             } else if (item.getChargesRemaining() > 0) {

src/engine/net/client/handlers/PlaceAssetMsgHandler.java

@@ -568,15 +568,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
             return false;
         }
 
-        //serverCity = ZoneManager.getCityAtLocation(buildingList.getLoc());
-        Bane validBane = null;
-        serverCity = null;
-        for(Bane b : Bane.banes.values()){
-                City c = b.getCity();
-                if(c.getGuild().equals(player.guild) || b.getOwner().guild.equals(player.guild))
-                    serverCity = b.getCity();
-        }
-
+        serverCity = ZoneManager.getCityAtLocation(buildingList.getLoc());
 
         // No valid player city found
 
@@ -619,13 +611,6 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
             return false;
         }
 
-        //make sure building is withing range
-        float distanceSquared = buildingList.getLoc().distanceSquared(serverCity.loc);
-        float allowedSquared = (CityBoundsType.SIEGEBOUNDS.extents * 0.65f) * (CityBoundsType.SIEGEBOUNDS.extents * 0.65f);
-        if(allowedSquared < distanceSquared) {
-            PlaceAssetMsg.sendPlaceAssetError(origin, 52, ""); // Cannot place outisde a guild zone
-            return false;
-        }
         // If there is a bane placed, we limit bow placement to 2x the stone rank's worth of attacker assets
         // and 1x the tree rank for defenders
 
@@ -667,7 +652,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
 
         // Count bow for attackers and defenders
 
-        awoList = WorldGrid.getObjectsInRangePartial(serverCity, CityBoundsType.SIEGEBOUNDS.extents, MBServerStatics.MASK_BUILDING);
+        awoList = WorldGrid.getObjectsInRangePartial(serverCity, 1000, MBServerStatics.MASK_BUILDING);
 
         for (AbstractWorldObject awo : awoList) {
             Building building = (Building) awo;
@@ -676,7 +661,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
                 if (!building.getBlueprint().isSiegeEquip())
                     continue;
 
-            if (!building.getLoc().isInsideCircle(serverCity.getLoc(), CityBoundsType.SIEGEBOUNDS.extents))
+            if (!building.getLoc().isInsideCircle(serverCity.getLoc(), CityBoundsType.ZONE.extents))
                 continue;
 
             if (building.getGuild() == null)

src/engine/net/client/msg/TeleportRepledgeListMsg.java

@@ -114,9 +114,9 @@ public class TeleportRepledgeListMsg extends ClientNetMsg {
         for (City city : cities)
             City.serializeForClientMsg(city, writer);
 
-        for(Mine mine : mines)
+        for(Mine mine : mines) {
             Mine.serializeForClientMsgTeleport(mine, writer);
-
+        }
         //Dungeon.serializeForClientMsgTeleport(writer);
     }
 

src/engine/objects/AbstractCharacter.java

@@ -24,6 +24,7 @@ import engine.jobs.TrackJob;
 import engine.math.AtomicFloat;
 import engine.math.Bounds;
 import engine.math.Vector3fImmutable;
+import engine.mobileAI.utilities.CombatUtilities;
 import engine.net.ByteBufferWriter;
 import engine.net.DispatchMessage;
 import engine.net.client.msg.UpdateStateMsg;
@@ -819,7 +820,8 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
         //TODO who the fuck wrote changeHeightJob. FIX THIS.
 
 
-        if (this.endLoc.equals(Vector3fImmutable.ZERO) || this.endLoc.equals(this.bindLoc))
+        float distance = this.loc.distance2D(this.endLoc);
+        if (this.endLoc.equals(Vector3fImmutable.ZERO) || this.endLoc.equals(this.bindLoc) || distance < 1)
             return false;
 
         if (this.takeOffTime != 0)
@@ -1046,7 +1048,9 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
             if (MBServerStatics.COMBAT_TARGET_HITBOX_DEBUG) {
                 Logger.info("Hit box radius for " + this.getFirstName() + " is " + (this.statStrCurrent / 200f));
             }
-            return ((PlayerCharacter) this).getStrForClient() / 200f;
+            int strength = ((PlayerCharacter) this).statStrBase;
+            float radius = strength * 0.1f * 0.5f;
+            return radius;
             //TODO CALCULATE MOB HITBOX BECAUSE FAIL  EMU IS FAIL!!!!!!!
         } else if (this.getObjectType() == GameObjectType.Mob) {
             if (MBServerStatics.COMBAT_TARGET_HITBOX_DEBUG) {
@@ -1230,7 +1234,7 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
                 //TODO why is Handle REtaliate and cancelontakedamage in modifyHealth? shouldnt this be outside this method?
                 if (value < 0f && !fromCost) {
                     this.cancelOnTakeDamage();
-                    CombatManager.handleRetaliate(this, attacker);
+                    //CombatManager.handleRetaliate(this, attacker);
                 }
 
                 return newHealth - oldHealth;
@@ -1287,7 +1291,7 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
         }
         if (value < 0f && !fromCost) {
             this.cancelOnTakeDamage();
-            CombatManager.handleRetaliate(this, attacker);
+            //CombatManager.handleRetaliate(this, attacker);
         }
         return newMana - oldMana;
     }
@@ -1334,7 +1338,7 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
         }
         if (value < 0f && !fromCost) {
             this.cancelOnTakeDamage();
-            CombatManager.handleRetaliate(this, attacker);
+            //CombatManager.handleRetaliate(this, attacker);
         }
         return newStamina - oldStamina;
     }
@@ -1369,7 +1373,7 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
         }
         if (oldMana > newMana && !fromCost) {
             this.cancelOnTakeDamage();
-            CombatManager.handleRetaliate(this, attacker);
+            //CombatManager.handleRetaliate(this, attacker);
         }
         return newMana - oldMana;
     }
@@ -1404,7 +1408,7 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
         }
         if (oldStamina > newStamina && !fromCost) {
             this.cancelOnTakeDamage();
-            CombatManager.handleRetaliate(this, attacker);
+            //CombatManager.handleRetaliate(this, attacker);
         }
         return newStamina - oldStamina;
 
@@ -1464,7 +1468,6 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
 
             if (eff == null)
                 continue;
-
             if (eff.cancelOnAttack() && eff.cancel()) {
                 eff.cancelJob();
                 this.effects.remove(s);

src/engine/objects/AbstractGameObject.java

@@ -169,7 +169,7 @@ public abstract class AbstractGameObject {
         return this.objectUUID;
     }
 
-    protected void setObjectUUID(int objectUUID) {
+    public void setObjectUUID(int objectUUID) {
         this.objectUUID = objectUUID;
     }
 

src/engine/objects/Arena.java

@@ -19,8 +19,8 @@ public class Arena {
 
     }
     public Boolean disqualify() {
-        HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(this.loc, ArenaManager.arena_radius, MBServerStatics.MASK_PLAYER);
-        HashSet<AbstractWorldObject> warningRange = WorldGrid.getObjectsInRangePartial(this.loc, ArenaManager.arena_radius + 250f, MBServerStatics.MASK_PLAYER);
+        HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(this.loc, 250f, MBServerStatics.MASK_PLAYER);
+        HashSet<AbstractWorldObject> warningRange = WorldGrid.getObjectsInRangePartial(this.loc, 500f, MBServerStatics.MASK_PLAYER);
         for(AbstractWorldObject obj : warningRange){
             PlayerCharacter pc = (PlayerCharacter)obj;
             if(pc.equals(this.player1) || pc.equals(this.player2))

src/engine/objects/Bane.java

@@ -57,8 +57,6 @@ public final class Bane {
     // Internal cache for banes
     private ActivateBaneJob activateBaneJob;
 
-    public ArrayList<PlayerCharacter> affected_players;
-
     /**
      * ResultSet Constructor
      */
@@ -210,25 +208,6 @@ public final class Bane {
             return false;
         }
 
-        //audit that defending nation does no have a bane on them already
-        boolean defenderBaned = false;
-        Guild defenderNation = targetCity.getGuild().getNation();
-        if(defenderNation.getOwnedCity() != null && defenderNation.getOwnedCity().getBane() != null){
-            defenderBaned = true;
-        }else{
-            for (Guild sub : defenderNation.getSubGuildList()) {
-                if (sub.getOwnedCity() != null) {
-                    if (sub.getOwnedCity().getBane() != null) {
-                        defenderBaned = true;
-                    }
-                }
-            }
-        }
-        if(defenderBaned){
-            ChatManager.chatSystemInfo(player, "This Nation has already been baned!");
-            return false;
-        }
-
         if (targetCity.isLocationOnCityGrid(player.getLoc()) == true) {
             PlaceAssetMsg.sendPlaceAssetError(origin, 1, "Cannot place banestone on city grid.");
             return false;
@@ -696,9 +675,6 @@ public final class Bane {
                 toUnprotect.setProtectionState(ProtectionState.NONE);
         }
 
-        for(PlayerCharacter affected : this.affected_players)
-            affected.ZergMultiplier = 1.0f;
-
     }
 
     public boolean isErrant() {
@@ -741,8 +717,6 @@ public final class Bane {
         if(city == null)
             return;
 
-        if(this.affected_players == null)
-            this.affected_players = new ArrayList<>();
         city.onEnter();
 
         ArrayList<Integer> attackers = new ArrayList<>();
@@ -753,13 +727,8 @@ public final class Bane {
         for(AbstractWorldObject obj : inSiegeRange){
             int uuid = obj.getObjectUUID();
             PlayerCharacter player = PlayerCharacter.getPlayerCharacter(uuid);
-
             if(player == null)
                 continue;
-
-            if(player.getAccount().status.equals(Enum.AccountStatus.ADMIN))
-                continue;
-
             Guild playerNation = player.guild.getNation();
             //separate the players into categories
             if(playerNation.equals(defendNation))
@@ -786,24 +755,18 @@ public final class Bane {
         float defenderMultiplier = ZergManager.getCurrentMultiplier(defenderSize,this.capSize);
         for(int uuid : attackers){
             PlayerCharacter player = PlayerCharacter.getPlayerCharacter(uuid);
-            if(inSiegeRange.contains(player)) { //player is still physically here, needs updated multiplier
+            if(inSiegeRange.contains(player)) //player is still physically here, needs updated multiplier
                 player.ZergMultiplier = attackerMultiplier;
-                this.affected_players.add(player);
-            }else {
+            else
                 player.ZergMultiplier = 1.0f;
-                this.affected_players.add(player);
-            }
         }
 
         for(int uuid : defenders){
             PlayerCharacter player = PlayerCharacter.getPlayerCharacter(uuid);
-            if(inSiegeRange.contains(player)) { //player is still physically here, needs updated multiplier
-                player.ZergMultiplier = attackerMultiplier;
-                this.affected_players.add(player);
-            }else {
+            if(inSiegeRange.contains(player)) //player is still physically here, needs updated multiplier
+                player.ZergMultiplier = defenderMultiplier;
+            else
                 player.ZergMultiplier = 1.0f;
-                this.affected_players.add(player);
-            }
         }
 
     }

src/engine/objects/Building.java

@@ -221,7 +221,7 @@ public class Building extends AbstractWorldObject {
             }
 
             this._strongboxValue = rs.getInt("currentGold");
-            this.maxGold = MBServerStatics.BUILDING_GOLD_LIMIT; // *** Refactor to blueprint method
+            this.maxGold = 100000000; // *** Refactor to blueprint method
             this.reserve = rs.getInt("reserve");
 
             // Does building have a protection contract?

src/engine/objects/CharacterTitle.java

@@ -5,60 +5,51 @@
 // ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
 //      Magicbane Emulator Project © 2013 - 2022
 //                www.magicbane.com
-
-
 package engine.objects;
-
 import engine.net.ByteBufferWriter;
-
 import java.nio.ByteBuffer;
-
 public enum CharacterTitle {
-
     NONE(0, 0, 0, ""),
     CSR_1(255, 0, 0, "CCR"),
     CSR_2(255, 0, 0, "CCR"),
     CSR_3(255, 0, 0, "CCR"),
     CSR_4(251, 181, 13, "CCR"),
     DEVELOPER(166, 153, 114, "Programmer"),
-    QA(88, 250, 244, "GIRLFRIEND");
-
+    QA(88, 250, 244, "GIRLFRIEND"),
+    PVE(0, 250, 0, "");
     int headerLength, footerLength;
     private ByteBuffer header;
     private ByteBuffer footer;
-
     CharacterTitle(int _r, int _g, int _b, String _prefix) {
         char[] str_header = ("^\\c" +
                 (((_r < 100) ? ((_r < 10) ? "00" : "0") : "") + ((byte) _r & 0xFF)) +
                 (((_g < 100) ? ((_g < 10) ? "00" : "0") : "") + ((byte) _g & 0xFF)) +
                 (((_b < 100) ? ((_b < 10) ? "00" : "0") : "") + ((byte) _b & 0xFF)) +
                 '<' + _prefix + "> ").toCharArray();
-
+        if (_prefix.equals("")) {
+            str_header = ("^\\c" +
+                    (((_r < 100) ? ((_r < 10) ? "00" : "0") : "") + ((byte) _r & 0xFF)) +
+                    (((_g < 100) ? ((_g < 10) ? "00" : "0") : "") + ((byte) _g & 0xFF)) +
+                    (((_b < 100) ? ((_b < 10) ? "00" : "0") : "") + ((byte) _b & 0xFF)) +
+                    _prefix).toCharArray();
+        }
         char[] str_footer = ("^\\c255255255").toCharArray();
-
         this.headerLength = str_header.length;
         this.footerLength = str_footer.length;
-
         this.header = ByteBuffer.allocateDirect(headerLength << 1);
         this.footer = ByteBuffer.allocateDirect(footerLength << 1);
-
         ByteBufferWriter headWriter = new ByteBufferWriter(header);
-
         for (char c : str_header) {
             headWriter.putChar(c);
         }
-
         ByteBufferWriter footWriter = new ByteBufferWriter(footer);
-
         for (char c : str_footer) {
             footWriter.putChar(c);
         }
     }
-
     public void _serializeFirstName(ByteBufferWriter writer, String firstName) {
         _serializeFirstName(writer, firstName, false);
     }
-
     public void _serializeFirstName(ByteBufferWriter writer, String firstName, boolean smallString) {
         if (this.ordinal() == 0) {
             if (smallString)
@@ -67,24 +58,19 @@ public enum CharacterTitle {
                 writer.putString(firstName);
             return;
         }
-
         char[] chars = firstName.toCharArray();
-
         if (smallString)
             writer.put((byte) (chars.length + this.headerLength));
         else
             writer.putInt(chars.length + this.headerLength);
         writer.putBB(header);
-
         for (char c : chars) {
             writer.putChar(c);
         }
     }
-
     public void _serializeLastName(ByteBufferWriter writer, String lastName, boolean haln, boolean asciiLastName) {
         _serializeLastName(writer, lastName, haln, asciiLastName, false);
     }
-
     public void _serializeLastName(ByteBufferWriter writer, String lastName, boolean haln, boolean asciiLastName, boolean smallString) {
         if (!haln || asciiLastName) {
             if (this.ordinal() == 0) {
@@ -95,19 +81,15 @@ public enum CharacterTitle {
                 return;
             }
         }
-
         if (!haln || asciiLastName) {
             char[] chars = lastName.toCharArray();
-
             if (smallString)
                 writer.put((byte) (chars.length + this.footerLength));
             else
                 writer.putInt(chars.length + this.footerLength);
-
             for (char c : chars) {
                 writer.putChar(c);
             }
-
             writer.putBB(footer);
         } else {
             if (smallString)
@@ -116,6 +98,5 @@ public enum CharacterTitle {
                 writer.putInt(this.footerLength);
             writer.putBB(footer);
         }
-
     }
-}
+}

src/engine/objects/City.java

@@ -382,6 +382,12 @@ public class City extends AbstractWorldObject {
             if (ago.getObjectType().equals(GameObjectType.City)) {
                 City city = (City) ago;
 
+                if(city == null)
+                    continue;
+
+                if(city.getTOL() != null && city.getTOL().getRank() < 0)
+                    continue;
+
                 if (city.noTeleport)
                     continue;
 
@@ -397,7 +403,7 @@ public class City extends AbstractWorldObject {
                             cities.add(city);
                         }else {
                             try {
-                                if (city.getGuild() != null && city.getGuild().getNation().equals(pc.guild.getNation())) {
+                                if (city.getGuild().getNation().equals(pc.guild.getNation())) {
                                     cities.add(city);
                                 }
                             }catch(Exception e){
@@ -953,7 +959,7 @@ public class City extends AbstractWorldObject {
 
     public boolean isLocationWithinSiegeBounds(Vector3fImmutable insideLoc) {
 
-        return insideLoc.isInsideCircle(this.getLoc(), CityBoundsType.SIEGEBOUNDS.extents);
+        return insideLoc.isInsideCircle(this.getLoc(), CityBoundsType.ZONE.extents);
 
     }
 

src/engine/objects/Contract.java

@@ -591,10 +591,10 @@ public class Contract extends AbstractGameObject {
             for(MobEquipment me : this.sellInventory){
                 switch(me.getItemBase().getUUID()) {
                     case 971070:
-                        me.magicValue = 3000000;
+                        me.magicValue = 2000000;
                         break;
                     case 971012:
-                        me.magicValue = 1000000;
+                        me.magicValue = 500000;
                         break;
                 }
             }
@@ -737,9 +737,6 @@ public class Contract extends AbstractGameObject {
         if (this.allowedBuildings.size() == 0)
             return false;
 
-        if(this.name.equals("Siege Engineer") && building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.SIEGETENT))
-            return true;
-
         // Binary match
         return (building.getBlueprint().getBuildingGroup().elementOf(this.allowedBuildings));
     }

src/engine/objects/Effect.java

@@ -330,7 +330,7 @@ public class Effect {
                 serializeForClientMsg(writer);
                 return;
             }
-            float duration = this.jc.timeToExecutionLeft() / 1000;
+            float duration = this.jc.timeToExecutionLeft() * 0.001f;// 1000;
             writer.putInt(this.eb.getToken());
             writer.putInt(aej.getTrains());
             writer.putInt(0);
@@ -366,7 +366,7 @@ public class Effect {
             return;
         }
 
-        float duration = this.jc.timeToExecutionLeft() / 1000;
+        float duration = this.jc.timeToExecutionLeft() *0.001f;// 1000;
         if (aej instanceof DamageOverTimeJob)
             duration = ab.getDurationInSeconds(aej.getTrains()) - (((DamageOverTimeJob) aej).getIteration() * 5);
 

src/engine/objects/ForgeWorkOrder.java

@@ -1,11 +0,0 @@
-package engine.objects;
-
-public class ForgeWorkOrder {
-    public int itembaseUUID;
-    public String prefix;
-    public String suffix;
-    public boolean resourceRolled;
-    public boolean randomRolled;
-    public int orderAmount;
-    public int slot;
-}

src/engine/objects/ItemBase.java

@@ -333,6 +333,13 @@ public class ItemBase {
     }
 
     public int getBaseValue() {
+        if(this.getUUID() == 971070){
+            return 2000000;
+        }
+
+        if(this.getUUID() == 971012){
+            return 500000;
+        }
         return this.value;
     }
 

src/engine/objects/ItemFactory.java

@@ -26,6 +26,7 @@ import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
 
 import java.util.ArrayList;
+import java.util.Random;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ThreadLocalRandom;
 
@@ -679,11 +680,10 @@ public class ItemFactory {
             return null;
         }
 
+        Random random = new Random();
         for (byte temp : vendor.getItemModTable()) {
-
             if (itemModTable != temp)
                 continue;
-
             prefixMod = vendor.getModTypeTable().get(vendor.getItemModTable().indexOf(temp));
             suffixMod = vendor.getModSuffixTable().get(vendor.getItemModTable().indexOf(temp));
         }
@@ -693,44 +693,31 @@ public class ItemFactory {
             return null;
         }
 
-        // Roll on the tables for this vendor
+        ArrayList<ModTypeTableEntry> prefixTable = LootManager._modTypeTables.get(prefixMod);
+        ArrayList<ModTypeTableEntry> suffixTable = LootManager._modTypeTables.get(suffixMod);
 
-        ModTypeTableEntry prefixTypeTable = ModTypeTableEntry.rollTable(prefixMod, ThreadLocalRandom.current().nextInt(1, 100 + 1));
-        ModTypeTableEntry suffixTypeTable = ModTypeTableEntry.rollTable(suffixMod, ThreadLocalRandom.current().nextInt(1, 100 + 1));
+        ModTypeTableEntry prefixTypeTable = prefixTable.get(random.nextInt(prefixTable.size()));
+        ModTypeTableEntry suffixTypeTable = suffixTable.get(random.nextInt(suffixTable.size()));
 
         // Sanity check.
 
         if (prefixTypeTable == null || suffixTypeTable == null)
             return null;
 
-        int rollPrefix = ThreadLocalRandom.current().nextInt(1, 100 + 1);
+        int rollPrefix = ThreadLocalRandom.current().nextInt(100);
 
         if (rollPrefix < vendor.getLevel() + 30) {
-
             int randomPrefix = TableRoll(vendor.getLevel());
-            if(vendor.contract.getName().contains("Heavy") || vendor.contract.getName().contains("Medium") || vendor.contract.getName().contains("Leather"))
-                randomPrefix += vendor.level * 0.5f;
-            if(randomPrefix > 320)
-                randomPrefix = 320;
             prefixEntry = ModTableEntry.rollTable(prefixTypeTable.modTableID, randomPrefix);
-
             if (prefixEntry != null)
                 prefix = prefixEntry.action;
-
         }
 
-        int rollSuffix = ThreadLocalRandom.current().nextInt(1, 100 + 1);
-
-        // Always have at least one mod on a magic rolled item.
-        // Suffix will be our backup plan.
+        int rollSuffix = ThreadLocalRandom.current().nextInt( 100);
 
         if (rollSuffix < vendor.getLevel() + 30) {
 
             int randomSuffix = TableRoll(vendor.getLevel());
-            if(vendor.contract.getName().contains("Heavy") || vendor.contract.getName().contains("Medium") || vendor.contract.getName().contains("Leather"))
-                randomSuffix += vendor.level * 0.25f;
-            if(randomSuffix > 320)
-                randomSuffix = 320;
             suffixEntry = ModTableEntry.rollTable(suffixTypeTable.modTableID, randomSuffix);
 
             if (suffixEntry != null)
@@ -1092,4 +1079,5 @@ public class ItemFactory {
         return ml;
 
     }
+
 }

src/engine/objects/Mine.java

@@ -69,6 +69,8 @@ public class Mine extends AbstractGameObject {
     public HashMap<Integer,Integer> oldBuildings;
     public HashMap<Integer, Long> mineAttendees = new HashMap<>();
 
+    public ZergTracker zergTracker;
+
     public Long allowed_teleport_time;
     public Boolean enforceLore = false;
     public HashMap<Guild, Enum.GuildType> chosen_charters;
@@ -131,6 +133,20 @@ public class Mine extends AbstractGameObject {
         this.openHour = rs.getInt("mineLiveHour");
         this.openMinute = rs.getInt("mineLiveMinute");
         this.capSize = rs.getInt("capSize");
+
+        //uncomment this for weekend 5s in lieu of 3s
+        //int loggedCapSize = rs.getInt("capSize");
+        //if(loggedCapSize == 3){
+        //    int dayOfWeek = DateTime.now().dayOfWeek().get();
+        //    if(dayOfWeek == 7 || dayOfWeek == 6 || dayOfWeek == 5){
+        //        this.capSize = 5;
+        //    }else{
+       //         this.capSize = loggedCapSize;
+        //    }
+        //}else{
+        //    this.capSize = loggedCapSize;
+        //}
+
         this.liveTime = LocalDateTime.now().withHour(this.openHour).withMinute(this.openMinute);
         Building tower = BuildingManager.getBuildingFromCache(this.buildingID);
         if(tower != null){
@@ -653,6 +669,11 @@ public class Mine extends AbstractGameObject {
                 ChatManager.chatSystemInfo(player,"You Have Entered an Active Mine Area");
             }
             Guild nation = player.guild.getNation();
+
+            if(this.enforceLore){
+                LoreMineManager.AuditPlayer(player, this);
+            }
+
             if(charactersByNation.containsKey(nation)){
                 if(!charactersByNation.get(nation).contains(player)) {
                     charactersByNation.get(nation).add(player);

src/engine/objects/Mob.java

@@ -87,7 +87,7 @@ public class Mob extends AbstractIntelligenceAgent {
     protected int loadID;
     protected float spawnRadius;
     //used by static mobs
-    protected int parentZoneID;
+    public int parentZoneID;
     protected float statLat;
     protected float statLon;
     protected float statAlt;
@@ -111,6 +111,8 @@ public class Mob extends AbstractIntelligenceAgent {
     public boolean StrongholdEpic = false;
     public boolean isDropper = false;
 
+    public Boolean isHellgateMob = false;
+
     public HashMap<PlayerCharacter,Float> hate_values;
 
 
@@ -127,6 +129,7 @@ public class Mob extends AbstractIntelligenceAgent {
         this.parentZone = parent;
         this.parentZoneID = (parent != null) ? parent.getObjectUUID() : 0;
         this.building = building;
+        this.bonuses = new PlayerBonuses(this);
 
         if (building != null)
             this.buildingID = building.getObjectUUID();
@@ -140,6 +143,7 @@ public class Mob extends AbstractIntelligenceAgent {
         if (building != null && building.getOwner() != null) {
             this.lastName = "the " + contract.getName();
         }
+        this.gridObjectType = GridObjectType.DYNAMIC;
         clearStatic();
     }
 
@@ -1494,8 +1498,11 @@ public class Mob extends AbstractIntelligenceAgent {
 
         if (isPlayerGuard)
             return;
-
-        LootManager.GenerateMobLoot(this);
+        if(this.isHellgateMob){
+            LootManager.GenerateStrongholdLoot(this,false,false);
+        }else {
+            LootManager.GenerateMobLoot(this);
+        }
     }
 
     @Override
@@ -1532,7 +1539,9 @@ public class Mob extends AbstractIntelligenceAgent {
             this.setResists(new Resists("Dropper"));
         } else if(this.isDropper){
             this.setResists(new Resists("Dropper"));
-        } else{
+        } else if(this.getMobBaseID() == 14104){
+            this.setResists(new Resists("Elite"));
+        }else{
             this.setResists(new Resists());
         }
         this.resists.calculateResists(this, false);
@@ -1965,6 +1974,9 @@ public class Mob extends AbstractIntelligenceAgent {
 
         }
         try {
+            if(this.equipmentSetID == 6481) {
+                int i = 0;
+            }
             if (this.equipmentSetID != 0)
                 this.equip = MobBase.loadEquipmentSet(this.equipmentSetID);
             else
@@ -1995,11 +2007,15 @@ public class Mob extends AbstractIntelligenceAgent {
         //skip for pets
 
         if (this.isPet() == false && (this.agentType.equals(AIAgentType.PET)) == false && this.isNecroPet() == false) {
-            if (this.getMobBase().notEnemy.size() > 0)
-                this.notEnemy.addAll(this.getMobBase().notEnemy);
+            try {
+                if (this.getMobBase().notEnemy.size() > 0)
+                    this.notEnemy.addAll(this.getMobBase().notEnemy);
 
-            if (this.getMobBase().enemy.size() > 0)
-                this.enemy.addAll(this.getMobBase().enemy);
+                if (this.getMobBase().enemy.size() > 0)
+                    this.enemy.addAll(this.getMobBase().enemy);
+            }catch(Exception ignored){
+
+            }
         }
 
         try {
@@ -2056,6 +2072,11 @@ public class Mob extends AbstractIntelligenceAgent {
                 }
 
             this.deathTime = 0;
+
+            if(this.isPet() && this.bonuses != null){
+                this.healthMax = this.healthMax + this.bonuses.getFloat(ModType.HealthFull,SourceType.None);
+                this.health.set(this.healthMax);
+            }
             InterestManager.setObjectDirty(this);
         } catch (Exception e) {
             Logger.error(e.getMessage());

src/engine/objects/MobBase.java

@@ -131,16 +131,22 @@ public class MobBase extends AbstractGameObject {
             return equip;
 
         for (BootySetEntry equipmentSetEntry : equipList) {
+            try {
+                if(equipmentSetEntry.itemBase == 189500){
+                    int i = 0;
+                }
+                MobEquipment mobEquipment = new MobEquipment(equipmentSetEntry.itemBase, equipmentSetEntry.dropChance);
+                ItemBase itemBase = mobEquipment.getItemBase();
 
-            MobEquipment mobEquipment = new MobEquipment(equipmentSetEntry.itemBase, equipmentSetEntry.dropChance);
-            ItemBase itemBase = mobEquipment.getItemBase();
+                if (itemBase != null) {
+                    if (itemBase.getType().equals(Enum.ItemType.WEAPON))
+                        if (mobEquipment.getSlot() == 1 && itemBase.getEquipFlag() == 2)
+                            mobEquipment.setSlot(2);
 
-            if (itemBase != null) {
-                if (itemBase.getType().equals(Enum.ItemType.WEAPON))
-                    if (mobEquipment.getSlot() == 1 && itemBase.getEquipFlag() == 2)
-                        mobEquipment.setSlot(2);
-
-                equip.put(mobEquipment.getSlot(), mobEquipment);
+                    equip.put(mobEquipment.getSlot(), mobEquipment);
+                }
+            }catch(Exception e){
+                Logger.error(e);
             }
         }
 

src/engine/objects/MobEquipment.java

@@ -98,7 +98,11 @@ public class MobEquipment extends AbstractGameObject {
         this.dropChance = dropChance;
 
         this.parentID = 0;
-        setMagicValue();
+        try {
+            setMagicValue();
+        }catch(Exception e){
+
+        }
     }
 
     public static int getNewID() {
@@ -290,6 +294,14 @@ public class MobEquipment extends AbstractGameObject {
 
     public int getMagicValue() {
 
+        if(this.itemBase.getUUID() == 971070){
+            return 2000000;
+        }
+
+        if(this.itemBase.getUUID() == 971012){
+            return 500000;
+        }
+
         if (!this.isID) {
             return itemBase.getBaseValue();
         }

src/engine/objects/PlayerCharacter.java

@@ -41,7 +41,6 @@ import engine.server.MBServerStatics;
 import engine.server.login.LoginServer;
 import engine.server.login.LoginServerMsgHandler;
 import engine.server.world.WorldServer;
-import engine.util.KeyCloneAudit;
 import engine.util.MiscUtils;
 import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
@@ -5145,29 +5144,39 @@ public class PlayerCharacter extends AbstractCharacter {
     @Override
     public void update(Boolean newSystem) {
 
-        this.updateLocation();
-        this.updateMovementState();
-
         if(!newSystem)
             return;
 
         try {
 
             if (this.updateLock.writeLock().tryLock()) {
+
                 try {
 
-                    if (this.isAlive() && this.isActive && this.enteredWorld) {
+                    if (!this.isAlive()) {
+                        if(this.isMoving())
+                            this.stopMovement(this.getMovementLoc());
+                        return;
+                    }
+                    //this.updateLocation();
+                    if(this.isMoving()){
+                        this.setLoc(this.getMovementLoc());
+                        this.region = Regions.GetRegionForTeleport(this.getMovementLoc());
+                    }else{
+                        this.setLoc(this.loc);
+                        this.region = Regions.GetRegionForTeleport(this.loc);
+                    }
+                    this.updateMovementState();
+                    this.doRegen();
 
-                        if (this.combatStats == null) {
+                    if (this.combatStats == null) {
                             this.combatStats = new PlayerCombatStats(this);
                         } else {
-                            try {
-                                this.combatStats.update();
-                            }catch(Exception ignored){
+                        try {
+                            this.combatStats.update();
+                        } catch (Exception ignored) {
 
-                            }
                         }
-                        this.doRegen();
                     }
 
                     if (this.getStamina() < 10) {
@@ -5181,15 +5190,67 @@ public class PlayerCharacter extends AbstractCharacter {
 
                     this.safeZone = this.isInSafeZone();
 
-                    if(this.isActive && this.enteredWorld)
-                        if (this.level < 10)
-                            while (this.level < 10)
+                    if(this.isActive && this.enteredWorld) {
+                        if (!this.timestamps.containsKey("nextBoxCheck"))
+                            this.timestamps.put("nextBoxCheck", System.currentTimeMillis() + 10000);
+
+                        if(!this.isBoxed && this.timestamps.get("nextBoxCheck") < System.currentTimeMillis()) {
+                            //updateBoxStatus(checkIfBoxed(this));
+                            this.isBoxed = checkIfBoxed(this);
+                            this.timestamps.put("nextBoxCheck", System.currentTimeMillis() + 10000);
+                        }
+
+                        if (this.level < 10 && this.enteredWorld) {
+                            while (this.level < 10) {
                                 grantXP(Experience.getBaseExperience(this.level + 1) - this.exp);
+                            }
+                        }
+                        if(this.isBoxed && !this.containsEffect(-654906771)){
+                            PowersManager.applyPower(this,this,this.loc,-935138707,40,false);
+                        }else if(!this.isBoxed && this.containsEffect(-654906771)){
+                            EffectsBase eb = PowersManager.getEffectByToken(-654906771);
+                            //this.effects.remove(String.valueOf(eb.getUUID()));
+                            for(Effect eff : this.effects.values()){
+                                if(eff.getEffectsBase().equals(eb)){
+                                    eff.endEffect();
+                                    eff.endEffectNoPower();
+                                }
+                            }
+                            this.effects.remove("PvE-Flagged");
+                            this.effects.remove("1258");
+                        }
+                    }
+                    if (this.isFlying()) {
+                        if (this.effects.containsKey("MoveBuff")) {
+                            GroundPlayer(this);
+                        }
+                        if (!this.timestamps.containsKey("StunGrounded"))
+                            this.timestamps.put("StunGrounded", System.currentTimeMillis() - 1000L);
+                        if (this.bonuses.getBool(ModType.Stunned, SourceType.None) && this.timestamps.get("StunGrounded") < System.currentTimeMillis()) {
+                            boolean isFlyMoving = this.getDesiredAltitude() != this.altitude;
+                            if (!isFlyMoving && this.bonuses.getBool(ModType.Stunned, SourceType.None)) {
+                                this.setDesiredAltitude(this.altitude - 10);
+                                this.setTakeOffTime(System.currentTimeMillis());
 
-                    this.auditBoxedStatus();
+                                ChangeAltitudeMsg msg = new ChangeAltitudeMsg(this.getObjectType().ordinal(), this.getObjectUUID(), false, this.getAltitude(), this.getDesiredAltitude(), this.getAltitude());
+                                // force a landing
+                                DispatchMessage.dispatchMsgToInterestArea(this, msg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
+                                this.timestamps.put("StunGrounded", System.currentTimeMillis() + 1500L);
+                                ChatManager.chatSystemInfo(this, "Applying 1 Tier Ground");
+                            }
+                        }
 
-                    if (this.isFlying())
-                        this.auditFlightStatus();
+                    }
+                    //if(!this.timestamps.containsKey("nextReload")){
+                    //    this.timestamps.put("nextReload",System.currentTimeMillis() + 5000);
+                   // }else{
+                    //    if(this.timestamps.get("nextReload") < System.currentTimeMillis()) {
+                    //        this.setDirtyLoad(true);
+                     //       InterestManager.setObjectDirty(this);
+                    //        InterestManager.INTERESTMANAGER.RefreshLoadedObjects(this);
+                     //       this.timestamps.put("nextReload",System.currentTimeMillis() + 5000);
+                     //   }
+                   // }
 
                 } catch (Exception e) {
                     Logger.error(e);
@@ -5201,89 +5262,26 @@ public class PlayerCharacter extends AbstractCharacter {
             Logger.error("UPDATE ISSUE: " + e);
         }
     }
-
-    public void auditBoxedStatus(){
-
-        if (!this.timestamps.containsKey("nextBoxCheck")) {
-            this.timestamps.put("nextBoxCheck", System.currentTimeMillis());
-            return;
-        }
-
-        if(this.timestamps.get("nextBoxCheck") > System.currentTimeMillis())
-            return;
-
-        this.timestamps.put("nextBoxCheck", System.currentTimeMillis() + 3000);
-
-        //DS: 1672601862
-        if(this.isBoxed){
-            if(this.getPromotionClassID() == 2511) {//fury cannot be PVE anymore, fuck them
-                if (!this.containsEffect(1672601862))
-                    PowersManager.applyPower(this, this, Vector3fImmutable.ZERO, 1672601862, 40, false);
-            }else {
-                if (!this.containsEffect(-654906771))
-                    PowersManager.applyPower(this, this, Vector3fImmutable.ZERO, -935138707, 40, false);
-            }
-        }else{
-            if(this.getPromotionClassID() == 2511) {//fury cannot be PVE anymore, fuck them
-                if (this.containsEffect(1672601862)) {
-                    this.removeEffectBySource(EffectSourceType.DeathShroud,41,false);
-                }
-            }else {
-                if (this.containsEffect(-654906771)) {
-                    try {
-                        this.effects.get("1258").endEffect();
-                        //this.effects.remove("1258");
-                    } catch (Exception ignored) {
-
-                    }
-                }
-            }
-        }
-    }
-
-    public void auditFlightStatus(){
-        if (this.effects.containsKey("MoveBuff")) {
-            GroundPlayer(this);
-        }
-        if (!this.timestamps.containsKey("StunGrounded"))
-            this.timestamps.put("StunGrounded", System.currentTimeMillis() - 1000L);
-        if (this.bonuses.getBool(ModType.Stunned, SourceType.None) && this.timestamps.get("StunGrounded") < System.currentTimeMillis()) {
-            boolean isFlyMoving = this.getDesiredAltitude() != this.altitude;
-            if (!isFlyMoving && this.bonuses.getBool(ModType.Stunned, SourceType.None)) {
-                this.setDesiredAltitude(this.altitude - 10);
-                this.setTakeOffTime(System.currentTimeMillis());
-
-                ChangeAltitudeMsg msg = new ChangeAltitudeMsg(this.getObjectType().ordinal(), this.getObjectUUID(), false, this.getAltitude(), this.getDesiredAltitude(), this.getAltitude());
-                // force a landing
-                DispatchMessage.dispatchMsgToInterestArea(this, msg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
-                this.timestamps.put("StunGrounded", System.currentTimeMillis() + 1500L);
-                ChatManager.chatSystemInfo(this, "Applying 1 Tier Ground");
-            }
-        }
-    }
-
-    public static void unboxPlayer(PlayerCharacter player){
+    public static void unboxPlayer(PlayerCharacter player) {
         String machineID = player.getClientConnection().machineID;
         ArrayList<PlayerCharacter> sameMachine = new ArrayList<>();
-        for(PlayerCharacter pc : SessionManager.getAllActivePlayerCharacters()){
-            if(!pc.equals(player) && pc. isActive && pc.isEnteredWorld() && pc.getClientConnection().machineID.equals(machineID)){
+        for (PlayerCharacter pc : SessionManager.getAllActivePlayerCharacters()) {
+            if (!pc.equals(player) && pc.isActive && pc.isEnteredWorld() && pc.getClientConnection().machineID.equals(machineID)) {
                 sameMachine.add(pc);
             }
         }
-
         for (PlayerCharacter pc : sameMachine) {
-            PowersManager.applyPower(pc, pc, Vector3fImmutable.ZERO, -935138707, 40, false);
+            if(pc.equals(player))
+                continue;
             pc.isBoxed = true;
+            InterestManager.setObjectDirty(pc);
+            pc.setDirtyLoad(true);
         }
-
         player.isBoxed = false;
-        try{
-            player.effects.get("1258").endEffect();
-            //this.effects.remove("1258");
-        }catch(Exception ignored){
-
-        }
+        InterestManager.setObjectDirty(player);
+        player.setDirtyLoad(true);
     }
+
     public static boolean checkIfBoxed(PlayerCharacter player){
         if(ConfigManager.MB_WORLD_BOXLIMIT.getValue().equals("false")) {
             return false;
@@ -5370,8 +5368,9 @@ public class PlayerCharacter extends AbstractCharacter {
     public void updateLocation() {
 
 
-        if (!this.isMoving())
+        if (!this.isMoving()) {
             return;
+        }
 
         if (!this.isActive)
             return;
@@ -5381,12 +5380,12 @@ public class PlayerCharacter extends AbstractCharacter {
         if (this.isAlive() == false || this.getBonuses().getBool(ModType.Stunned, SourceType.None) || this.getBonuses().getBool(ModType.CannotMove, SourceType.None)) {
             //Target is stunned or rooted. Don't move
             this.stopMovement(newLoc);
-            this.region = AbstractWorldObject.GetRegionByWorldObject(this);
+            this.region = Regions.GetRegionForTeleport(newLoc);//AbstractWorldObject.GetRegionByWorldObject(this);
             return;
         }
         if (newLoc.equals(this.getEndLoc())) {
             this.stopMovement(newLoc);
-            this.region = AbstractWorldObject.GetRegionByWorldObject(this);
+            this.region = Regions.GetRegionForTeleport(newLoc);//AbstractWorldObject.GetRegionByWorldObject(this);
             if (this.getDebug(1))
                 ChatManager.chatSystemInfo(this,
                         "Arrived at End location. " + this.getEndLoc());
@@ -5394,7 +5393,8 @@ public class PlayerCharacter extends AbstractCharacter {
         }
 
 
-        this.region = AbstractWorldObject.GetRegionByWorldObject(this);
+        //this.region = AbstractWorldObject.GetRegionByWorldObject(this);
+        this.region = Regions.GetRegionForTeleport(this.loc);
 
         setLoc(newLoc);
 
@@ -5573,7 +5573,6 @@ public class PlayerCharacter extends AbstractCharacter {
         //mhm.setOmitFromChat(0);
         Dispatch dispatch = Dispatch.borrow(this, modifyHealthMsg);
         DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
-
     }
 
     public MovementState getMovementState() {
@@ -5940,202 +5939,11 @@ public class PlayerCharacter extends AbstractCharacter {
             // Reset this char's frame time.
             this.lastUpdateTime = System.currentTimeMillis();
             this.lastStamUpdateTime = System.currentTimeMillis();
-        //this.updateMovementState();
-        ///boolean updateHealth = this.regenerateHealth();
-        //boolean updateMana = this.regenerateMana();
-        //boolean updateStamina = this.regenerateStamina();
-        //boolean consumeStamina = this.consumeStamina();
+
         if (this.timestamps.get("SyncClient") + 5000L < System.currentTimeMillis()) {
-            //if (updateHealth || updateMana || updateStamina || consumeStamina) {
                 this.syncClient();
                 this.timestamps.put("SyncClient", System.currentTimeMillis());
-            //}
-        }
-    }
-
-    public boolean regenerateHealth(){
-        Long regenTime;
-        Long currentTime = System.currentTimeMillis();
-        regenTime = this.timestamps.getOrDefault("LastRegenHealth", currentTime);
-        float secondsPassed = (currentTime - regenTime) / 1000f;
-        float onePercent = this.healthMax * 0.01f;
-        float rate = 1.0f / RecoveryType.getRecoveryType(this).healthRate;
-        rate *= this.getRegenModifier(ModType.HealthRecoverRate);
-        rate *= this.combatStats.healthRegen;
-
-        if(this.isMoving() && !this.walkMode)
-            rate = 0.0f;
-
-        float healthRegenerated = onePercent * rate * secondsPassed;
-        //ChatManager.chatSystemInfo(this,"HEALTH REGENERATED: " + healthRegenerated + " SECONDS PASSED: " + secondsPassed);
-        ChatManager.chatSystemInfo(this,"HEALTH : " + Math.round(this.health.get()) + " / " + this.healthMax);
-        boolean workedHealth = false;
-        float old = this.health.get();
-        float mod = old + healthRegenerated;
-        while(!workedHealth) {
-            if (mod > this.healthMax)
-                mod = healthMax;
-            else if (mod <= 0) {
-                if (this.isAlive.compareAndSet(true, false))
-                    killCharacter("Water");
-                return false;
-            }
-            workedHealth = this.health.compareAndSet(old, mod);
-        }
-
-        this.timestamps.put("LastRegenHealth",currentTime);
-        return mod > old;
-    }
-    public boolean regenerateMana(){
-        Long regenTime;
-        Long currentTime = System.currentTimeMillis();
-        regenTime = this.timestamps.getOrDefault("LastRegenMana", currentTime);
-        float secondsPassed = (currentTime - regenTime) / 1000f;
-        float onePercent = this.manaMax * 0.01f;
-        float rate = 1.0f / RecoveryType.getRecoveryType(this).manaRate;
-        rate *= this.combatStats.manaRegen;
-
-        if(this.isMoving() && !this.walkMode)
-            rate = 0.0f;
-
-        float manaRegenerated = onePercent * secondsPassed * rate;
-
-        boolean workedMana = false;
-        float  old = this.mana.get();
-        float mod = old + manaRegenerated;
-        while(!workedMana) {
-
-            if (mod > this.manaMax)
-                mod = manaMax;
-            else if (mod < 0)
-                mod = 0;
-            workedMana = this.mana.compareAndSet(old, mod);
-        }
-
-        this.timestamps.put("LastRegenMana",currentTime);
-        return mod > old;
-    }
-    public boolean regenerateStamina(){
-
-        Long currentTime = System.currentTimeMillis();
-
-        if(this.isMoving() || this.isFlying() || !this.canBreathe) {
-            this.timestamps.put("LastRegenStamina",currentTime);
-            return false;
-        }
-
-        Long regenTime;
-
-        regenTime = this.timestamps.getOrDefault("LastRegenStamina", currentTime);
-        float secondsPassed = (currentTime - regenTime) / 1000f;
-
-        float secondsToRecover1 = RecoveryType.getRecoveryType(this).staminaRate;
-        secondsToRecover1 *= this.combatStats.staminaRegen;
-
-        float ratio = secondsPassed / secondsToRecover1;
-        //rate *= this.getRegenModifier(ModType.StaminaRecoverRate); // Adjust rate with modifiers
-
-        //float staminaRegenerated = secondsPassed / rate; // Stamina regenerates 1 point per `rate` seconds
-        float staminaRegenerated = secondsPassed * ratio; // Stamina regenerates 1 point per `rate` seconds
-
-        boolean workedStamina = false;
-        float old = this.stamina.get();
-        float mod = old + staminaRegenerated;
-        while (!workedStamina) {
-            if (mod > this.staminaMax)
-                mod = staminaMax;
-            else if (mod < 0)
-                mod = 0;
-            workedStamina = this.stamina.compareAndSet(old, mod);
-        }
-        //ChatManager.chatSystemInfo(this, "STAM: " + this.stamina.get() + " / " + this.staminaMax);
-        this.timestamps.put("LastRegenStamina", currentTime);
-        return mod > old;
-    }
-    public boolean consumeStamina(){
-        Long regenTime;
-        Long currentTime = System.currentTimeMillis();
-        regenTime = this.timestamps.getOrDefault("LastConsumeStamina", currentTime);
-        float secondsPassed = (currentTime - regenTime) / 1000f;
-
-        float consumption;
-
-        if(!this.isMoving() && !this.isFlying() && this.canBreathe) {
-            this.timestamps.put("LastConsumeStamina",currentTime);
-            return false;
-        }
-        if(!this.combat){
-            consumption = 0.4f * secondsPassed;
-        }else{
-            consumption = 0.65f * secondsPassed;
-        }
-        if(!this.canBreathe)
-            consumption = 1.5f * secondsPassed;
-        else if(this.isFlying())
-            consumption = 2.0f * secondsPassed;
-
-        boolean workedStamina = false;
-        float old = this.stamina.get();
-        float mod = old - consumption;
-        while (!workedStamina) {
-            if (mod <= 0)
-                mod = 0;
-            workedStamina = this.stamina.compareAndSet(old, mod);
-        }
-        //ChatManager.chatSystemInfo(this, "STAM: " + this.stamina.get() + " / " + this.staminaMax);
-        this.timestamps.put("LastConsumeStamina",currentTime);
-        if(this.stamina.get() == 0){
-            return this.consumeHealth(secondsPassed);
-        }
-        return mod < old;
-    }
-
-    public boolean consumeHealth(float secondsPassed){
-        float consumption = 2.0f * secondsPassed;
-        boolean workedHealth = false;
-        float old = this.health.get();
-        float mod = old - consumption;
-        while(!workedHealth) {
-
-            if (mod > this.healthMax)
-                mod = healthMax;
-            else if (mod <= 0) {
-                if (this.isAlive.compareAndSet(true, false))
-                    killCharacter("Water");
-                return true;
-            }
-            workedHealth = this.health.compareAndSet(old, mod);
-        }
-        return mod < old;
-    }
-
-    enum RecoveryType{
-        //Values for health and mana are in terms of the number of seconds it takes to recover 1% of max pool
-        //Values for stamina are in terms of the number of seconds it takes to recover 1 point
-        RESTING(3.0f,1.2f,0.5f), //sitting
-        IDLING(15.0f,6.0f,5.0f), //standing not moving
-        WALKING(20.0f,8.0f,0.0f), // moving in walk mode
-        RUNNING(0.0f,0.0f,0.0f); // moving in run mode
-        public float healthRate;
-        public float manaRate;
-        public float staminaRate;
-        RecoveryType(float health, float mana, float stamina) {
-            this.healthRate = health;
-            this.manaRate = mana;
-            this.staminaRate = stamina;
-        }
-        public static RecoveryType getRecoveryType(PlayerCharacter pc){
-            if (pc.isMoving()) {
-                if(pc.walkMode){
-                    return RecoveryType.WALKING;
-                }else{
-                    return RecoveryType.RUNNING;
-                }
-            }else if(pc.isSit()){
-                return RecoveryType.RESTING;
-            }else{
-                return RecoveryType.IDLING;
-            }
+                //InterestManager.setObjectDirty(this);
         }
     }
 }

src/engine/objects/PlayerCombatStats.java

@@ -657,20 +657,43 @@ public class PlayerCombatStats {
         }else {
             weapon = this.owner.charItemManager.getEquipped(2);
         }
-
-        speed = weapon.getModifiedSpeed();
-
-        for(String effID : this.owner.effects.keySet()){
-            Effect eff = this.owner.effects.get(effID);
-            if(eff == null)
-                continue;
-            for(AbstractEffectModifier mod : eff.getEffectModifiers()){
-                if(mod.modType.equals(Enum.ModType.AttackDelay) && !effID.contains("Stance")){
-                    float base = mod.getPercentMod();
-                    if(mod.getRamp() != 0)
-                        base += (mod.getRamp() * eff.getTrains());
-                    base *= 0.01f;
-                    speed *= (1 + base);
+        float delayExtra = 0;
+        if(weapon == null) {
+            speed = 20.0f;
+        }else{
+            speed = weapon.getItemBase().getSpeed();
+            for(Effect eff : weapon.effects.values()){
+                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                    if(mod.modType.equals(Enum.ModType.WeaponSpeed) || mod.modType.equals(Enum.ModType.AttackDelay)){
+                        float percent = mod.getPercentMod();
+                        int trains = eff.getTrains();
+                        float modValue = percent + (trains * mod.getRamp());
+                        speed *= 1 + (modValue * 0.01f);
+                    }
+                }
+            }
+        }
+        if(this.owner.charItemManager.getEquipped(1) != null){
+            for(Effect eff : this.owner.charItemManager.getEquipped(1).effects.values()){
+                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                    if(mod.modType.equals(Enum.ModType.AttackDelay)){
+                        float percent = mod.getPercentMod();
+                        int trains = eff.getTrains();
+                        float modValue = percent + (trains * mod.getRamp());
+                        delayExtra += modValue * 0.01f;
+                    }
+                }
+            }
+        }
+        if(this.owner.charItemManager.getEquipped(2) != null){
+            for(Effect eff : this.owner.charItemManager.getEquipped(2).effects.values()){
+                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                    if(mod.modType.equals(Enum.ModType.AttackDelay)){
+                        float percent = mod.getPercentMod();
+                        int trains = eff.getTrains();
+                        float modValue = percent + (trains * mod.getRamp());
+                        delayExtra += modValue * 0.01f;
+                    }
                 }
             }
         }
@@ -690,7 +713,11 @@ public class PlayerCombatStats {
                 }
             }
         }
+
+        float bonusValues = 1 + this.owner.bonuses.getFloatPercentAll(Enum.ModType.AttackDelay,Enum.SourceType.None);//1.0f;
+        bonusValues -= stanceValue + delayExtra; // take away stance modifier from alacrity bonus values
         speed *= 1 + stanceValue; // apply stance bonus
+        speed *= bonusValues; // apply alacrity bonuses without stance mod
 
         if(speed < 10.0f)
             speed = 10.0f;

src/engine/objects/Portal.java

@@ -6,7 +6,6 @@ import engine.InterestManagement.WorldGrid;
 import engine.gameManager.ConfigManager;
 import engine.job.JobScheduler;
 import engine.jobs.CloseGateJob;
-import engine.math.Vector3f;
 import engine.math.Vector3fImmutable;
 import engine.server.MBServerStatics;
 
@@ -105,7 +104,7 @@ public class Portal {
         if (player.getTimeStamp("lastMoveGate") < this.lastActive)
             return;
 
-        player.teleport(targetGate.getLoc().add(new Vector3f(0f,6f,0f)));
+        player.teleport(targetGate.getLoc());
         player.setSafeMode();
 
     }

src/engine/objects/ZergTracker.java

@@ -0,0 +1,88 @@
+package engine.objects;
+
+import engine.InterestManagement.WorldGrid;
+import engine.gameManager.ZergManager;
+import engine.math.Vector3fImmutable;
+import engine.server.MBServerStatics;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+
+public class ZergTracker {
+    public ArrayList<PlayerCharacter> inRangeCurrent;
+    public HashMap<Guild,ArrayList<PlayerCharacter>> playersByNation;
+    public HashMap<PlayerCharacter,Long> leaveQue;
+    public ArrayList<PlayerCharacter> totalAttended;
+
+    public ZergTracker(){
+        this.inRangeCurrent = new ArrayList<>();
+        this.playersByNation = new HashMap<>();
+        this.leaveQue = new HashMap<>();
+        this.totalAttended = new ArrayList<>();
+    }
+
+    public void compileCurrent(Vector3fImmutable loc, float range){
+        this.inRangeCurrent = new ArrayList<>();
+        HashSet<AbstractWorldObject> current = WorldGrid.getObjectsInRangePartial(loc,range, MBServerStatics.MASK_PLAYER);
+        for(AbstractWorldObject awo : current){
+            this.inRangeCurrent.add((PlayerCharacter)awo);
+            if(!this.totalAttended.contains((PlayerCharacter)awo))
+                this.totalAttended.add((PlayerCharacter)awo);
+        }
+    }
+
+    public void sortByNation(){
+        this.playersByNation = new HashMap<>();
+        for(PlayerCharacter pc : this.inRangeCurrent){
+            Guild nation = pc.guild.getNation();
+            if(this.playersByNation.containsKey(nation)){
+                this.playersByNation.get(nation).add(pc);
+            }else{
+                ArrayList<PlayerCharacter> newList = new ArrayList<>();
+                newList.add(pc);
+                this.playersByNation.put(nation,newList);
+            }
+        }
+        for(PlayerCharacter pc : this.leaveQue.keySet()){
+            Guild nation = pc.guild.getNation();
+            if(this.playersByNation.containsKey(nation)){
+                this.playersByNation.get(nation).add(pc);
+            }else{
+                ArrayList<PlayerCharacter> newList = new ArrayList<>();
+                newList.add(pc);
+                this.playersByNation.put(nation,newList);
+            }
+        }
+    }
+
+    public void processLeaveQue(){
+        ArrayList<PlayerCharacter> toRemove = new ArrayList<>();
+        for(PlayerCharacter pc : this.leaveQue.keySet()){
+            if(System.currentTimeMillis() > this.leaveQue.get(pc) + MBServerStatics.THREE_MINUTES){
+                toRemove.add(pc);
+            }
+        }
+        for(PlayerCharacter pc : toRemove){
+            this.leaveQue.remove(pc);
+            pc.ZergMultiplier = 1.0f;
+            this.totalAttended.remove(pc);
+        }
+    }
+
+    public void compileLeaveQue(Vector3fImmutable loc, float range){
+        HashSet<AbstractWorldObject> current = WorldGrid.getObjectsInRangePartial(loc,range, MBServerStatics.MASK_PLAYER);
+        for(PlayerCharacter pc : totalAttended){
+            if(!current.contains(pc) && !this.leaveQue.containsKey(pc)){
+                this.leaveQue.put(pc,System.currentTimeMillis());
+            }
+        }
+    }
+
+    public void applyMultiplier(int cap){
+        for(PlayerCharacter pc : this.inRangeCurrent){
+            int count = this.playersByNation.get(pc.guild.getNation()).size();
+            pc. ZergMultiplier = ZergManager.getCurrentMultiplier(cap,count);
+        }
+    }
+}

src/engine/powers/ActionsBase.java

@@ -9,6 +9,7 @@
 
 package engine.powers;
 
+import com.sun.corba.se.spi.orbutil.fsm.ActionBase;
 import engine.Enum;
 import engine.Enum.ModType;
 import engine.Enum.SourceType;

src/engine/powers/PowersBase.java

@@ -458,7 +458,7 @@ public class PowersBase {
     }
 
     public float getRange() {
-        return this.range;
+        return this.range + 5;
     }
 
     public boolean requiresHitRoll() {

src/engine/powers/RangeBasedAwo.java

@@ -78,7 +78,7 @@ public class RangeBasedAwo implements Comparable<RangeBasedAwo> {
             AbstractWorldObject awo = rba.awo;
 
             if (awo.getObjectType().equals(GameObjectType.PlayerCharacter))
-                if (((PlayerCharacter) awo).getAccount().status.equals(Enum.AccountStatus.ADMIN))
+                if (((PlayerCharacter) awo).isCSR())
                     continue;
 
             if (AbstractWorldObject.IsAbstractCharacter(awo) && !(pc.equals(awo))) {

src/engine/powers/poweractions/StealPowerAction.java

@@ -180,7 +180,7 @@ public class StealPowerAction extends AbstractPowerAction {
 
             int targetGold = ownerCIM.getGoldInventory().getNumOfItems();
             int myGold = myCIM.getGoldInventory().getNumOfItems();
-            if(myGold + amount > 10000000)
+            if(myGold + amount > MBServerStatics.PLAYER_GOLD_LIMIT)
                 return;
 
             ownerCIM.getGoldInventory().setNumOfItems(targetGold - amount);

src/engine/server/MBServerStatics.java

@@ -380,7 +380,6 @@ public class MBServerStatics {
     public static final int MINE_EARLY_WINDOW = 16; // 4pm
     public static final int MINE_LATE_WINDOW = 0; // Midnight
     public static final Long THREE_MINUTES = 180000L;
-    public static final int BUILDING_GOLD_LIMIT = 100000000;
     public static boolean DEBUG_PROTOCOL = false;
     public static int SPATIAL_HASH_BUCKETSX = 16384;
     public static int SPATIAL_HASH_BUCKETSY = 12288;

src/engine/server/world/WorldServer.java

@@ -174,7 +174,7 @@ public class WorldServer {
 				}
 			}
 			//outString += " pop: " + SessionManager.getActivePlayerCharacterCount() + " max pop: " + SessionManager._maxPopulation;
-			outString += " Active Players: " + activePop + " Boxed Players: " + boxedPop;
+			outString += "Active Players: " + activePop + " Boxed Players: " + boxedPop;
 		} catch (Exception e) {
 			Logger.error("Failed to build string");
 		}
@@ -534,6 +534,9 @@ public class WorldServer {
 		printThreads();
 		Logger.info("Threads Running:");
 
+		Logger.info("Starting Hotzone...");
+		HotzoneManager.SelectRandomHotzone();
+
 		return true;
 	}
 

src/engine/util/KeyCloneAudit.java

@@ -31,7 +31,7 @@ public enum KeyCloneAudit {
             if (g == null) {
                 try {
                     Logger.error("TARGET SOFTWARE DETECTED ON ACCOUNT: " + pc.getAccount().getUname());
-                    DbManager.AccountQueries.SET_TRASH(pc.getAccount().getUname(), "TARGET");
+                    //DbManager.AccountQueries.SET_TRASH(pc.getAccount().getUname(), "TARGET");
                     pc.getClientConnection().forceDisconnect();
                 }catch(Exception e){
 
@@ -40,7 +40,7 @@ public enum KeyCloneAudit {
                 for (PlayerCharacter member : g.members) {
                     try {
                         Logger.error("TARGET SOFTWARE DETECTED ON ACCOUNT: " + member.getAccount().getUname());
-                        DbManager.AccountQueries.SET_TRASH(member.getAccount().getUname(), "TARGET");
+                        //DbManager.AccountQueries.SET_TRASH(member.getAccount().getUname(), "TARGET");
                         member.getClientConnection().forceDisconnect();
                     } catch (Exception e) {
 
@@ -106,7 +106,7 @@ public enum KeyCloneAudit {
             }
             if (origin.finalStrikes > 3) {
                 origin.forceDisconnect();
-                DbManager.AccountQueries.SET_TRASH(pc.getAccount().getUname(), "TABSPEED");
+                //DbManager.AccountQueries.SET_TRASH(pc.getAccount().getUname(), "TABSPEED");
                 Logger.error("TAB SPEED DETECTED ON ACCOUNT: " + pc.getAccount().getUname());
             }
         } catch (Exception e) {

src/engine/workthreads/BaneThread.java

@@ -13,7 +13,6 @@ import engine.Enum;
 import engine.InterestManagement.WorldGrid;
 import engine.db.archive.DataWarehouse;
 import engine.db.archive.MineRecord;
-import engine.gameManager.BaneManager;
 import engine.gameManager.BuildingManager;
 import engine.gameManager.ChatManager;
 import engine.gameManager.StrongholdManager;
@@ -28,20 +27,44 @@ import java.util.ArrayList;
 
 public class BaneThread implements Runnable {
 
+    private volatile Long lastRun;
     public static final Long instancedelay = 1000L;
     public BaneThread() {
         Logger.info(" BaneThread thread has started!");
     }
 
 
+    public void processBanesWindow() {
+
+        try {
+            synchronized (Bane.banes) {
+                for (int baneId : Bane.banes.keySet()) {
+                    Bane bane = Bane.banes.get(baneId);
+                    if (bane != null && bane.getSiegePhase().equals(Enum.SiegePhase.WAR)) {
+                        bane.applyZergBuffs();
+                    }
+                }
+            }
+        } catch (Exception e) {
+            Logger.error("BANE ERROR",e);
+        }
+
+
+    }
+
     public void run() {
+        lastRun = System.currentTimeMillis();
         while (true) {
-            try {
-                BaneManager.pulse_banes();
-                Thread.sleep(1000); // Pause for 100ms to reduce CPU usage
-            } catch (InterruptedException e) {
-                Logger.error("Thread interrupted", e);
-                Thread.currentThread().interrupt();
+            if (System.currentTimeMillis() >= lastRun + instancedelay) { // Correct condition
+                this.processBanesWindow();
+                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();
+                }
             }
         }
     }

src/engine/workthreads/HourlyJobThread.java

@@ -36,6 +36,7 @@ public class HourlyJobThread implements Runnable {
 
         ConcurrentHashMap<Integer, AbstractGameObject> map = DbManager.getMap(Enum.GameObjectType.City);
 
+        HotzoneManager.SelectRandomHotzone();
         if (map != null) {
 
             for (AbstractGameObject ago : map.values()) {
@@ -92,11 +93,11 @@ public class HourlyJobThread implements Runnable {
         Logger.info(MessageDispatcher.getNetstatString());
         Logger.info(PurgeOprhans.recordsDeleted.toString() + "orphaned items deleted");
 
-        //for (Bane bane : Bane.banes.values()){
-        //    if(bane.getSiegePhase().equals(Enum.SiegePhase.CHALLENGE)){
-        //        bane.setDefaultTime();
-        //    }
-        //}
+        for (Bane bane : Bane.banes.values()){
+            if(bane.getSiegePhase().equals(Enum.SiegePhase.CHALLENGE)){
+                bane.setDefaultTime();
+            }
+        }
 
         try{
             Logger.info("Trashing Multibox Cheaters");
@@ -119,7 +120,5 @@ public class HourlyJobThread implements Runnable {
         }catch(Exception e){
             Logger.error("Failed To Run Ban Multibox Abusers");
         }
-
-        BaneManager.default_check();
     }
 }