city null pointer check

This reverts commit cd1e38b184.

src/engine/Dungeons/Dungeon.java

@@ -0,0 +1,150 @@
+package engine.Dungeons;
+
+import engine.Enum;
+import engine.InterestManagement.WorldGrid;
+import engine.gameManager.BuildingManager;
+import engine.gameManager.PowersManager;
+import engine.gameManager.ZoneManager;
+import engine.math.Vector3fImmutable;
+import engine.net.ByteBufferWriter;
+import engine.objects.*;
+import engine.powers.EffectsBase;
+import engine.server.MBServerStatics;
+import org.pmw.tinylog.Logger;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.HashSet;
+
+public class Dungeon {
+
+    public static int NoFlyEffectID = -1733819072;
+    public static int NoTeleportEffectID = -1971545187;
+    public static int NoSummonEffectID = 2122002462;
+    public ArrayList<PlayerCharacter> participants;
+    public int maxPerGuild;
+    public Vector3fImmutable entrance;
+    public ArrayList<Mob> dungeon_mobs;
+    public Long respawnTime = 0L;
+
+    public Dungeon(Vector3fImmutable entrance, int maxCount){
+        this.participants = new ArrayList<>();
+        this.entrance = entrance;
+        this.dungeon_mobs = new ArrayList<>();
+        this.maxPerGuild = maxCount;
+    }
+    public void applyDungeonEffects(PlayerCharacter player){
+        EffectsBase noFly = PowersManager.getEffectByToken(NoFlyEffectID);
+        EffectsBase noTele = PowersManager.getEffectByToken(NoTeleportEffectID);
+        EffectsBase noSum = PowersManager.getEffectByToken(NoSummonEffectID);
+
+        if(noFly != null)
+            player.addEffectNoTimer(noFly.getName(),noFly,40,true);
+
+        if(noTele != null)
+            player.addEffectNoTimer(noTele.getName(),noTele,40,true);
+
+        if(noSum != null)
+            player.addEffectNoTimer(noSum.getName(),noSum,40,true);
+    }
+
+    public void removeDungeonEffects(PlayerCharacter player) {
+        EffectsBase noFly = PowersManager.getEffectByToken(NoFlyEffectID);
+        EffectsBase noTele = PowersManager.getEffectByToken(NoTeleportEffectID);
+        EffectsBase noSum = PowersManager.getEffectByToken(NoSummonEffectID);
+        for (Effect eff : player.effects.values()) {
+            if (noFly != null && eff.getEffectsBase().equals(noFly))
+                eff.endEffect();
+
+            if (noTele != null && eff.getEffectsBase().equals(noTele))
+                eff.endEffect();
+
+            if (noSum != null && eff.getEffectsBase().equals(noSum))
+                eff.endEffect();
+        }
+    }
+
+    public static void serializeForClientMsgTeleport(ByteBufferWriter writer) {
+        Guild rulingGuild = Guild.getErrantGuild();
+        Guild rulingNation = Guild.getErrantGuild();
+
+        Zone zone = ZoneManager.getZoneByUUID(994);
+        // Begin Serialzing soverign guild data
+        writer.putInt(Enum.GameObjectType.Zone.ordinal());
+        writer.putInt(994);
+        writer.putString("Whitehorn Citadel");
+        writer.putInt(rulingGuild.getObjectType().ordinal());
+        writer.putInt(rulingGuild.getObjectUUID());
+
+        writer.putString("Whitehorn Militants"); // guild name
+        writer.putString("In the Citadel, We Fight!"); // motto
+        writer.putString(rulingGuild.getLeadershipType());
+
+        // Serialize guild ruler's name
+        // If tree is abandoned blank out the name
+        // to allow them a rename.
+
+        writer.putString("Kol'roth The Destroyer");//sovreign
+
+        writer.putInt(rulingGuild.getCharter());
+        writer.putInt(0); // always 00000000
+
+        writer.put((byte)0);
+
+        writer.put((byte) 1);
+        writer.put((byte) 1);  // *** Refactor: What are these flags?
+        writer.put((byte) 1);
+        writer.put((byte) 1);
+        writer.put((byte) 1);
+
+        GuildTag._serializeForDisplay(rulingGuild.getGuildTag(), writer);
+        GuildTag._serializeForDisplay(rulingNation.getGuildTag(), writer);
+
+        writer.putInt(0);// TODO Implement description text
+
+        writer.put((byte) 1);
+        writer.put((byte) 0);
+        writer.put((byte) 1);
+
+        // Begin serializing nation guild info
+
+        if (rulingNation.isEmptyGuild()) {
+            writer.putInt(rulingGuild.getObjectType().ordinal());
+            writer.putInt(rulingGuild.getObjectUUID());
+        } else {
+            writer.putInt(rulingNation.getObjectType().ordinal());
+            writer.putInt(rulingNation.getObjectUUID());
+        }
+
+
+        // Serialize nation name
+
+        writer.putString("Whitehorn Militants"); //nation name
+
+        writer.putInt(-1);//city rank, -1 puts it at top of list always
+
+        writer.putInt(0xFFFFFFFF);
+
+        writer.putInt(0);
+
+        writer.putString("Kol'roth The Destroyer");//nation ruler
+
+        writer.putLocalDateTime(LocalDateTime.now());
+
+        //location
+        Vector3fImmutable loc = Vector3fImmutable.getRandomPointOnCircle(BuildingManager.getBuilding(2827951).loc,30f);
+
+        writer.putFloat(loc.x);
+        writer.putFloat(loc.y);
+        writer.putFloat(loc.z);
+
+        writer.putInt(0);
+
+        writer.put((byte) 1);
+        writer.put((byte) 0);
+        writer.putInt(0x64);
+        writer.put((byte) 0);
+        writer.put((byte) 0);
+        writer.put((byte) 0);
+    }
+}

src/engine/Dungeons/DungeonManager.java

@@ -0,0 +1,105 @@
+package engine.Dungeons;
+
+import engine.Enum;
+import engine.InterestManagement.WorldGrid;
+import engine.gameManager.DbManager;
+import engine.gameManager.ZoneManager;
+import engine.math.Vector3fImmutable;
+import engine.objects.*;
+import engine.powers.EffectsBase;
+import engine.server.MBServerStatics;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+public class DungeonManager {
+    public static ArrayList<Dungeon> dungeons;
+
+    private static final float dungeonAiRange = 64f;
+    private static final float maxTravel = 64f;
+
+    public static void joinDungeon(PlayerCharacter pc, Dungeon dungeon){
+        if(requestEnter(pc,dungeon)) {
+            dungeon.participants.add(pc);
+            dungeon.applyDungeonEffects(pc);
+            translocateToDungeon(pc, dungeon);
+        }
+    }
+
+    public static void leaveDungeon(PlayerCharacter pc, Dungeon dungeon){
+        dungeon.participants.remove(pc);
+        dungeon.removeDungeonEffects(pc);
+        translocateOutOfDungeon(pc);
+    }
+
+    public static boolean requestEnter(PlayerCharacter pc, Dungeon dungeon){
+        int current = 0;
+        Guild nation = pc.guild.getNation();
+
+        if(nation == null)
+            return false;
+
+        for(PlayerCharacter participant : dungeon.participants){
+            if(participant.guild.getNation().equals(nation)){
+                current ++;
+            }
+        }
+
+        if(current >= dungeon.maxPerGuild)
+            return false;
+
+        return true;
+    }
+
+    public static void translocateToDungeon(PlayerCharacter pc, Dungeon dungeon){
+        pc.teleport(dungeon.entrance);
+        pc.setSafeMode();
+    }
+
+    public static void translocateOutOfDungeon(PlayerCharacter pc){
+        pc.teleport(pc.bindLoc);
+        pc.setSafeMode();
+    }
+
+    public static void pulse_dungeons(){
+        for(Dungeon dungeon : dungeons){
+
+            //early exit, if no players present don't waste resources
+            if(dungeon.participants.isEmpty())
+                continue;
+
+            if(dungeon.respawnTime > 0 && System.currentTimeMillis() > dungeon.respawnTime){
+                respawnMobs(dungeon);
+            }
+
+            //remove any players that have left
+            HashSet<AbstractWorldObject> obj = WorldGrid.getObjectsInRangePartial(dungeon.entrance,4096f,MBServerStatics.MASK_PLAYER);
+            for(PlayerCharacter player : dungeon.participants)
+                if(!obj.contains(player))
+                    leaveDungeon(player,dungeon);
+
+            //cycle dungeon mob AI
+            for(Mob mob : dungeon.dungeon_mobs)
+                dungeonMobAI(mob);
+        }
+    }
+
+    public static void dungeonMobAI(Mob mob){
+
+    }
+
+    public static void respawnMobs(Dungeon dungeon){
+        for(Mob mob : dungeon.dungeon_mobs){
+
+            if(!mob.isAlive() && mob.despawned)
+                mob.respawn();
+
+            if(!mob.isAlive() && !mob.despawned){
+                mob.despawn();
+                mob.respawn();
+            }
+
+        }
+    }
+
+}

src/engine/Enum.java

@@ -9,15 +9,13 @@
 package engine;
 
 import ch.claude_martin.enumbitset.EnumBitSetHelper;
+import engine.gameManager.BuildingManager;
 import engine.gameManager.ConfigManager;
 import engine.gameManager.PowersManager;
 import engine.gameManager.ZoneManager;
 import engine.math.Vector2f;
 import engine.math.Vector3fImmutable;
-import engine.objects.AbstractCharacter;
+import engine.objects.*;
-import engine.objects.ItemBase;
-import engine.objects.Shrine;
-import engine.objects.Zone;
 import engine.powers.EffectsBase;
 import org.pmw.tinylog.Logger;
 
@@ -139,8 +137,8 @@ public class Enum {
         HALFGIANTMALE(2010, MonsterType.HalfGiant, RunSpeed.STANDARD, CharacterSex.MALE, 1.15f),
         HUMANMALE(2011, MonsterType.Human, RunSpeed.STANDARD, CharacterSex.MALE, 1),
         HUMANFEMALE(2012, MonsterType.Human, RunSpeed.STANDARD, CharacterSex.FEMALE, 1),
-        IREKEIMALE(2013, MonsterType.Irekei, RunSpeed.STANDARD, CharacterSex.MALE, 1.1f),
+        IREKEIMALE(2013, MonsterType.Irekei, RunSpeed.IREKEI, CharacterSex.MALE, 1.1f),
-        IREKEIFEMALE(2014, MonsterType.Irekei, RunSpeed.STANDARD, CharacterSex.FEMALE, 1.1f),
+        IREKEIFEMALE(2014, MonsterType.Irekei, RunSpeed.IREKEI, CharacterSex.FEMALE, 1.1f),
         SHADEMALE(2015, MonsterType.Shade, RunSpeed.STANDARD, CharacterSex.MALE, 1),
         SHADEFEMALE(2016, MonsterType.Shade, RunSpeed.STANDARD, CharacterSex.FEMALE, 1),
         MINOMALE(2017, MonsterType.Minotaur, RunSpeed.MINOTAUR, CharacterSex.MALE, 1.3f),
@@ -152,7 +150,8 @@ public class Enum {
         NEPHFEMALE(2026, MonsterType.Nephilim, RunSpeed.STANDARD, CharacterSex.FEMALE, 1.1f),
         HALFGIANTFEMALE(2027, MonsterType.HalfGiant, RunSpeed.STANDARD, CharacterSex.FEMALE, 1.15f),
         VAMPMALE(2028, MonsterType.Vampire, RunSpeed.STANDARD, CharacterSex.MALE, 1),
-        VAMPFEMALE(2029, MonsterType.Vampire, RunSpeed.STANDARD, CharacterSex.FEMALE, 1);
+        VAMPFEMALE(2029, MonsterType.Vampire, RunSpeed.STANDARD, CharacterSex.FEMALE, 1),
+        SAETOR(1999,MonsterType.Minotaur, RunSpeed.MINOTAUR, CharacterSex.MALE,1);
 
         @SuppressWarnings("unchecked")
         private static HashMap<Integer, RaceType> _raceTypeByID = new HashMap<>();
@@ -208,8 +207,8 @@ public class Enum {
         SENTINEL(0, 0, 0, 0, 0, 0, 0),
         STANDARD(6.1900001f, 13.97f, 4.2199998f, 13.97f, 6.3299999f, 18.379999f, 6.5f),
         CENTAUR(6.1900001f, 16.940001f, 5.5500002f, 16.940001f, 6.3299999f, 18.379999f, 6.5f),
-        MINOTAUR(6.6300001f, 15.95f, 4.2199998f, 15.95f, 6.3299999f, 18.379999f, 6.5f);
+        MINOTAUR(6.6300001f, 15.95f, 4.2199998f, 15.95f, 6.3299999f, 18.379999f, 6.5f),
-
+        IREKEI(6.499500105f, 14.6685f, 4.2199998f, 14.6685f, 6.3299999f, 18.379999f, 6.5f);
         private float walkStandard;
         private float walkCombat;
         private float runStandard;
@@ -469,11 +468,14 @@ public class Enum {
 
                 // 14001 does not have a banestone to bind at
 
-                if (ruinZone.getLoadNum() == 14001)
+                if (ruinZone.getLoadNum() == 14001) {
                     spawnLocation = Vector3fImmutable.getRandomPointOnCircle(ruinZone.getLoc(), 30);
-                else
+                }else {
-                    spawnLocation = Vector3fImmutable.getRandomPointOnCircle(ruinZone.getLoc()
+                    //spawnLocation = Vector3fImmutable.getRandomPointOnCircle(ruinZone.getLoc()
-                            .add(new Vector3fImmutable(-196.016f, 2.812f, 203.621f)), 30);
+                    //.add(new Vector3fImmutable(-196.016f, 2.812f, 203.621f)), 30);
+                        spawnLocation = Vector3fImmutable.getRandomPointOnCircle(BuildingManager.getBuilding(27977).loc,30f);
+
+                }
             }
 
 
@@ -776,6 +778,7 @@ public class Enum {
         Combat,
         Spires,
         Snare,
+        Snared,
         Stun,
         Blind,
         Root,
@@ -878,6 +881,7 @@ public class Enum {
         Siege,
         Slash,
         Snare,
+        Snared,
         Sorcery,
         Spear,
         SpearMastery,
@@ -957,6 +961,17 @@ public class Enum {
         Wizardry;
 
         public static SourceType GetSourceType(String modName) {
+            switch(modName){
+                case "Slashing":
+                    modName = "Slash";
+                    break;
+                case "Crushing":
+                    modName = "Crush";
+                    break;
+                case "Piercing":
+                    modName = "Pierce";
+                    break;
+            }
             SourceType returnMod;
             if (modName.isEmpty())
                 return SourceType.None;
@@ -964,8 +979,8 @@ public class Enum {
             try {
                 returnMod = SourceType.valueOf(modName.replace(",", ""));
             } catch (Exception e) {
-                Logger.error(modName);
+                //Logger.error(modName);
-                Logger.error(e);
+                //Logger.error(e);
                 return SourceType.None;
             }
             return returnMod;
@@ -1016,6 +1031,7 @@ public class Enum {
         Silence,
         Slash,
         Snare,
+        Snared,
         Stance,
         Stun,
         Summon,
@@ -1140,6 +1156,7 @@ public class Enum {
         SkillDebuff,
         SlashResistanceDebuff,
         Snare,
+        Snared,
         StackableAttrCONBuff,
         StackableAttrDEXBuff,
         StackableAttrSTRBuff,
@@ -2306,9 +2323,10 @@ public class Enum {
 
     public enum CityBoundsType {
 
-        GRID(640),
+        GRID(544),
-        ZONE(875),
+        ZONE(672),
-        PLACEMENT(876);
+        PLACEMENT(673),
+        SIEGEBOUNDS(1750);
 
         public final float extents;
 

src/engine/InterestManagement/InterestManager.java

@@ -19,10 +19,7 @@ import engine.net.AbstractNetMsg;
 import engine.net.Dispatch;
 import engine.net.DispatchMessage;
 import engine.net.client.ClientConnection;
-import engine.net.client.msg.LoadCharacterMsg;
+import engine.net.client.msg.*;
-import engine.net.client.msg.LoadStructureMsg;
-import engine.net.client.msg.MoveToPointMsg;
-import engine.net.client.msg.UnloadObjectsMsg;
 import engine.objects.*;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
@@ -514,6 +511,18 @@ 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){
+
+        //        }
+        //    }
+        //}
+
+
+
         ClientConnection origin = player.getClientConnection();
 
         if (origin == null)
@@ -521,10 +530,10 @@ public enum InterestManager implements Runnable {
 
         // Update loaded upbjects lists
 
+        player.isBoxed = PlayerCharacter.checkIfBoxed(player);
         player.setDirtyLoad(true);
         updateStaticList(player, origin);
         updateMobileList(player, origin);
-
     }
 
     public synchronized void HandleLoadForTeleport(PlayerCharacter playerCharacter) {

src/engine/ZergMehcanics/MineAntiZerg.java

@@ -0,0 +1,116 @@
+package engine.ZergMehcanics;
+
+import engine.InterestManagement.WorldGrid;
+import engine.gameManager.BuildingManager;
+import engine.gameManager.ZergManager;
+import engine.objects.*;
+import engine.server.MBServerStatics;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+
+public class MineAntiZerg {
+
+    public static HashMap<Mine,HashMap<PlayerCharacter,Long>> leaveTimers = new HashMap<>();
+    public static HashMap<Mine,ArrayList<PlayerCharacter>> currentPlayers = new HashMap<>();
+
+    public static void runMines(){
+        for(Mine mine : Mine.getMines()){
+
+            Building tower = BuildingManager.getBuildingFromCache(mine.getBuildingID());
+
+            if(tower == null)
+                continue;
+
+            if(!mine.isActive)
+                continue;
+
+            logPlayersPresent(tower,mine);
+
+            auditPlayersPresent(tower,mine);
+
+            auditPlayers(mine);
+        }
+    }
+
+    public static void logPlayersPresent(Building tower, Mine mine){
+        HashSet<AbstractWorldObject> loadedPlayers = WorldGrid.getObjectsInRangePartial(tower.loc, MBServerStatics.CHARACTER_LOAD_RANGE * 3,MBServerStatics.MASK_PLAYER);
+
+        ArrayList<PlayerCharacter> playersPresent = new ArrayList<>();
+        for(AbstractWorldObject player : loadedPlayers){
+            playersPresent.add((PlayerCharacter)player);
+        }
+
+        currentPlayers.put(mine,playersPresent);
+    }
+
+    public static void auditPlayersPresent(Building tower, Mine mine){
+        HashSet<AbstractWorldObject> loadedPlayers = WorldGrid.getObjectsInRangePartial(tower.loc, MBServerStatics.CHARACTER_LOAD_RANGE * 3,MBServerStatics.MASK_PLAYER);
+
+        ArrayList<PlayerCharacter> toRemove = new ArrayList<>();
+
+        for(PlayerCharacter player : currentPlayers.get(mine)){
+            if(!loadedPlayers.contains(player)){
+                toRemove.add(player);
+            }
+        }
+
+        currentPlayers.get(mine).removeAll(toRemove);
+
+        for(PlayerCharacter player : toRemove){
+            if(leaveTimers.containsKey(mine)){
+                leaveTimers.get(mine).put(player,System.currentTimeMillis());
+            }else{
+                HashMap<PlayerCharacter,Long> leaveTime = new HashMap<>();
+                leaveTime.put(player,System.currentTimeMillis());
+                leaveTimers.put(mine,leaveTime);
+            }
+        }
+
+        toRemove.clear();
+
+        for(PlayerCharacter player : leaveTimers.get(mine).keySet()){
+            long timeGone = System.currentTimeMillis() - leaveTimers.get(mine).get(player);
+            if(timeGone > 180000L) {//3 minutes
+                toRemove.add(player);
+                player.ZergMultiplier = 1.0f;
+            }
+        }
+
+        for(PlayerCharacter player : toRemove) {
+            leaveTimers.get(mine).remove(player);
+        }
+    }
+
+    public static void auditPlayers(Mine mine){
+
+        HashMap<Guild,ArrayList<PlayerCharacter>> playersByNation = new HashMap<>();
+
+        for(PlayerCharacter player : currentPlayers.get(mine)){
+            if(playersByNation.containsKey(player.guild.getNation())){
+                playersByNation.get(player.guild.getNation()).add(player);
+            }else{
+                ArrayList<PlayerCharacter> players = new ArrayList<>();
+                players.add(player);
+                playersByNation.put(player.guild.getNation(),players);
+            }
+        }
+
+        for(PlayerCharacter player : leaveTimers.get(mine).keySet()){
+            if(playersByNation.containsKey(player.guild.getNation())){
+                playersByNation.get(player.guild.getNation()).add(player);
+            }else{
+                ArrayList<PlayerCharacter> players = new ArrayList<>();
+                players.add(player);
+                playersByNation.put(player.guild.getNation(),players);
+            }
+        }
+
+        for(Guild nation : playersByNation.keySet()){
+            for(PlayerCharacter player : playersByNation.get(nation)){
+                player.ZergMultiplier = ZergManager.getCurrentMultiplier(playersByNation.get(nation).size(), mine.capSize);
+            }
+        }
+    }
+}

src/engine/db/handlers/dbAccountHandler.java

@@ -13,14 +13,13 @@ import engine.Enum;
 import engine.Enum.GameObjectType;
 import engine.gameManager.ConfigManager;
 import engine.gameManager.DbManager;
+import engine.net.DispatchMessage;
+import engine.net.client.msg.chat.ChatSystemMsg;
 import engine.objects.Account;
 import engine.objects.PlayerCharacter;
 import org.pmw.tinylog.Logger;
 
-import java.sql.Connection;
+import java.sql.*;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
 import java.util.ArrayList;
 
 public class dbAccountHandler extends dbHandlerBase {
@@ -77,18 +76,24 @@ public class dbAccountHandler extends dbHandlerBase {
         }
     }
 
-    public void SET_TRASH(String machineID) {
+    public void SET_TRASH(String machineID, String type) {
-
         try (Connection connection = DbManager.getConnection();
-             PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO dyn_trash(`machineID`, `count`)"
+             PreparedStatement preparedStatement = connection.prepareStatement(
-                     + " VALUES (?, 1) ON DUPLICATE KEY UPDATE `count` = `count` + 1;")) {
+                     "INSERT INTO dyn_trash(`machineID`, `count`, `type`)"
+                             + " VALUES (?, 1, ?) ON DUPLICATE KEY UPDATE `count` = `count` + 1;")) {
 
             preparedStatement.setString(1, machineID);
+            preparedStatement.setString(2, type);
             preparedStatement.execute();
 
         } catch (SQLException e) {
             Logger.error(e);
         }
+
+        ChatSystemMsg chatMsg = new ChatSystemMsg(null, "Account: " + machineID + " has been kicked from game for cheating");
+        chatMsg.setMessageType(10);
+        chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+        DispatchMessage.dispatchMsgToAll(chatMsg);
     }
 
     public ArrayList<String> GET_TRASH_LIST() {
@@ -270,4 +275,21 @@ public class dbAccountHandler extends dbHandlerBase {
         }
     }
 
+    public void TRASH_CHEATERS() {
+        try (Connection connection = DbManager.getConnection();
+             CallableStatement callableStatement = connection.prepareCall("{CALL BanAccountsWithMachineID()}")) {
+
+            boolean hasResultSet = callableStatement.execute();
+
+            if (!hasResultSet && callableStatement.getUpdateCount() > 0) {
+                Logger.info("TRASHED CHEATERS");
+            } else {
+                Logger.warn("No cheaters to trash.");
+            }
+
+        } catch (SQLException e) {
+            Logger.error("Error trashing cheaters: ", e);
+        }
+    }
+
 }

src/engine/db/handlers/dbBaneHandler.java

@@ -10,17 +10,13 @@
 package engine.db.handlers;
 
 import engine.gameManager.DbManager;
-import engine.objects.Bane;
+import engine.gameManager.ZoneManager;
-import engine.objects.Building;
+import engine.math.Vector3fImmutable;
-import engine.objects.City;
+import engine.objects.*;
-import engine.objects.PlayerCharacter;
 import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
 
-import java.sql.Connection;
+import java.sql.*;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
 
 public class dbBaneHandler extends dbHandlerBase {
 
@@ -89,6 +85,139 @@ public class dbBaneHandler extends dbHandlerBase {
         return true;
     }
 
+    public boolean SET_BANE_TIME_NEW(int hour, int cityUUID) {
+        hour += 12; // Adjust hour
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement getStatement = connection.prepareStatement("SELECT `placementDate`, `liveDate` FROM `dyn_banes` WHERE `cityUUID`=?");
+             PreparedStatement updateStatement = connection.prepareStatement("UPDATE `dyn_banes` SET `liveDate`=?, `time_set`=? WHERE `cityUUID`=?")) {
+
+            // Retrieve placementDate and liveDate
+            getStatement.setInt(1, cityUUID);
+            try (ResultSet rs = getStatement.executeQuery()) {
+                if (rs.next()) {
+                    DateTime placementDate = new DateTime(rs.getTimestamp("placementDate").getTime());
+                    Timestamp liveDateTimestamp = rs.getTimestamp("liveDate");
+
+                    // Explicitly check if liveDate is null
+                    DateTime toSet;
+                    if (liveDateTimestamp == null) {
+                        // If liveDate is null, default to placementDate
+                        toSet = placementDate;
+                    } else {
+                        // If liveDate is not null, use it
+                        DateTime liveDate = new DateTime(liveDateTimestamp.getTime());
+                        toSet = liveDate;
+                    }
+
+                    // Adjust the time
+                    toSet = toSet.withHourOfDay(hour).withMinuteOfHour(0).withSecondOfMinute(0).withMillisOfSecond(0);
+
+                    // Update liveDate and time_set flag
+                    updateStatement.setTimestamp(1, new java.sql.Timestamp(toSet.getMillis()));
+                    updateStatement.setInt(2, 1); // time_set flag
+                    updateStatement.setInt(3, cityUUID);
+
+                    updateStatement.execute();
+                    return true;
+                }
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean SET_BANE_DAY_NEW(int dayOffset, int cityUUID) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement getStatement = connection.prepareStatement("SELECT `placementDate`, `liveDate` FROM `dyn_banes` WHERE `cityUUID`=?");
+             PreparedStatement updateStatement = connection.prepareStatement("UPDATE `dyn_banes` SET `liveDate`=?, `day_set`=? WHERE `cityUUID`=?")) {
+
+            // Retrieve placementDate and liveDate
+            getStatement.setInt(1, cityUUID);
+            try (ResultSet rs = getStatement.executeQuery()) {
+                if (rs.next()) {
+                    DateTime placementDate = new DateTime(rs.getTimestamp("placementDate").getTime());
+                    Timestamp liveDateTimestamp = rs.getTimestamp("liveDate");
+
+                    // Explicitly check if liveDate is null
+                    DateTime liveDate;
+                    if (liveDateTimestamp == null) {
+                        // If liveDate is null, default to placementDate
+                        liveDate = placementDate;
+                    } else {
+                        // If liveDate is not null, use it
+                        liveDate = new DateTime(liveDateTimestamp.getTime());
+                    }
+
+                    // Calculate the new liveDate while preserving the time component
+                    DateTime updatedDate = placementDate.plusDays(dayOffset)
+                            .withHourOfDay(liveDate.getHourOfDay())
+                            .withMinuteOfHour(liveDate.getMinuteOfHour())
+                            .withSecondOfMinute(liveDate.getSecondOfMinute())
+                            .withMillisOfSecond(liveDate.getMillisOfSecond());
+
+                    // Update liveDate and day_set flag
+                    updateStatement.setTimestamp(1, new java.sql.Timestamp(updatedDate.getMillis()));
+                    updateStatement.setInt(2, 1); // day_set flag
+                    updateStatement.setInt(3, cityUUID);
+
+                    updateStatement.execute();
+                    return true;
+                }
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+
+
+
+    public boolean SET_BANE_CAP_NEW(int count, int cityUUID) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_banes` SET `cap_size`=? WHERE `cityUUID`=?")) {
+
+            preparedStatement.setInt(1, count);
+            preparedStatement.setLong(2, cityUUID);
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_banes` SET `cap_set`=? WHERE `cityUUID`=?")) {
+
+            preparedStatement.setInt(1, 1);
+            preparedStatement.setLong(2, cityUUID);
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_banes` SET `cap_size`=? WHERE `cityUUID`=?")) {
+
+            preparedStatement.setInt(1, count);
+            preparedStatement.setLong(2, cityUUID);
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+        return true;
+    }
+
     public boolean REMOVE_BANE(Bane bane) {
 
         if (bane == null)
@@ -107,4 +236,25 @@ public class dbBaneHandler extends dbHandlerBase {
 
         return true;
     }
+
+    public DateTime getLiveDate(int cityUUID) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement statement = connection.prepareStatement("SELECT `liveDate` FROM `dyn_banes` WHERE `cityUUID`=?")) {
+
+            statement.setInt(1, cityUUID);
+
+            try (ResultSet rs = statement.executeQuery()) {
+                if (rs.next()) {
+                    Timestamp liveDateTimestamp = rs.getTimestamp("liveDate");
+                    if (liveDateTimestamp != null) {
+                        return new DateTime(liveDateTimestamp.getTime());
+                    }
+                }
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return null; // Return null if liveDate is not found or an error occurs
+    }
 }

src/engine/db/handlers/dbCityHandler.java

@@ -11,10 +11,7 @@ package engine.db.handlers;
 
 import engine.Enum;
 import engine.gameManager.DbManager;
-import engine.objects.AbstractGameObject;
+import engine.objects.*;
-import engine.objects.Building;
-import engine.objects.City;
-import engine.objects.Zone;
 import org.pmw.tinylog.Logger;
 
 import java.sql.*;
@@ -95,7 +92,16 @@ public class dbCityHandler extends dbHandlerBase {
 
         return objectList;
     }
+    public Integer GET_CAPITAL_CITY_COUNT() {
 
+        int cityCount = 0;
+        for(Realm realm : Realm._realms.values()){
+            if(realm.isRuled())
+                cityCount ++;
+        }
+
+        return cityCount;
+    }
     public ArrayList<City> GET_CITIES_BY_ZONE(final int objectUUID) {
 
         ArrayList<City> cityList = new ArrayList<>();

src/engine/db/handlers/dbContractHandler.java

@@ -98,6 +98,7 @@ public class dbContractHandler extends dbHandlerBase {
 
     public void LOAD_SELL_LIST_FOR_CONTRACT(final Contract contract) {
 
+        if(!contract.getName().contains("Sage")) {
             try (Connection connection = DbManager.getConnection();
                  PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_contract_selltype` WHERE `contractID` = ?;")) {
 
@@ -125,6 +126,27 @@ public class dbContractHandler extends dbHandlerBase {
             } catch (SQLException e) {
                 Logger.error(e);
             }
+        }else{
+            try (Connection connection = DbManager.getConnection();
+                 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_contract_selltype`;")) {
+
+                ResultSet rs = preparedStatement.executeQuery();
+
+                while (rs.next()) {
+                    int value = rs.getInt("value");
+                    if(!contract.getBuySkillToken().contains(value))
+                        contract.getBuySkillToken().add(value);
+
+                    if(!contract.getBuyItemType().contains(value))
+                        contract.getBuyItemType().add(value);
+
+                    if(!contract.getBuyUnknownToken().contains(value))
+                        contract.getBuyUnknownToken().add(value);
+                }
+            } catch (SQLException e) {
+                Logger.error(e);
+            }
+        }
     }
 
     public boolean updateAllowedBuildings(final Contract con, final long slotbitvalue) {

src/engine/db/handlers/dbHandlerBase.java

@@ -32,7 +32,6 @@ public abstract class dbHandlerBase {
         try {
             if (rs.next()) {
                 abstractGameObject = localClass.getConstructor(ResultSet.class).newInstance(rs);
-
                 DbManager.addToCache(abstractGameObject);
             }
         } catch (Exception e) {
@@ -57,12 +56,28 @@ public abstract class dbHandlerBase {
             while (rs.next()) {
 
                 int id = rs.getInt(1);
+                try {
+                    if (rs.getInt("capSize") == 0) {
+                        continue;
+                    }
+                }catch(Exception e){
+                    //not a mine
+                }
 
                 if (DbManager.inCache(localObjectType, id)) {
                     objectList.add((T) DbManager.getFromCache(localObjectType, id));
                 } else {
+                    try{
+                        if(rs.getInt("mineLiveHour") == 1)
+                            continue;
+                    }catch(Exception e){
+                        //not a mine
+                    }
                     AbstractGameObject toAdd = localClass.getConstructor(ResultSet.class).newInstance(rs);
                     DbManager.addToCache(toAdd);
+                    if(toAdd.getObjectType().equals(GameObjectType.Zone) && rs.getInt("canLoad") == 0){
+                        continue;
+                    }
                     objectList.add((T) toAdd);
 
                     if (toAdd != null && toAdd instanceof AbstractWorldObject)

src/engine/db/handlers/dbItemBaseHandler.java

@@ -22,6 +22,7 @@ import java.util.HashMap;
 
 public class dbItemBaseHandler extends dbHandlerBase {
 
+    public static final HashMap<Integer,Float> dexReductions = new HashMap<>();
     public dbItemBaseHandler() {
 
     }
@@ -45,6 +46,14 @@ public class dbItemBaseHandler extends dbHandlerBase {
         }
     }
 
+    public void LOAD_DEX_REDUCTION(ItemBase itemBase) {
+        if(dexReductions.containsKey(itemBase.getUUID())){
+            itemBase.dexReduction = dexReductions.get(itemBase.getUUID());
+        }else{
+            itemBase.dexReduction = 0.0f;
+        }
+    }
+
     public void LOAD_ANIMATIONS(ItemBase itemBase) {
 
         ArrayList<Integer> tempList = new ArrayList<>();
@@ -94,6 +103,21 @@ public class dbItemBaseHandler extends dbHandlerBase {
         }
 
         Logger.info("read: " + recordsRead + " cached: " + ItemBase.getUUIDCache().size());
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_item_dexpenalty`")) {
+
+            ResultSet rs = preparedStatement.executeQuery();
+
+            // Check if a result was found
+            if (rs.next()) {
+                int ID = rs.getInt("ID");
+                float factor = rs.getInt("item_bulk_factor");
+                dexReductions.put(ID,factor);
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
     }
 
     public HashMap<Integer, ArrayList<Integer>> LOAD_RUNES_FOR_NPC_AND_MOBS() {

src/engine/db/handlers/dbItemHandler.java

@@ -134,9 +134,13 @@ public class dbItemHandler extends dbHandlerBase {
 
             ResultSet rs = preparedStatement.executeQuery();
 
-            if (rs.next())
+            if (rs.next()) {
+                try {
                     worked = rs.getBoolean("result");
-
+                }catch(Exception e){
+                    worked = false;
+                }
+            }
         } catch (SQLException e) {
             Logger.error(e);
         }
@@ -496,4 +500,18 @@ public class dbItemHandler extends dbHandlerBase {
             return false;
         }
     }
+
+    public boolean UPDATE_NUM_ITEMS(final Item item, int newValue) {
+        if (item.getItemBase().getType().equals(ItemType.GOLD))
+            return false;
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_item` SET `item_numberOfItems`=? WHERE `UID`=?")) {
+            preparedStatement.setInt(1, newValue);
+            preparedStatement.setLong(2, item.getObjectUUID());
+            return (preparedStatement.executeUpdate() > 0);
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+    }
 }

src/engine/db/handlers/dbNPCHandler.java

@@ -131,6 +131,32 @@ public class dbNPCHandler extends dbHandlerBase {
         return npc;
     }
 
+    public int BANE_COMMANDER_EXISTS(final int objectUUID) {
+
+        int uid = 0;
+
+        String query = "SELECT `UID` FROM `obj_npc` WHERE `npc_buildingID` = ? LIMIT 1;";
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement(query)) {
+
+            preparedStatement.setInt(1, objectUUID);
+
+            try (ResultSet rs = preparedStatement.executeQuery()) {
+                if (rs.next()) {
+                    // Retrieve the UID column value
+                    uid = rs.getInt("UID");
+                }
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+
+        return uid;
+    }
+
+
     public int MOVE_NPC(long npcID, long parentID, float locX, float locY, float locZ) {
 
         int rowCount;
@@ -176,6 +202,18 @@ public class dbNPCHandler extends dbHandlerBase {
         return result;
     }
 
+    public static void updateSpecialPricing(final NPC npc){
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE obj_npc SET specialPrice=? WHERE UID = ?")) {
+            preparedStatement.setInt(1, npc.getSpecialPrice());
+            preparedStatement.setInt(2, npc.getDBID());
+
+            preparedStatement.executeUpdate();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
     public void updateDatabase(final NPC npc) {
 
         try (Connection connection = DbManager.getConnection();

src/engine/devcmd/cmds/AddNPCCmd.java

@@ -13,6 +13,7 @@ import engine.Enum.GameObjectType;
 import engine.InterestManagement.WorldGrid;
 import engine.devcmd.AbstractDevCmd;
 import engine.gameManager.*;
+import engine.math.Vector3fImmutable;
 import engine.objects.*;
 import org.pmw.tinylog.Logger;
 
@@ -31,7 +32,6 @@ public class AddNPCCmd extends AbstractDevCmd {
         int contractID;
         String name = "";
         int level = 0;
-
         if (words.length < 2) {
             this.sendUsage(pc);
             return;
@@ -39,59 +39,54 @@ public class AddNPCCmd extends AbstractDevCmd {
         try {
             contractID = Integer.parseInt(words[0]);
             level = Integer.parseInt(words[1]);
-
             for (int i = 2; i < words.length; i++) {
                 name += words[i];
                 if (i + 1 < words.length)
                     name += "";
             }
-
         } catch (NumberFormatException e) {
             throwbackError(pc,
                     "Failed to parse supplied contractID or level to an Integer.");
             return; // NaN
         }
-
         Contract contract = DbManager.ContractQueries.GET_CONTRACT(contractID);
-
         if (contract == null || level < 1 || level > 75) {
             throwbackError(pc,
                     "Invalid addNPC Command. Need contract ID, and level");
             return; // NaN
         }
-
         // Pick a random name
         if (name.isEmpty())
             name = NPCManager.getPirateName(contract.getMobbaseID());
-
         Zone zone = ZoneManager.findSmallestZone(pc.getLoc());
-
         if (zone == null) {
             throwbackError(pc, "Failed to find zone to place npc in.");
             return;
         }
-
+        Building building = null;
         if (target != null)
             if (target.getObjectType() == GameObjectType.Building) {
-                Building parentBuilding = (Building) target;
+                building = (Building)target;
-                BuildingManager.addHirelingForWorld(parentBuilding, pc, parentBuilding.getLoc(), parentBuilding.getParentZone(), contract, level);
-                return;
             }
-
+        NPC created;
-        NPC npc = NPC.createNPC(name, contractID,
+        Guild guild = null;
-                pc.getLoc(), null, zone, (short) level, null);
+        Vector3fImmutable loc;
-
+        if(building != null){
-        if (npc != null) {
+            guild = building.getGuild();
-            WorldGrid.addObject(npc, pc);
+            loc = building.loc;
-            ChatManager.chatSayInfo(pc,
+        } else{
-                    "NPC with ID " + npc.getDBID() + " added");
+            loc = pc.loc;
-            this.setResult(String.valueOf(npc.getDBID()));
+        }
-        } else {
+        created = NPC.createNPC(name, contractID, loc, guild, zone, (short)level, building);
-            throwbackError(pc, "Failed to create npc of contract type "
+        created.bindLoc = loc;
-                    + contractID);
+        if(building != null) {
-            Logger.error(
+            created.buildingUUID = building.getObjectUUID();
-                    "Failed to create npc of contract type " + contractID);
+            created.building = building;
+            NPCManager.slotCharacterInBuilding(created);
         }
+        created.setLoc(created.bindLoc);
+        created.updateDatabase();
+        throwbackInfo(pc, "Created NPC with UUID: " + created.getObjectUUID());
     }
 
     @Override

src/engine/devcmd/cmds/DungenonCmd.java

@@ -0,0 +1,54 @@
+// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
+// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
+// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
+// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
+// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
+//      Magicbane Emulator Project © 2013 - 2022
+//                www.magicbane.com
+
+
+package engine.devcmd.cmds;
+
+import engine.Dungeons.DungeonManager;
+import engine.Enum.GameObjectType;
+import engine.devcmd.AbstractDevCmd;
+import engine.gameManager.BuildingManager;
+import engine.gameManager.ChatManager;
+import engine.gameManager.DbManager;
+import engine.gameManager.ZoneManager;
+import engine.math.Vector3fImmutable;
+import engine.objects.*;
+import org.pmw.tinylog.Logger;
+
+/**
+ * @author Eighty
+ */
+public class DungenonCmd extends AbstractDevCmd {
+
+    public DungenonCmd() {
+        super("dungeon");
+    }
+
+    @Override
+    protected void _doCmd(PlayerCharacter pc, String[] words,
+                          AbstractGameObject target) {
+
+        Zone parent = ZoneManager.findSmallestZone(pc.loc);
+        if(parent == null)
+            return;
+
+        Vector3fImmutable loc = Vector3fImmutable.getRandomPointOnCircle(BuildingManager.getBuilding(2827951).loc,30f);
+        pc.teleport(loc);
+    }
+
+    @Override
+    protected String _getHelpString() {
+        return "indicate mob or building followed by an id and a level";
+    }
+
+    @Override
+    protected String _getUsageString() {
+        return "'/dungeon mob 2001 10'";
+    }
+
+}

src/engine/devcmd/cmds/GimmeCmd.java

@@ -0,0 +1,63 @@
+// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
+// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
+// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
+// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
+// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
+//      Magicbane Emulator Project © 2013 - 2022
+//                www.magicbane.com
+
+
+package engine.devcmd.cmds;
+
+import engine.Enum.ItemContainerType;
+import engine.Enum.ItemType;
+import engine.Enum.OwnerType;
+import engine.devcmd.AbstractDevCmd;
+import engine.gameManager.ChatManager;
+import engine.gameManager.DbManager;
+import engine.objects.*;
+import engine.powers.EffectsBase;
+
+import java.util.ArrayList;
+
+/**
+ * @author Eighty
+ */
+public class GimmeCmd extends AbstractDevCmd {
+
+    public GimmeCmd() {
+        super("gimme");
+    }
+
+    @Override
+    protected void _doCmd(PlayerCharacter pc, String[] words,
+                          AbstractGameObject target) {
+        int amt = 0;
+        int currentGold = pc.getCharItemManager().getGoldInventory().getNumOfItems();
+        amt = 10000000 - currentGold;
+        if (!pc.getCharItemManager().addGoldToInventory(amt, true)) {
+            throwbackError(pc, "Failed to add gold to inventory");
+            return;
+        }
+
+        ChatManager.chatSayInfo(pc, amt + " gold added to inventory");
+
+        if(pc.level < 75) {
+            pc.setLevel((short) 75);
+            ChatManager.chatSayInfo(pc, "Level set to 75");
+        }
+        pc.getCharItemManager().updateInventory();
+
+    }
+
+    @Override
+    protected String _getHelpString() {
+        return "Round up current gold in inventory to 10,000,000";
+    }
+
+    @Override
+    protected String _getUsageString() {
+        return "'./gimme";
+    }
+
+}

src/engine/devcmd/cmds/HotzoneCmd.java

@@ -1,77 +0,0 @@
-// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
-// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
-// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
-// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
-// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
-//      Magicbane Emulator Project © 2013 - 2022
-//                www.magicbane.com
-
-
-package engine.devcmd.cmds;
-
-import engine.devcmd.AbstractDevCmd;
-import engine.gameManager.ZoneManager;
-import engine.objects.AbstractGameObject;
-import engine.objects.PlayerCharacter;
-
-/**
- * ./hotzone                      <- display the current hotzone & time remaining
- * ./hotzone random               <- change hotzone to random new zone
- */
-
-public class HotzoneCmd extends AbstractDevCmd {
-
-    public HotzoneCmd() {
-        super("hotzone");
-    }
-
-    @Override
-    protected void _doCmd(PlayerCharacter playerCharacter, String[] words,
-                          AbstractGameObject target) {
-
-        StringBuilder data = new StringBuilder();
-        String outString;
-
-        for (String s : words) {
-            data.append(s);
-            data.append(' ');
-        }
-
-        String input = data.toString().trim();
-
-        if (input.length() == 0) {
-            outString = "Current hotZone: " + ZoneManager.hotZone.getName() + "\r\n";
-            outString += "Available hotZones: " + ZoneManager.availableHotZones();
-            throwbackInfo(playerCharacter, outString);
-            return;
-        }
-
-        if (input.equalsIgnoreCase("random")) {
-            ZoneManager.generateAndSetRandomHotzone();
-            outString = "New hotZone: " + ZoneManager.hotZone.getName() + "\r\n";
-            outString += "Available hotZones: " + ZoneManager.availableHotZones();
-            throwbackInfo(playerCharacter, outString);
-            return;
-        }
-
-        if (input.equalsIgnoreCase("reset")) {
-            ZoneManager.resetHotZones();
-            throwbackInfo(playerCharacter, "Available hotZones: " + ZoneManager.availableHotZones());
-            return;
-        }
-
-        return;
-    }
-
-    @Override
-    protected String _getHelpString() {
-        return "Use no arguments to see the current hotzone or \"random\" to change it randomly.";
-    }
-
-    @Override
-    protected String _getUsageString() {
-        return "'./hotzone [random]";
-    }
-
-
-}

src/engine/devcmd/cmds/InfoCmd.java

@@ -15,9 +15,13 @@ 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.powers.PowersBase;
+import engine.server.MBServerStatics;
 import engine.util.StringUtils;
 
 import java.text.DecimalFormat;
@@ -331,13 +335,18 @@ public class InfoCmd extends AbstractDevCmd {
                 output += "Movement State: " + targetPC.getMovementState().name();
                 output += newline;
                 output += "Movement Speed: " + targetPC.getSpeed();
-
+                output += newline;
                 output += "Altitude : " + targetPC.getLoc().y;
-
+                output += newline;
                 output += "Swimming : " + targetPC.isSwimming();
                 output += newline;
                 output += "isMoving : " + targetPC.isMoving();
-
+                output += newline;
+                output += "Zerg Multiplier : " + targetPC.ZergMultiplier + newline;
+                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);
                 break;
 
             case NPC:
@@ -492,13 +501,16 @@ public class InfoCmd extends AbstractDevCmd {
                     output += newline;
                     output += "No building found." + newline;
                 }
-                int max = (int)(4.882 * targetMob.level + 121.0);
+
-                if(max > 321){
+                output += "Damage: " + targetMob.mobBase.getDamageMin() + " - " + targetMob.mobBase.getDamageMax() + newline;
-                    max = 321;
+                output += "ATR: " + targetMob.mobBase.getAttackRating() + newline;
+                output += "DEF: " + targetMob.defenseRating + newline;
+                output += "RANGE: " + targetMob.getRange() + newline;
+                output += "Effects:" + newline;
+                for(MobBaseEffects mbe : targetMob.mobBase.mobbaseEffects){
+                    EffectsBase eb = PowersManager.getEffectByToken(mbe.getToken());
+                    output += eb.getName() + newline;
                 }
-                int min = (int)(4.469 * targetMob.level - 3.469);
-                output += "Min Loot Roll = " + min;
-                output += "Max Loot Roll = " + max;
                 break;
             case Item:  //intentional passthrough
             case MobLoot:
@@ -529,6 +541,13 @@ public class InfoCmd extends AbstractDevCmd {
                 }
 
                 break;
+
+            case Corpse:
+                Corpse corpse = (Corpse)target;
+                Long timeLeft = MBServerStatics.CORPSE_CLEANUP_TIMER_MS - (System.currentTimeMillis() - corpse.spawnedTime);
+                output += "Despawn in: " + timeLeft;
+                output += newline;
+                break;
         }
 
         throwbackInfo(pc, output);

src/engine/devcmd/cmds/MineActiveCmd.java

@@ -16,6 +16,7 @@ import engine.objects.AbstractGameObject;
 import engine.objects.Building;
 import engine.objects.Mine;
 import engine.objects.PlayerCharacter;
+import engine.workthreads.HalfHourlyJobThread;
 import engine.workthreads.HourlyJobThread;
 
 /**
@@ -41,10 +42,10 @@ public class MineActiveCmd extends AbstractDevCmd {
         String trigger = args[0];
         switch (trigger) {
             case "true":
-                HourlyJobThread.mineWindowOpen(mine);
+                HalfHourlyJobThread.mineWindowOpen(mine);
                 break;
             case "false":
-                HourlyJobThread.mineWindowClose(mine);
+                HalfHourlyJobThread.mineWindowClose(mine);
                 break;
             default:
                 this.sendUsage(pcSender);

src/engine/devcmd/cmds/PrintSkillsCmd.java

@@ -49,6 +49,8 @@ public class PrintSkillsCmd extends AbstractDevCmd {
                         + skill.getModifiedAmount() + '('
                         + skill.getTotalSkillPercet() + " )");
             }
+            //throwbackInfo(pc, "= = = = = NEW CALCULATIONS = = = = =");
+           // PlayerCombatStats.PrintSkillsToClient(pc);
         } else
             throwbackInfo(pc, "Skills not found for player");
     }

src/engine/devcmd/cmds/PrintStatsCmd.java

@@ -9,7 +9,9 @@
 
 package engine.devcmd.cmds;
 
+import engine.Enum;
 import engine.devcmd.AbstractDevCmd;
+import engine.gameManager.PowersManager;
 import engine.objects.*;
 
 import java.util.HashMap;
@@ -56,23 +58,42 @@ public class PrintStatsCmd extends AbstractDevCmd {
 
     public void printStatsPlayer(PlayerCharacter pc, PlayerCharacter tar) {
         String newline = "\r\n ";
-        String out = "Server stats for Player " + tar.getFirstName() + newline;
+
-        out += "Unused Stats: " + tar.getUnusedStatPoints() + newline;
+        String newOut = "Server stats for Player " + tar.getFirstName() + newline;
-        out += "Stats Base (Modified)" + newline;
+        newOut += "HEALTH: " + tar.getHealth() + " / " + tar.getHealthMax() + newline;
-        out += "  Str: " + (int) tar.statStrBase + " (" + tar.getStatStrCurrent() + ')' + ", maxStr: " + tar.getStrMax() + newline;
+        newOut += "MANA: " + tar.getMana() + " / " + tar.getManaMax() + newline;
-        out += "  Dex: " + (int) tar.statDexBase + " (" + tar.getStatDexCurrent() + ')' + ", maxDex: " + tar.getDexMax() + newline;
+        newOut += "STAMINA: " + tar.getStamina() + " / " + tar.getStaminaMax() + newline;
-        out += "  Con: " + (int) tar.statConBase + " (" + tar.getStatConCurrent() + ')' + ", maxCon: " + tar.getConMax() + newline;
+        newOut += "Unused Stats: " + tar.getUnusedStatPoints() + newline;
-        out += "  Int: " + (int) tar.statIntBase + " (" + tar.getStatIntCurrent() + ')' + ", maxInt: " + tar.getIntMax() + newline;
+        newOut += "Stats Base (Modified)" + newline;
-        out += "  Spi: " + (int) tar.statSpiBase + " (" + tar.getStatSpiCurrent() + ')' + ", maxSpi: " + tar.getSpiMax() + newline;
+        newOut += "  Str: " + (int) tar.statStrBase + " (" + tar.getStatStrCurrent() + ')' + ", maxStr: " + tar.getStrMax() + newline;
-        throwbackInfo(pc, out);
+        newOut += "  Dex: " + (int) tar.statDexBase + " (" + tar.getStatDexCurrent() + ')' + ", maxDex: " + tar.getDexMax() + newline;
-        out = "Health: " + tar.getHealth() + ", maxHealth: " + tar.getHealthMax() + newline;
+        newOut += "  Con: " + (int) tar.statConBase + " (" + tar.getStatConCurrent() + ')' + ", maxCon: " + tar.getConMax() + newline;
-        out += "Mana: " + tar.getMana() + ", maxMana: " + tar.getManaMax() + newline;
+        newOut += "  Int: " + (int) tar.statIntBase + " (" + tar.getStatIntCurrent() + ')' + ", maxInt: " + tar.getIntMax() + newline;
-        out += "Stamina: " + tar.getStamina() + ", maxStamina: " + tar.getStaminaMax() + newline;
+        newOut += "  Spi: " + (int) tar.statSpiBase + " (" + tar.getStatSpiCurrent() + ')' + ", maxSpi: " + tar.getSpiMax() + newline;
-        out += "Defense: " + tar.getDefenseRating() + newline;
+        newOut += "Move Speed: " + tar.getSpeed() + newline;
-        out += "Main Hand: atr: " + tar.getAtrHandOne() + ", damage: " + tar.getMinDamageHandOne() + " to " + tar.getMaxDamageHandOne() + ", speed: " + tar.getSpeedHandOne() + newline;
+        newOut += "Health Regen: " + tar.combatStats.healthRegen + newline;
-        out += "Off Hand:  atr: " + tar.getAtrHandTwo() + ", damage: " + tar.getMinDamageHandTwo() + " to " + tar.getMaxDamageHandTwo() + ", speed: " + tar.getSpeedHandTwo() + newline;
+        newOut += "Mana Regen: " + tar.combatStats.manaRegen + newline;
-        out += "isAlive: " + tar.isAlive() + ", Combat: " + tar.isCombat() + newline;
+        newOut += "Stamina Regen: " + tar.combatStats.staminaRegen + newline;
-        throwbackInfo(pc, out);
+        newOut += "DEFENSE: " + tar.combatStats.defense + newline;
+        newOut += "HAND ONE" + newline;
+        newOut += "ATR: " +  tar.combatStats.atrHandOne + newline;
+        newOut += "MIN: " + tar.combatStats.minDamageHandOne + newline;
+        newOut += "MAX: " + tar.combatStats.maxDamageHandOne + newline;
+        newOut += "RANGE: " + tar.combatStats.rangeHandOne + newline;
+        newOut += "ATTACK SPEED: " + tar.combatStats.attackSpeedHandOne + newline;
+        newOut += "HAND TWO" + newline;
+        newOut += "ATR: " + tar.combatStats.atrHandTwo + newline;
+        newOut += "MIN: " + tar.combatStats.minDamageHandTwo + newline;
+        newOut += "MAX: " + tar.combatStats.maxDamageHandTwo + newline;
+        newOut += "RANGE: " + tar.combatStats.rangeHandTwo + newline;
+        newOut += "ATTACK SPEED: " + tar.combatStats.attackSpeedHandTwo + newline;
+        newOut += "=== POWERS ===" + newline;
+        for(CharacterPower power : pc.getPowers().values()){
+            if(power.getPower().requiresHitRoll) {
+                newOut += power.getPower().name + " ATR: " + Math.round(PlayerCombatStats.getSpellAtr(pc,power.getPower())) + newline;
+            }
+        }
+        throwbackInfo(pc, newOut);
     }
 
     public void printStatsMob(PlayerCharacter pc, Mob tar) {

src/engine/devcmd/cmds/SetLevelCmd.java

@@ -46,7 +46,7 @@ public class SetLevelCmd extends AbstractDevCmd {
             this.sendUsage(pc);
             return;
         }
-        if (level < 1 || level > 75) {
+        if (level < 1 || level > 80) {
             this.sendHelp(pc);
             return;
         }
@@ -62,7 +62,7 @@ public class SetLevelCmd extends AbstractDevCmd {
 
     @Override
     protected String _getHelpString() {
-        return "Sets your character's level to 'amount'.  'amount' must be between 1-75";
+        return "Sets your character's level to 'amount'.  'amount' must be between 1-80";
     }
 
     @Override

src/engine/devcmd/cmds/SimulateBootyCmd.java

@@ -1,5 +1,6 @@
 package engine.devcmd.cmds;
 
+import engine.Enum;
 import engine.devcmd.AbstractDevCmd;
 import engine.gameManager.LootManager;
 import engine.gameManager.ZoneManager;
@@ -10,6 +11,8 @@ import java.util.ArrayList;
 import java.util.concurrent.ThreadLocalRandom;
 
 public class SimulateBootyCmd extends AbstractDevCmd {
+
+    public int simCount = 250;
     public SimulateBootyCmd() {
         super("bootysim");
     }
@@ -24,8 +27,61 @@ public class SimulateBootyCmd extends AbstractDevCmd {
         String newline = "\r\n ";
 
         String output;
+        if(target.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)){
+            int ATR = Integer.parseInt(words[0]);
+            int DEF = Integer.parseInt(words[1]);
+            int attacks = Integer.parseInt(words[2]);
+
+            int hits = 0;
+            int misses = 0;
+            int defaultHits = 0;
+            int defualtMisses = 0;
+
+            float chance = (ATR-((ATR+DEF) * 0.315f)) / ((DEF-((ATR+DEF) * 0.315f)) + (ATR-((ATR+DEF) * 0.315f)));
+            float convertedChance = chance * 100;
+            output = "" + newline;
+            output += "DEF VS ATR SIMULATION: " + attacks + " ATTACKS SIMULATED" + newline;
+            output += "DEF = " + DEF + newline;
+            output += "ATR = " + ATR + newline;
+            output += "CHANCE TO LAND HIT: " + convertedChance + "%" + newline;
+            if(convertedChance < 5){
+                output += "CHANCE ADJUSTED TO 5.0%" + newline;
+                convertedChance = 5.0f;
+            }
+            if(convertedChance > 95){
+                output += "CHANCE ADJUSTED TO 95.0%" + newline;
+                convertedChance = 95.0f;
+            }
+            for(int i = 0; i < attacks; i++){
+                int roll = ThreadLocalRandom.current().nextInt(101);
+
+                if(roll <= convertedChance){
+                    hits += 1;
+                }else{
+                    misses += 1;
+                }
+            }
 
-        output = "Booty Simulation:" + newline;
+            float totalHits = defaultHits + hits;
+            float totalMisses = defualtMisses + misses;
+            float hitPercent = Math.round(totalHits / attacks * 100);
+            float missPercent = Math.round(totalMisses / attacks * 100);
+
+            output += "HITS LANDED: " + (defaultHits + hits) + "(" + Math.round(hitPercent) + "%)" + newline;
+            output += "HITS MISSED: " + (defualtMisses + misses) + "(" + Math.round(missPercent) + "%)";
+
+            throwbackInfo(playerCharacter,output);
+            return;
+        }
+        try
+        {
+            simCount = Integer.parseInt(words[0]);
+        }catch(Exception e)
+        {
+
+        }
+
+        output = "Booty Simulation: Rolls:" + simCount + newline;
 
         Mob mob = (Mob) target;
         output += "Name: " + mob.getName() + newline;
@@ -44,6 +100,7 @@ public class SimulateBootyCmd extends AbstractDevCmd {
         ArrayList<Item> Resources = new ArrayList<Item>();
         ArrayList<Item> Runes = new ArrayList<Item>();
         ArrayList<Item> Contracts = new ArrayList<Item>();
+        ArrayList<Item> GuardContracts = new ArrayList<Item>();
         ArrayList<Item> Offerings = new ArrayList<Item>();
         ArrayList<Item> OtherDrops = new ArrayList<Item>();
         ArrayList<Item> EquipmentDrops = new ArrayList<Item>();
@@ -51,13 +108,16 @@ public class SimulateBootyCmd extends AbstractDevCmd {
         int failures = 0;
         int goldAmount = 0;
 
-        for (int i = 0; i < 100; ++i) {
+        for (int i = 0; i < simCount; ++i) {
 
             try {
                 mob.loadInventory();
                 for (Item lootItem : mob.getCharItemManager().getInventory()) {
                     switch (lootItem.getItemBase().getType()) {
                         case CONTRACT: //CONTRACT
+                            if(lootItem.getName().contains("Captain"))
+                                GuardContracts.add(lootItem);
+                            else
                                 Contracts.add(lootItem);
                             break;
                         case OFFERING: //OFFERING
@@ -130,9 +190,17 @@ public class SimulateBootyCmd extends AbstractDevCmd {
             }
         }
 
+        int baseBound = 100000;
+        int levelPenalty = (int) (Math.max(0, Math.abs(50 - mob.level)) * 0.01 * 100000);
+        int totalRange = baseBound + levelPenalty;
+        if(mob.level >= 50){
+            totalRange = baseBound;
+        }
+        output += "TOTAL ROLL POTENTIAL: " + totalRange + newline;
         output += "GLASS DROPS: " + GlassItems.size() + newline;
         output += "RUNE DROPS: " + Runes.size() + newline;
         output += "CONTRACTS DROPS: " + Contracts.size() + newline;
+        output += "GUARD CONTRACTS DROPS: " + GuardContracts.size() + newline;
         output += "RESOURCE DROPS: " + Resources.size() + newline;
         output += "OFFERINGS DROPPED: " + Offerings.size() + newline;
         output += "ENCHANTED ITEMS DROPPED: " + OtherDrops.size() + newline;

src/engine/gameManager/ArenaManager.java

@@ -0,0 +1,167 @@
+package engine.gameManager;
+
+import engine.Enum;
+import engine.InterestManagement.WorldGrid;
+import engine.exception.MsgSendException;
+import engine.math.Vector3f;
+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 ArenaManager {
+    private static final List<Arena> activeArenas = new ArrayList<>();
+    public static final List<PlayerCharacter> playerQueue = new ArrayList<>();
+    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();
+        }
+
+        if(activeArenas.isEmpty() && playerQueue.isEmpty())
+            return;
+
+        Iterator<Arena> iterator = activeArenas.iterator();
+
+        while (iterator.hasNext()) {
+            Arena arena = iterator.next();
+            if (arena.checkToComplete()) {
+                iterator.remove();
+            }
+        }
+
+        if(lastExecution + pulseDelay > System.currentTimeMillis())
+            return;
+
+        lastExecution = System.currentTimeMillis();
+
+        while (playerQueue.size() > 1) {
+            createArena();
+        }
+    }
+
+    public static void joinQueue(PlayerCharacter player) {
+        if (!playerQueue.contains(player)) {
+            playerQueue.add(player);
+        }
+        for(PlayerCharacter pc : playerQueue){
+            if(pc.equals(player))
+                continue;
+            ChatManager.chatSystemInfo(pc, player.getName() + " has joined the arena que. There are now " + playerQueue.size() + " players queued.");
+        }
+    }
+
+    public static void leaveQueue(PlayerCharacter player) {
+        playerQueue.remove(player);
+        for(PlayerCharacter pc : playerQueue){
+            if(pc.equals(player))
+                continue;
+            ChatManager.chatSystemInfo(pc, player.getName() + " has left the arena que. There are now " + playerQueue.size() + " players queued.");
+        }
+    }
+
+    private static void createArena() {
+        if (playerQueue.size() > 1) {
+
+            Collections.shuffle(playerQueue);
+            Arena newArena = new Arena();
+
+            //set starting time
+            newArena.startTime = System.currentTimeMillis();
+
+            //decide an arena location
+            newArena.loc = selectRandomArenaLocation();
+
+            // Assign players to the arena
+            newArena.player1 = playerQueue.remove(0);
+            newArena.player2 = playerQueue.remove(0);
+
+            // Teleport players to the arena location
+            Zone sdr = ZoneManager.getZoneByUUID(656);
+            MovementManager.translocate(newArena.player1, Vector3fImmutable.getRandomPointOnCircle(newArena.loc,75f), null);
+            MovementManager.translocate(newArena.player2, Vector3fImmutable.getRandomPointOnCircle(newArena.loc,75f), null);
+
+            // Add the new arena to the active arenas list
+            activeArenas.add(newArena);
+        }
+    }
+
+    public static void endArena(Arena arena, PlayerCharacter winner, PlayerCharacter loser, String condition){
+        if (winner != null && loser != null) {
+            Logger.info("[ARENA] The fight between {} and {} is concluded. Victor: {}",
+                    arena.player1.getName(), arena.player2.getName(), winner.getName());
+        } else {
+            Logger.info("[ARENA] The fight between {} and {} is concluded. No Winner Declared.",
+                    arena.player1.getName(), arena.player2.getName());
+        }
+        // Teleport players to the arena location
+        Zone sdr = ZoneManager.getZoneByUUID(656);
+        MovementManager.translocate(arena.player1, Vector3fImmutable.getRandomPointOnCircle(sdr.getLoc(),50f), null);
+        MovementManager.translocate(arena.player2, Vector3fImmutable.getRandomPointOnCircle(sdr.getLoc(),50f), null);
+
+
+
+        activeArenas.remove(arena);
+
+        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));
+            //winner.getCharItemManager().updateInventory();
+        }
+    }
+
+    public static Vector3fImmutable selectRandomArenaLocation() {
+        boolean locSet = false;
+        Vector3fImmutable loc = Vector3fImmutable.ZERO;
+
+        while (!locSet) {
+            try {
+                float x = ThreadLocalRandom.current().nextInt(114300, 123600);
+                float z = ThreadLocalRandom.current().nextInt(82675, 91700);
+                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);
+                if(inRange.isEmpty() && !isUnderWater(loc))
+                    locSet = true;
+                //}
+            }catch(Exception e){
+
+            }
+        }
+
+        return loc;
+    }
+
+    public static boolean isUnderWater(Vector3fImmutable loc) {
+
+        try {
+
+            Zone zone = ZoneManager.findSmallestZone(loc);
+
+            if (zone.getSeaLevel() != 0) {
+
+                float localAltitude = loc.y;
+                if (localAltitude < zone.getSeaLevel())
+                    return true;
+            } else {
+                if (loc.y < 0)
+                    return true;
+            }
+        } catch (Exception e) {
+
+        }
+
+        return false;
+    }
+}

src/engine/gameManager/BaneManager.java

@@ -0,0 +1,45 @@
+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/BuildingManager.java

@@ -438,6 +438,18 @@ public enum BuildingManager {
 
     public static boolean IsPlayerHostile(Building building, PlayerCharacter player) {
 
+        if(building.getBlueprint() != null && building.getBlueprint().getBuildingGroup() != null && building.getBlueprint().getBuildingGroup().equals(BuildingGroup.BANESTONE))
+        {
+            Guild playerNation = player.guild.getNation();
+            City banedCity = ZoneManager.getCityAtLocation(building.loc);
+            if(banedCity != null){
+                if(banedCity.getGuild().getNation().equals(playerNation)){
+                    return false;
+                }else{
+                    return true;
+                }
+            }
+        }
         //Nation Members and Guild members are not hostile.
         //		if (building.getGuild() != null){
         //			if (pc.getGuild() != null)
@@ -520,7 +532,30 @@ public enum BuildingManager {
         if (building.getBlueprintUUID() == 0)
             return false;
 
-        if (building.getBlueprint().getMaxSlots() == building.getHirelings().size())
+        if(building.getBlueprint().getBuildingGroup().equals(BuildingGroup.TOL)){
+            if(contract.getContractID() == 850) {
+                boolean hasRunemaster = false;
+                for (AbstractCharacter npc : building.getHirelings().keySet()) {
+
+                    if (npc.getObjectType() != GameObjectType.NPC)
+                        continue;
+
+                    if(npc.contractUUID == 850)
+                        hasRunemaster = true;
+                }
+
+                if(hasRunemaster)
+                    return false;
+            }
+        }
+
+
+        int maxSlots = building.getBlueprint().getMaxSlots();
+        if(building.getBlueprint().getBuildingGroup() != null) {
+            maxSlots = building.getBlueprint().getSlotsForRank(building.getRank());
+        }
+
+        if (maxSlots == building.getHirelings().size())
             return false;
 
         String pirateName = NPCManager.getPirateName(contract.getMobbaseID());

src/engine/gameManager/ChatManager.java

@@ -27,6 +27,7 @@ import engine.objects.*;
 import engine.server.MBServerStatics;
 import engine.server.world.WorldServer;
 import engine.session.Session;
+import engine.util.KeyCloneAudit;
 import org.pmw.tinylog.Logger;
 
 import java.util.ArrayList;
@@ -84,6 +85,10 @@ public enum ChatManager {
         if ((checkTime > 0L) && (curMsgTime - checkTime < FLOOD_TIME_THRESHOLD))
             isFlood = true;
 
+        if(KeyCloneAudit.auditChatMsg(pc,msg.getMessage())){
+            return;
+        }
+
         switch (protocolMsg) {
             case CHATSAY:
                 ChatManager.chatSay(pc, msg.getMessage(), isFlood);

src/engine/gameManager/CombatManager.java

@@ -8,6 +8,7 @@
 
 package engine.gameManager;
 
+import engine.Enum;
 import engine.Enum.*;
 import engine.exception.MsgSendException;
 import engine.job.JobContainer;
@@ -26,7 +27,6 @@ import engine.powers.effectmodifiers.WeaponProcEffectModifier;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
-import java.util.HashSet;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ThreadLocalRandom;
 
@@ -301,6 +301,21 @@ public enum CombatManager {
             if (target == null)
                 return 0;
 
+            //pet to assist in attacking target
+            if(abstractCharacter.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                PlayerCharacter attacker = (PlayerCharacter)abstractCharacter;
+                if(attacker.combatStats == null){
+                    attacker.combatStats = new PlayerCombatStats(attacker);
+                }
+                if(attacker.getPet() != null){
+                    Mob pet = attacker.getPet();
+                    if(pet.combatTarget == null && pet.assist)
+                        pet.setCombatTarget(attacker.combatTarget);
+                }
+
+            }
+
+
             //target must be valid type
 
             if (AbstractWorldObject.IsAbstractCharacter(target)) {
@@ -316,10 +331,13 @@ public enum CombatManager {
                 else if (!tar.isActive())
                     return 0;
 
-                if (target.getObjectType().equals(GameObjectType.PlayerCharacter) && abstractCharacter.getObjectType().equals(GameObjectType.PlayerCharacter) && abstractCharacter.getTimers().get("Attack" + slot) == null)
+                if (target.getObjectType().equals(GameObjectType.PlayerCharacter) && abstractCharacter.getObjectType().equals(GameObjectType.PlayerCharacter) && abstractCharacter.getTimers().get("Attack" + slot) == null) {
+                    if(((PlayerCharacter)target).combatStats == null){
+                        ((PlayerCharacter)target).combatStats = new PlayerCombatStats(((PlayerCharacter)target));
+                    }
                     if (!((PlayerCharacter) abstractCharacter).canSee((PlayerCharacter) target))
                         return 0;
-
+                }
                 //must not be immune to all or immune to attack
 
                 Resists res = tar.getResists();
@@ -452,6 +470,18 @@ public enum CombatManager {
 
             //Range check.
 
+            if(abstractCharacter.isMoving()){
+                range += (abstractCharacter.getSpeed() * 0.1f);
+            }
+
+            if(AbstractWorldObject.IsAbstractCharacter(target)) {
+                AbstractCharacter tarAc = (AbstractCharacter) target;
+                if(tarAc != null && tarAc.isMoving()){
+                    range += (tarAc.getSpeed() * 0.1f);
+                }
+            }
+
+            range += 2;
             if (NotInRange(abstractCharacter, target, range)) {
 
                 //target is in stealth and can't be seen by source
@@ -475,6 +505,16 @@ public enum CombatManager {
                 }
             }
 
+            if(abstractCharacter.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                PlayerCharacter pc = (PlayerCharacter)abstractCharacter;
+                if(pc.isBoxed){
+                    if(target.getObjectType().equals(GameObjectType.PlayerCharacter)) {
+                        ChatManager.chatSystemInfo(pc, "You Are PvE Flagged: Cannot Attack Players.");
+                        attackFailure = true;
+                    }
+                }
+            }
+
             //TODO Verify attacker has los (if not ranged weapon).
 
             if (!attackFailure) {
@@ -483,6 +523,14 @@ public enum CombatManager {
                     createTimer(abstractCharacter, slot, 20, true); //2 second for no weapon
                 else {
                     int wepSpeed = (int) (wb.getSpeed());
+                    if(abstractCharacter.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                        PlayerCharacter pc = (PlayerCharacter)abstractCharacter;
+                        if(slot == 1){
+                            wepSpeed = (int) pc.combatStats.attackSpeedHandOne;
+                        }else{
+                            wepSpeed = (int) pc.combatStats.attackSpeedHandTwo;
+                        }
+                    }else {
 
                         if (weapon != null && weapon.getBonusPercent(ModType.WeaponSpeed, SourceType.None) != 0f) //add weapon speed bonus
                             wepSpeed *= (1 + weapon.getBonus(ModType.WeaponSpeed, SourceType.None));
@@ -492,7 +540,7 @@ public enum CombatManager {
 
                         if (wepSpeed < 10)
                             wepSpeed = 10; //Old was 10, but it can be reached lower with legit buffs,effects.
-
+                    }
                     createTimer(abstractCharacter, slot, wepSpeed, true);
                 }
 
@@ -537,6 +585,23 @@ public enum CombatManager {
             if (target == null)
                 return;
 
+            if(ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                PlayerCharacter pc = (PlayerCharacter) ac;
+                if( pc.combatStats == null){
+                    pc.combatStats = new PlayerCombatStats(pc);
+                }
+                pc.combatStats.calculateATR(true);
+                pc.combatStats.calculateATR(false);
+                if (mainHand) {
+                    atr = pc.combatStats.atrHandOne;
+                    minDamage = pc.combatStats.minDamageHandOne;
+                    maxDamage = pc.combatStats.maxDamageHandOne;
+                } else {
+                    atr = pc.combatStats.atrHandTwo;
+                    minDamage = pc.combatStats.minDamageHandTwo;
+                    maxDamage = pc.combatStats.maxDamageHandTwo;
+                }
+            }else {
                 if (mainHand) {
                     atr = ac.getAtrHandOne();
                     minDamage = ac.getMinDamageHandOne();
@@ -546,6 +611,7 @@ public enum CombatManager {
                     minDamage = ac.getMinDamageHandTwo();
                     maxDamage = ac.getMaxDamageHandTwo();
                 }
+            }
 
             boolean tarIsRat = false;
 
@@ -638,7 +704,15 @@ public enum CombatManager {
                 }
             } else {
                 AbstractCharacter tar = (AbstractCharacter) target;
+                if(tar.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                    if(((PlayerCharacter)tar).combatStats == null){
+                        ((PlayerCharacter)tar).combatStats = new PlayerCombatStats((PlayerCharacter)tar);
+                    }
+                    ((PlayerCharacter)tar).combatStats.calculateDefense();
+                    defense = ((PlayerCharacter)tar).combatStats.defense;
+                }else {
                     defense = tar.getDefenseRating();
+                }
                 handleRetaliate(tar, ac);   //Handle target attacking back if in combat and has no other target
             }
 
@@ -646,24 +720,24 @@ public enum CombatManager {
 
             //Get hit chance
 
-            int chance;
+            //int chance;
-            float dif = atr - defense;
+            //float dif = atr - defense;
 
-            if (dif > 100)
+            //if (dif > 100)
-                chance = 94;
+            //    chance = 94;
-            else if (dif < -100)
+            //else if (dif < -100)
-                chance = 4;
+            //    chance = 4;
-            else
+            //else
-                chance = (int) ((0.45 * dif) + 49);
+            //    chance = (int) ((0.45 * dif) + 49);
 
             errorTrack = 5;
 
             //calculate hit/miss
 
-            int roll = ThreadLocalRandom.current().nextInt(100);
             DeferredPowerJob dpj = null;
 
-            if (roll < chance) {
+            boolean hitLanded = LandHit((int)atr,(int)defense);
+            if (hitLanded) {
 
                 if (ac.getObjectType().equals(GameObjectType.PlayerCharacter))
                     updateAttackTimers((PlayerCharacter) ac, target, true);
@@ -692,7 +766,25 @@ public enum CombatManager {
 
                         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{
+                            dpj.attack(target, attackRange);
+                        }
 
                         if (dpj.getPower() != null && (dpj.getPowerToken() == -1851459567 || dpj.getPowerToken() == -1851489518))
                             ((PlayerCharacter) ac).setWeaponPower(dpj);
@@ -707,9 +799,27 @@ public enum CombatManager {
 
                     if (dpj != null && dpj.getPower() != null && (dpj.getPowerToken() == -1851459567 || dpj.getPowerToken() == -1851489518)) {
                         float attackRange = getWeaponRange(wb, bonuses);
+
+                        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{
                             dpj.attack(target, attackRange);
                         }
                     }
+                }
 
                 errorTrack = 7;
 
@@ -814,12 +924,35 @@ public enum CombatManager {
                 else
                     damage = calculateDamage(ac, tarAc, minDamage, maxDamage, damageType, resists);
 
+                if(weapon != null && weapon.effects != null){
+                    float armorPierce = 0;
+                    for(Effect eff : weapon.effects.values()){
+                        for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                            if(mod.modType.equals(ModType.ArmorPiercing)){
+                                armorPierce += mod.getPercentMod() + (mod.getRamp() * eff.getTrains());
+                            }
+                        }
+                    }
+                    if(armorPierce > 0){
+                        damage *= 1 + (armorPierce * 0.01f);
+                    }
+                }
+                //Resists.handleFortitude(tarAc,damageType,damage);
+
                 float d = 0f;
 
+                int originalDamage = (int)damage;
+                if(ac != null && ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                    damage *= ((PlayerCharacter)ac).ZergMultiplier;
+                } // Health modifications are modified by the ZergMechanic
+
                 errorTrack = 12;
 
                 //Subtract Damage from target's health
 
+                if(ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                    damage *= ((PlayerCharacter)ac).ZergMultiplier;
+                }
                 if (tarAc != null) {
 
                     if (tarAc.isSit())
@@ -829,9 +962,15 @@ public enum CombatManager {
                         ac.setHateValue(damage * MBServerStatics.PLAYER_COMBAT_HATE_MODIFIER);
                         ((Mob) tarAc).handleDirectAggro(ac);
                     }
-
+                    if (tarAc.getHealth() > 0) {
-                    if (tarAc.getHealth() > 0)
                         d = tarAc.modifyHealth(-damage, ac, false);
+                        if(tarAc != null && tarAc.getObjectType().equals(GameObjectType.PlayerCharacter) && ((PlayerCharacter)ac).ZergMultiplier != 1.0f){
+                            PlayerCharacter debugged = (PlayerCharacter)tarAc;
+                            ChatManager.chatSystemInfo(debugged, "ZERG DEBUG: " + ac.getName() + " Hits You For: " + (int)damage + " instead of " + originalDamage);
+                        }
+                    }
+
+                    tarAc.cancelOnTakeDamage();
 
                 } else if (target.getObjectType().equals(GameObjectType.Building)) {
 
@@ -863,48 +1002,24 @@ public enum CombatManager {
                 errorTrack = 14;
 
                 //handle procs
-
+                procChanceHandler(weapon,ac,tarAc);
-                if (weapon != null && tarAc != null && tarAc.isAlive()) {
-
-                    ConcurrentHashMap<String, Effect> effects = weapon.getEffects();
-
-                    for (Effect eff : effects.values()) {
-                        if (eff == null)
-                            continue;
-
-                        HashSet<AbstractEffectModifier> aems = eff.getEffectModifiers();
-
-                        if (aems != null) {
-                            for (AbstractEffectModifier aem : aems) {
-
-                                if (!tarAc.isAlive())
-                                    break;
-
-                                if (aem instanceof WeaponProcEffectModifier) {
-
-                                    int procChance = ThreadLocalRandom.current().nextInt(100);
-
-                                    if (procChance < MBServerStatics.PROC_CHANCE)
-                                        ((WeaponProcEffectModifier) aem).applyProc(ac, target);
-
-                                }
-                            }
-                        }
-                    }
-                }
 
                 errorTrack = 15;
 
                 //handle damage shields
 
                 if (ac.isAlive() && tarAc != null && tarAc.isAlive())
+                    try {
                         handleDamageShields(ac, tarAc, damage);
+                    }catch(Exception e){
+                        Logger.error(e.getMessage());
+                    }
 
             } 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();
 
@@ -915,15 +1030,39 @@ public enum CombatManager {
                             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 {
                                     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());
+                }
                 errorTrack = 17;
 
                 //miss, Send miss message
@@ -946,6 +1085,41 @@ public enum CombatManager {
         }
     }
 
+    private static void procChanceHandler(Item weapon, AbstractCharacter ac, AbstractCharacter tarAc) {
+
+        //no weapon means no proc
+        if(weapon == null)
+            return;
+
+        //caster is dead of null, no proc
+        if(ac == null || !ac.isAlive())
+            return;
+
+        //target is dead or null, no proc
+        if(tarAc == null || !tarAc.isAlive())
+            return;
+
+        //no effects on weapon, skip proc
+        if(weapon.effects == null || weapon.effects.isEmpty())
+            return;
+
+        for (Effect eff : weapon.effects.values()){
+            for(AbstractEffectModifier mod : eff.getEffectModifiers()) {
+                if (mod.modType.equals(ModType.WeaponProc)) {
+                    int procChance = ThreadLocalRandom.current().nextInt(100);
+                    if (procChance < MBServerStatics.PROC_CHANCE) {
+                        try {
+                            ((WeaponProcEffectModifier) mod).applyProc(ac, tarAc);
+                            break;
+                        } catch (Exception e) {
+                            Logger.error(eff.getName() + " Failed To Cast Proc");
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     public static boolean canTestParry(AbstractCharacter ac, AbstractWorldObject target) {
 
         if (ac == null || target == null || !AbstractWorldObject.IsAbstractCharacter(target))
@@ -964,6 +1138,12 @@ public enum CombatManager {
         Item tarMain = tarItem.getItemFromEquipped(1);
         Item tarOff = tarItem.getItemFromEquipped(2);
 
+        if(target.getObjectType().equals(GameObjectType.PlayerCharacter)){
+            PlayerCharacter pc = (PlayerCharacter) target;
+            if(pc.getRaceID() == 1999 && !isRanged(acMain) && !isRanged(acOff))
+                return true;
+        }
+
         return !isRanged(acMain) && !isRanged(acOff) && !isRanged(tarMain) && !isRanged(tarOff);
     }
 
@@ -1022,9 +1202,11 @@ public enum CombatManager {
 
         //calculate resists in if any
 
+
+
         if (resists != null)
-            return resists.getResistedDamage(source, target, damageType, damage, 0);
+            damage = resists.getResistedDamage(source, target, damageType, damage, 0);
-        else
+
         return damage;
     }
 
@@ -1175,6 +1357,14 @@ public enum CombatManager {
 
     private static boolean testPassive(AbstractCharacter source, AbstractCharacter target, String type) {
 
+        if(target.getBonuses() != null)
+            if(target.getBonuses().getBool(ModType.Stunned, SourceType.None))
+                return false;
+
+        if(source.getBonuses() != null)
+            if(source.getBonuses().getBool(ModType.IgnorePassiveDefense, SourceType.None))
+                return false;
+
         float chance = target.getPassiveChance(type, source.getLevel(), true);
 
         if (chance == 0f)
@@ -1185,7 +1375,7 @@ public enum CombatManager {
         if (chance > 75f)
             chance = 75f;
 
-        int roll = ThreadLocalRandom.current().nextInt(100);
+        int roll = ThreadLocalRandom.current().nextInt(1,100);
 
         return roll < chance;
 
@@ -1237,13 +1427,16 @@ public enum CombatManager {
         DispatchMessage.dispatchMsgToInterestArea(pc, rwss, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
     }
 
-    private static void toggleSit(boolean toggle, ClientConnection origin) {
+    public static void toggleSit(boolean toggle, ClientConnection origin) {
 
         PlayerCharacter pc = SessionManager.getPlayerCharacter(origin);
 
         if (pc == null)
             return;
 
+        if(pc.isFlying())
+            pc.setSit(false);
+        else
             pc.setSit(toggle);
 
         UpdateStateMsg rwss = new UpdateStateMsg();
@@ -1322,6 +1515,13 @@ public enum CombatManager {
                 return;
 
             retaliater.setCombatTarget(ac);
+            if(retaliater.isPlayerGuard && (retaliater.BehaviourType.equals(MobBehaviourType.GuardMinion) || retaliater.BehaviourType.equals(MobBehaviourType.GuardCaptain))){
+                for(Mob guard : retaliater.guardedCity.getParent().zoneMobSet){
+                    if(guard.isPlayerGuard && guard.combatTarget == null){
+                        guard.setCombatTarget(ac);
+                    }
+                }
+            }
 
         }
     }
@@ -1353,9 +1553,9 @@ public enum CombatManager {
 
                 Resists resists = ac.getResists();
 
-                if (resists != null)
+                if (resists != null) {
                     amount = resists.getResistedDamage(target, ac, ds.getDamageType(), amount, 0);
-
+                }
                 total += amount;
             }
 
@@ -1438,4 +1638,31 @@ public enum CombatManager {
             ((AbstractCharacter) awo).getCharItemManager().damageRandomArmor(1);
     }
 
+    public static boolean LandHit(int ATR, int DEF){
+
+        //float chance = (ATR-((ATR+DEF) * 0.315f)) / ((DEF-((ATR+DEF) * 0.315f)) + (ATR-((ATR+DEF) * 0.315f)));
+        //float convertedChance = chance * 100;
+
+        int roll = ThreadLocalRandom.current().nextInt(101);
+
+        //if(roll <= 5)//always 5% chance to miss
+        //    return false;
+
+        //if(roll >= 95)//always 5% chance to hit
+        //    return true;
+
+        float chance = PlayerCombatStats.getHitChance(ATR,DEF);
+        return chance >= roll;
+    }
+
+    public static boolean specialCaseHitRoll(int powerID){
+        switch(powerID) {
+            case 563200808: // Naargal's Bite
+            case 563205337: // Naargal's Dart
+            case 563205930: // Sword of Saint Malorn
+                return true;
+            default:
+                return false;
+        }
+    }
 }

src/engine/gameManager/ConfigManager.java

@@ -65,6 +65,7 @@ public enum ConfigManager {
     MB_WORLD_MAINTENANCE,
     MB_WORLD_GREETING,
     MB_WORLD_KEYCLONE_MAX,
+    MB_WORLD_TESTMODE,
     MB_USE_RUINS,
 
     // Mobile AI modifiers
@@ -97,7 +98,8 @@ public enum ConfigManager {
     MB_MAGICBOT_FORTOFIX,
     MB_MAGICBOT_RECRUIT,
     MB_MAGICBOT_MAGICBOX,
-    MB_MAGICBOT_ADMINLOG;
+    MB_MAGICBOT_ADMINLOG,
+    MB_WORLD_BOXLIMIT;
 
     // Map to hold our config pulled in from the environment
     // We also use the config to point to the current message pump

src/engine/gameManager/DevCmdManager.java

@@ -79,13 +79,13 @@ public enum DevCmdManager {
         DevCmdManager.registerDevCmd(new AddGoldCmd());
         DevCmdManager.registerDevCmd(new ZoneInfoCmd());
         DevCmdManager.registerDevCmd(new DebugMeleeSyncCmd());
-        DevCmdManager.registerDevCmd(new HotzoneCmd());
         DevCmdManager.registerDevCmd(new MineActiveCmd());
         // Dev
         DevCmdManager.registerDevCmd(new ApplyStatModCmd());
         DevCmdManager.registerDevCmd(new AddBuildingCmd());
         DevCmdManager.registerDevCmd(new AddNPCCmd());
         DevCmdManager.registerDevCmd(new AddMobCmd());
+        DevCmdManager.registerDevCmd(new DungenonCmd());
         DevCmdManager.registerDevCmd(new RemoveObjectCmd());
         DevCmdManager.registerDevCmd(new RotateCmd());
         DevCmdManager.registerDevCmd(new FlashMsgCmd());
@@ -103,6 +103,7 @@ public enum DevCmdManager {
         DevCmdManager.registerDevCmd(new SetAdminRuneCmd());
         DevCmdManager.registerDevCmd(new SetInvulCmd());
         DevCmdManager.registerDevCmd(new MakeItemCmd());
+        DevCmdManager.registerDevCmd(new GimmeCmd());
         DevCmdManager.registerDevCmd(new EnchantCmd());
         DevCmdManager.registerDevCmd(new SetSubRaceCmd());
         // Admin
@@ -177,10 +178,44 @@ public enum DevCmdManager {
             return false;
         }
 
+        if(!pcSender.getTimestamps().containsKey("DEVCOMMAND"))
+            pcSender.getTimestamps().put("DEVCOMMAND",System.currentTimeMillis() - 1500L);
+        else if(System.currentTimeMillis() - pcSender.getTimestamps().get("DEVCOMMAND") < 1000L)
+            return false;
+
         //kill any commands not available to everyone on production server
         //only admin level can run dev commands on production
-
+        boolean playerAllowed = false;
-        if (a.status.equals(Enum.AccountStatus.ADMIN) == false) {
+        if(ConfigManager.MB_WORLD_TESTMODE.getValue().equals("true")) {
+            switch (adc.getMainCmdString()) {
+                case "printresists":
+                case "printstats":
+                case "printskills":
+                case "printpowers":
+                case "gimme":
+                case "goto":
+                case "teleportmode":
+                case "printbonuses":
+                    playerAllowed = true;
+                    if (!a.status.equals(Enum.AccountStatus.ADMIN))
+                        target = pcSender;
+                    break;
+            }
+        }else{
+            switch (adc.getMainCmdString()) {
+                case "printresists":
+                case "printstats":
+                case "printskills":
+                case "printpowers":
+                case "printbonuses":
+                //case "gimme":
+                    playerAllowed = true;
+                    if (!a.status.equals(Enum.AccountStatus.ADMIN))
+                        target = pcSender;
+                    break;
+            }
+        }
+        if (!playerAllowed && !a.status.equals(Enum.AccountStatus.ADMIN)) {
             Logger.info("Account " + a.getUname() + "attempted to use dev command " + cmd);
             return false;
         }

src/engine/gameManager/ForgeManager.java

@@ -0,0 +1,15 @@
+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/LootManager.java

@@ -14,10 +14,10 @@ import engine.net.DispatchMessage;
 import engine.net.client.msg.ErrorPopupMsg;
 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.*;
-import java.util.HashMap;
 import java.util.concurrent.ThreadLocalRandom;
 
 /**
@@ -34,6 +34,21 @@ public enum LootManager {
     public static HashMap<Integer, ArrayList<ModTableEntry>> _modTables = new HashMap<>();
     public static HashMap<Integer, ArrayList<ModTypeTableEntry>> _modTypeTables = new HashMap<>();
 
+    public static final ArrayList<Integer> vorg_ha_uuids = new ArrayList<>(Arrays.asList(27580, 27590, 188500, 188510, 188520, 188530, 188540, 188550, 189510));
+    public static final ArrayList<Integer> vorg_ma_uuids = new ArrayList<>(Arrays.asList(27570,188900,188910,188920,188930,188940,188950,189500));
+    public static final ArrayList<Integer> vorg_la_uuids = new ArrayList<>(Arrays.asList(27550,27560,189100,189110,189120,189130,189140,189150));
+    public static final ArrayList<Integer> vorg_cloth_uuids = new ArrayList<>(Arrays.asList(27600,188700,188720,189550,189560));
+    public static final ArrayList<Integer> racial_guard_uuids = new ArrayList<>(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 ArrayList<Integer> static_rune_ids = new ArrayList<>(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,
+            250115, 250118, 250119, 250120, 250121, 250122, 252123, 252124, 252125, 252126,
+            252127
+    ));
+
     // Drop Rates
 
     public static float NORMAL_DROP_RATE;
@@ -68,25 +83,59 @@ public enum LootManager {
 
     public static void GenerateMobLoot(Mob mob) {
 
+        if(mob == null){
+            return;
+        }
+
+        if(!mob.getSafeZone()) {
+            SpecialLootHandler.RollContract(mob);
+            SpecialLootHandler.RollGlass(mob);
+            SpecialLootHandler.RollRune(mob);
+            SpecialLootHandler.RollRacialGuard(mob);
+            SpecialLootHandler.ResourceDrop(mob);
+        }
+
         //determine if mob is in hotzone
-        boolean inHotzone = ZoneManager.inHotZone(mob.getLoc());
+        boolean inHotzone = false;
 
         //iterate the booty sets
 
-        if (mob.getMobBase().bootySet != 0 && _bootySetMap.containsKey(mob.getMobBase().bootySet) == true)
+        if(mob.mobBase == null || mob.getMobBaseID() == 253003){
+            int i = 0;
+        }
+
+        if (mob.getMobBase().bootySet != 0 && _bootySetMap.containsKey(mob.getMobBase().bootySet))
             RunBootySet(_bootySetMap.get(mob.getMobBase().bootySet), mob, inHotzone);
 
-        if (mob.bootySet != 0 && _bootySetMap.containsKey(mob.bootySet) == true)
+        if (mob.bootySet != 0 && _bootySetMap.containsKey(mob.bootySet)) {
             RunBootySet(_bootySetMap.get(mob.bootySet), mob, inHotzone);
+        }else if(mob.bootySet != 0 && ItemBase.getItemBase(mob.bootySet) != null){
+            MobLoot specialDrop = null;
+            specialDrop = new MobLoot(mob,ItemBase.getItemBase(mob.bootySet),true);
+            if(specialDrop != null) {
+                ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + mob.getParentZone().getName() + " has found the " + specialDrop.getName() + ". Are you tough enough to take it?");
+                chatMsg.setMessageType(10);
+                chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+                DispatchMessage.dispatchMsgToAll(chatMsg);
+                mob.getCharItemManager().addItemToInventory(specialDrop);
+                mob.setResists(new Resists("Dropper"));
+                if(!Mob.discDroppers.contains(mob))
+                    Mob.AddDiscDropper(mob);
+            }
+
+        }
 
         //lastly, check mobs inventory for godly or disc runes to send a server announcement
         for (Item it : mob.getInventory()) {
 
             ItemBase ib = it.getItemBase();
-                if(ib == null)
+            if (ib == null)
                 break;
             if (ib.isDiscRune() || ib.getName().toLowerCase().contains("of the gods")) {
-                    ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + mob.getParentZone().getName() + " has found the " + ib.getName() + ". Are you tough enough to take it?");
+                Zone camp = mob.getParentZone();
+                Zone macro = camp.getParent();
+                String name = camp.getName() + "(" + macro.getName() + ")";
+                ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + name + " has found the " + ib.getName() + ". Are you tough enough to take it?");
                 chatMsg.setMessageType(10);
                 chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
                 DispatchMessage.dispatchMsgToAll(chatMsg);
@@ -98,18 +147,21 @@ public enum LootManager {
     private static void RunBootySet(ArrayList<BootySetEntry> entries, Mob mob, boolean inHotzone) {
 
         boolean hotzoneWasRan = false;
-        float dropRate = 1.0f;
+        float dropRate;
 
         // Iterate all entries in this bootySet and process accordingly
-
+        Zone zone = ZoneManager.findSmallestZone(mob.loc);
         for (BootySetEntry bse : entries) {
             switch (bse.bootyType) {
                 case "GOLD":
+                    if (zone != null && zone.getSafeZone() == (byte)1)
+                        return; // no loot to drop in safezones
                     GenerateGoldDrop(mob, bse, inHotzone);
                     break;
                 case "LOOT":
+                    if (zone != null && zone.getSafeZone() == (byte)1)
+                        return; // no loot to drop in safezones
 
-                    if (mob.getSafeZone() == false)
                     dropRate = LootManager.NORMAL_DROP_RATE;
 
                     if (inHotzone == true)
@@ -156,11 +208,10 @@ public enum LootManager {
 
         //gets the 1-320 roll for this mob
         int itemTableRoll = 0;
-        int objectType = mob.getObjectType().ordinal();
         if(mob.getObjectType().ordinal() == 52) { //52 = player character
             itemTableRoll = ThreadLocalRandom.current().nextInt(1,320 + 1);
         } else{
-            itemTableRoll = TableRoll(mob.level, inHotzone);
+            itemTableRoll = TableRoll(mob.level);
         }
         ItemTableEntry tableRow = ItemTableEntry.rollTable(itemTableId, itemTableRoll);
         if (tableRow == null)
@@ -171,14 +222,11 @@ public enum LootManager {
         if (itemUUID == 0)
             return null;
 
-        if (ItemBase.getItemBase(itemUUID).getType().ordinal() == Enum.ItemType.RESOURCE.ordinal()) {
+        ItemBase ib = ItemBase.getItemBase(itemUUID);
-            int amount = ThreadLocalRandom.current().nextInt(tableRow.minSpawn, tableRow.maxSpawn + 1);
+        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 new MobLoot(mob, ItemBase.getItemBase(itemUUID), amount, false);
+            return null;
-        }
-
-        outItem = new MobLoot(mob, ItemBase.getItemBase(itemUUID), false);
-        Enum.ItemType outType = outItem.getItemBase().getType();
 
+        outItem = new MobLoot(mob, ib, false);
 
         if(selectedRow.pModTable != 0){
             try {
@@ -196,6 +244,7 @@ public enum LootManager {
                 Logger.error("Failed to GenerateSuffix for item: " + outItem.getName());
             }
         }
+
         return outItem;
     }
 
@@ -216,7 +265,7 @@ public enum LootManager {
         if(mob.getObjectType().ordinal() == 52) {
             prefixTableRoll = ThreadLocalRandom.current().nextInt(1,320 + 1);
         } else{
-            prefixTableRoll = TableRoll(mob.level, inHotzone);
+            prefixTableRoll = TableRoll(mob.level);
         }
         ModTableEntry prefixMod = ModTableEntry.rollTable(prefixTable.modTableID, prefixTableRoll);
 
@@ -224,8 +273,23 @@ public enum LootManager {
             return inItem;
 
         if (prefixMod.action.length() > 0) {
-            inItem.setPrefix(prefixMod.action);
+            String action = prefixMod.action;
-            inItem.addPermanentEnchantment(prefixMod.action, 0, prefixMod.level, true);
+            if(action.equals("PRE-108") || action.equals("PRE-058") || action.equals("PRE-031")){//massive, barons and avatars to be replaced by leg or warlords
+                int roll = ThreadLocalRandom.current().nextInt(1,100);
+                if(inItem.getItemBase().getRange() > 15){
+                    action = "PRE-040";
+                }else {
+                    if (roll > 50) {
+                        //set warlords
+                        action = "PRE-021";
+                    } else {
+                        //set legendary
+                        action = "PRE-040";
+                    }
+                }
+            }
+            inItem.setPrefix(action);
+            inItem.addPermanentEnchantment(action, 0, prefixMod.level, true);
         }
 
         return inItem;
@@ -248,14 +312,34 @@ public enum LootManager {
         if(mob.getObjectType().ordinal() == 52) {
             suffixTableRoll = ThreadLocalRandom.current().nextInt(1,320 + 1);
         } else{
-            suffixTableRoll = TableRoll(mob.level, inHotzone);
+            suffixTableRoll = TableRoll(mob.level);
         }
         ModTableEntry suffixMod = ModTableEntry.rollTable(suffixTable.modTableID, suffixTableRoll);
 
         if (suffixMod == null)
             return inItem;
 
-        if (suffixMod.action.length() > 0) {
+        int moveSpeedRoll = ThreadLocalRandom.current().nextInt(100);
+        if(inItem.getItemBase().getValidSlot() == MBServerStatics.SLOT_FEET && moveSpeedRoll < 10){
+            int rankRoll = ThreadLocalRandom.current().nextInt(10);
+            String suffixSpeed = "SUF-148";
+            switch(rankRoll) {
+                case 1:
+                case 2:
+                case 3:
+                    suffixSpeed = "SUF-149";
+                    break;
+                case 4:
+                case 5:
+                case 6:
+                case 7:
+                    suffixSpeed = "SUF-150";
+                    break;
+
+            }
+            inItem.setSuffix(suffixSpeed);
+            inItem.addPermanentEnchantment(suffixSpeed, 0, suffixMod.level, false);
+        }else if (suffixMod.action.length() > 0) {
             inItem.setSuffix(suffixMod.action);
             inItem.addPermanentEnchantment(suffixMod.action, 0, suffixMod.level, false);
         }
@@ -263,23 +347,36 @@ public enum LootManager {
         return inItem;
     }
 
-    public static int TableRoll(int mobLevel, Boolean inHotzone) {
+    public static int TableRoll(int mobLevel) {
-
-        if (mobLevel > 65)
-            mobLevel = 65;
-
-        int max = (int) (4.882 * mobLevel + 127.0);
 
-        if (max > 319)
+        int rank = (int)(mobLevel * 0.1f);
-            max = 319;
+        int min = 50;
-
+        int max = 100;
-        int min = (int) (4.469 * mobLevel - 3.469);
+        switch(rank){
-
+            case 1:
-        if (min < 70)
+                min = 200;
-            min = 70;
+                max = 250;
-
+                break;
-        if (inHotzone)
+            case 2:
-            min += mobLevel;
+                min = 210;
+                max = 275;
+                break;
+            case 3:
+                min = 220;
+                max = 300;
+                break;
+            case 4:
+                min = 230;
+                max = 320;
+                break;
+            case 5:
+            case 6:
+            case 7:
+            case 8:
+                min = 240;
+                max = 320;
+                break;
+        }
 
         int roll = ThreadLocalRandom.current().nextInt(min, max + 1);
 
@@ -299,12 +396,7 @@ public enum LootManager {
 
         int high = bse.highGold;
         int low = bse.lowGold;
-        int gold = ThreadLocalRandom.current().nextInt(low, high + 1);
+        int gold = (int) (ThreadLocalRandom.current().nextInt(low, high + 1) * NORMAL_GOLD_RATE);
-
-        if (inHotzone == true)
-            gold = (int) (gold * HOTZONE_GOLD_RATE);
-        else
-            gold = (int) (gold * NORMAL_GOLD_RATE);
 
         if (gold > 0) {
             MobLoot goldAmount = new MobLoot(mob, gold);
@@ -315,43 +407,65 @@ public enum LootManager {
 
     public static void GenerateLootDrop(Mob mob, int tableID, Boolean inHotzone) {
 
-        try {
-
         MobLoot toAdd = getGenTableItem(tableID, mob, inHotzone);
+        if(toAdd != null){
+            ItemBase ib = toAdd.getItemBase();
+            switch(ib.getType()){
+                case CONTRACT:
+                case RUNE:
+                case RESOURCE:
+                    return;
+            }
 
-            if (toAdd != null)
+            if (ib.getUUID() == 1580021)//mithril
-                mob.getCharItemManager().addItemToInventory(toAdd);
+                return;
 
-        } catch (Exception e) {
+            toAdd.setIsID(true);
-            //TODO chase down loot generation error, affects roughly 2% of drops
+            mob.getCharItemManager().addItemToInventory(toAdd);
-            int i = 0;
         }
     }
 
+
     public static void GenerateEquipmentDrop(Mob mob) {
 
+        if (mob == null || mob.getSafeZone())
+            return; // no equipment to drop in safezones
+
+        if(mob.StrongholdGuardian || mob.StrongholdCommander || mob.StrongholdEpic)
+            return; // stronghold mobs don't drop equipment
+
         //do equipment here
-        int dropCount = 0;
+        if (mob.getEquip() != null) {
-        if (mob.getEquip() != null)
+            boolean isVorg = false;
             for (MobEquipment me : mob.getEquip().values()) {
 
                 if (me.getDropChance() == 0)
                     continue;
 
+                String name = me.getItemBase().getName().toLowerCase();
+                if (name.contains("vorgrim legionnaire's") || name.contains("vorgrim auxiliary's") ||name.contains("bellugh nuathal") || name.contains("crimson circle"))
+                    isVorg = true;
+
+                if(isVorg && !mob.isDropper){
+                    continue;
+                }
+
                 float equipmentRoll = ThreadLocalRandom.current().nextInt(1, 100 + 1);
                 float dropChance = me.getDropChance() * 100;
-
+                ItemBase itemBase = me.getItemBase();
+                if(isVorg) {
+                    mob.spawnTime = ThreadLocalRandom.current().nextInt(300, 2700);
+                    dropChance = 7.5f;
+                    itemBase = getRandomVorg(itemBase);
+                }
                 if (equipmentRoll > dropChance)
                     continue;
 
-                MobLoot ml = new MobLoot(mob, me.getItemBase(), false);
+                MobLoot ml = new MobLoot(mob, itemBase, false);
 
-                if (ml != null && dropCount < 1) {
                 ml.setIsID(true);
                 ml.setDurabilityCurrent((short) (ml.getDurabilityCurrent() - ThreadLocalRandom.current().nextInt(5) + 1));
                 mob.getCharItemManager().addItemToInventory(ml);
-                    dropCount = 1;
-                    //break; // Exit on first successful roll.
             }
         }
     }
@@ -365,12 +479,134 @@ public enum LootManager {
         if (chanceRoll > bse.dropChance)
             return;
 
+        if(bse.itemBase == 1580021)//mithril
+            return;
         MobLoot lootItem = new MobLoot(mob, ItemBase.getItemBase(bse.itemBase), true);
 
-        if (lootItem != null)
+        if (lootItem != null) {
             mob.getCharItemManager().addItemToInventory(lootItem);
+            if(lootItem.getItemBase().isDiscRune() && !Mob.discDroppers.contains(mob))
+                Mob.AddDiscDropper(mob);
+        }
+    }
+
+    public static void newFatePeddler(PlayerCharacter playerCharacter, Item gift) {
+
+        CharacterItemManager itemMan = playerCharacter.getCharItemManager();
+
+        if (itemMan == null)
+            return;
+
+        //check if player owns the gift he is trying to open
+
+        if (!itemMan.doesCharOwnThisItem(gift.getObjectUUID()))
+            return;
+
+        ItemBase ib = gift.getItemBase();
+
+        MobLoot winnings = null;
+
+        if (ib == null)
+            return;
+        switch (ib.getUUID()) {
+            case 971070: //wrapped rune
+                Random random = new Random();
+                int roll = random.nextInt(100);
+                int itemId;
+                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);
+                    try {
+                        itemId = SpecialLootHandler.static_rune_ids_high.get(roll);
+                   } catch (Exception e) {
+
+                    }
+                  runeBase = ItemBase.getItemBase(itemId);
+                   if (runeBase != null) {
+                       MobLoot rune = new MobLoot(playerCharacter, runeBase, true);
+
+                       if (rune != null)
+                           playerCharacter.getCharItemManager().addItemToInventory(rune);
+                   }
+                } 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);
+                    try {
+                        itemId = SpecialLootHandler.static_rune_ids_mid.get(roll);
+                   } catch (Exception e) {
+
+                    }
+                    runeBase = ItemBase.getItemBase(itemId);
+                    if (runeBase != null) {
+                        MobLoot rune = new MobLoot(playerCharacter, runeBase, true);
+
+                        if (rune != null)
+                            playerCharacter.getCharItemManager().addItemToInventory(rune.promoteToItem(playerCharacter));
+                    }
+                 } else {
+                //5-30
+                     roll = ThreadLocalRandom.current().nextInt(SpecialLootHandler.static_rune_ids_low.size() + 1);
+                     itemId = SpecialLootHandler.static_rune_ids_low.get(0);
+                    try {
+                        itemId = SpecialLootHandler.static_rune_ids_low.get(roll);
+                    } catch (Exception ignored) {
+
+                   }
+                   runeBase = ItemBase.getItemBase(itemId);
+                   if (runeBase != null) {
+                       MobLoot rune = new MobLoot(playerCharacter, runeBase, true);
+
+                        if (rune != null)
+                            playerCharacter.getCharItemManager().addItemToInventory(rune.promoteToItem(playerCharacter));
+                    }
+                }
+                break;
+            case 971012: //wrapped glass
+                int chance = ThreadLocalRandom.current().nextInt(100);
+                if(chance == 50){
+                    int ID = 7000000;
+                    int additional = ThreadLocalRandom.current().nextInt(0,28);
+                    ID += (additional * 10);
+                    ItemBase glassBase = ItemBase.getItemBase(ID);
+                    if(glassBase != null) {
+                        winnings = new MobLoot(playerCharacter, glassBase, 1, false);
+                        ChatManager.chatSystemInfo(playerCharacter, "You've Won A " + glassBase.getName());
+                    }
+                }else{
+                    ChatManager.chatSystemInfo(playerCharacter, "Please Try Again!");
+                }
+                break;
         }
 
+        if (winnings == null) {
+            itemMan.consume(gift);
+            itemMan.updateInventory();
+            return;
+        }
+
+        //early exit if the inventory of the player will not hold the item
+
+        if (!itemMan.hasRoomInventory(winnings.getItemBase().getWeight())) {
+            ErrorPopupMsg.sendErrorPopup(playerCharacter, 21);
+            return;
+        }
+
+        winnings.setIsID(true);
+
+        //remove gift from inventory
+
+        itemMan.consume(gift);
+
+        //add winnings to player inventory
+
+        Item playerWinnings = winnings.promoteToItem(playerCharacter);
+        itemMan.addItemToInventory(playerWinnings);
+        itemMan.updateInventory();
+
+    }
     public static void peddleFate(PlayerCharacter playerCharacter, Item gift) {
 
         //get table ID for the itembase ID
@@ -392,12 +628,12 @@ public enum LootManager {
 
         //check if player owns the gift he is trying to open
 
-        if (itemMan.doesCharOwnThisItem(gift.getObjectUUID()) == false)
+        if (!itemMan.doesCharOwnThisItem(gift.getObjectUUID()))
             return;
 
         //roll 1-100 for the gen table selection
 
-        int genRoll = ThreadLocalRandom.current().nextInt(1, 100 + 1);
+        int genRoll = ThreadLocalRandom.current().nextInt(94, 100) + 1;
         GenTableEntry selectedRow = GenTableEntry.rollTable(tableID, genRoll, LootManager.NORMAL_DROP_RATE);
 
         if(selectedRow == null)
@@ -413,12 +649,22 @@ public enum LootManager {
 
         //create the item from the table, quantity is always 1
 
-        MobLoot winnings = new MobLoot(playerCharacter, ItemBase.getItemBase(selectedItem.cacheID), 1, false);
+        ItemBase ib = ItemBase.getItemBase(selectedItem.cacheID);
+        if(ib.getUUID() == Warehouse.coalIB.getUUID()){
+            //no more coal, give gold instead
+            if (itemMan.getGoldInventory().getNumOfItems() + 250000 > MBServerStatics.PLAYER_GOLD_LIMIT) {
+                ErrorPopupMsg.sendErrorPopup(playerCharacter, 21);
+                return;
+            }
+            itemMan.addGoldToInventory(250000,false);
+            itemMan.updateInventory();
+        }else {
+            MobLoot winnings = new MobLoot(playerCharacter, ib, 1, false);
 
             if (winnings == null)
                 return;
 
-        //early exit if the inventory of the player will not old the item
+            //early exit if the inventory of the player will not hold the item
 
             if (itemMan.hasRoomInventory(winnings.getItemBase().getWeight()) == false) {
                 ErrorPopupMsg.sendErrorPopup(playerCharacter, 21);
@@ -427,17 +673,17 @@ public enum LootManager {
 
             //determine if the winning item needs a prefix
 
-        if(selectedRow.pModTable != 0){
+            if (selectedRow.pModTable != 0) {
-            int prefixRoll = ThreadLocalRandom.current().nextInt(220,320 + 1);
+                int prefixRoll = ThreadLocalRandom.current().nextInt(220, 320 + 1);
                 ModTableEntry prefix = ModTableEntry.rollTable(selectedRow.pModTable, prefixRoll);
-            if(prefix != null)
+                if (prefix != null)
                     winnings.addPermanentEnchantment(prefix.action, 0, prefix.level, true);
             }
 
             //determine if the winning item needs a suffix
 
-        if(selectedRow.sModTable != 0){
+            if (selectedRow.sModTable != 0) {
-            int suffixRoll = ThreadLocalRandom.current().nextInt(220,320 + 1);
+                int suffixRoll = ThreadLocalRandom.current().nextInt(220, 320 + 1);
                 ModTableEntry suffix = ModTableEntry.rollTable(selectedRow.sModTable, suffixRoll);
                 if (suffix != null)
                     winnings.addPermanentEnchantment(suffix.action, 0, suffix.level, true);
@@ -454,4 +700,225 @@ public enum LootManager {
             itemMan.addItemToInventory(playerWinnings);
             itemMan.updateInventory();
         }
+    }
+
+    public static int rollRandomItem(int itemTable){
+        int returnedID = ItemTableEntry.getRandomItem(itemTable);
+        return returnedID;
+    }
+
+    public static ItemBase getRandomVorg(ItemBase itemBase){
+        int roll = 0;
+        if(vorg_ha_uuids.contains(itemBase.getUUID())) {
+            roll = ThreadLocalRandom.current().nextInt(0, 9);
+            switch (roll) {
+                case 1:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(0));
+                case 2:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(1));
+                case 3:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(2));
+                case 4:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(3));
+                case 5:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(4));
+                case 6:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(5));
+                case 7:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(6));
+                case 8:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(7));
+                default:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(8));
+            }
+        }
+
+        if(vorg_ma_uuids.contains(itemBase.getUUID())) {
+            roll = ThreadLocalRandom.current().nextInt(0, 8);
+            switch (roll) {
+                case 1:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(0));
+                case 2:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(1));
+                case 3:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(2));
+                case 4:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(3));
+                case 5:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(4));
+                case 6:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(5));
+                case 7:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(6));
+                default:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(7));
+            }
+        }
+
+        if(vorg_la_uuids.contains(itemBase.getUUID())) {
+            roll = ThreadLocalRandom.current().nextInt(0, 8);
+            switch (roll) {
+                case 1:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(0));
+                case 2:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(1));
+                case 3:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(2));
+                case 4:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(3));
+                case 5:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(4));
+                case 6:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(5));
+                case 7:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(6));
+                default:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(7));
+            }
+        }
+
+        if(vorg_cloth_uuids.contains(itemBase.getUUID())) {
+            roll = ThreadLocalRandom.current().nextInt(0, 5);
+            switch (roll) {
+                case 1:
+                    return ItemBase.getItemBase(vorg_cloth_uuids.get(0));
+                case 2:
+                    return ItemBase.getItemBase(vorg_cloth_uuids.get(1));
+                case 3:
+                    return ItemBase.getItemBase(vorg_cloth_uuids.get(2));
+                case 4:
+                    return ItemBase.getItemBase(vorg_cloth_uuids.get(3));
+                default:
+                    return ItemBase.getItemBase(vorg_cloth_uuids.get(4));
+            }
+        }
+
+        return null;
+    }
+
+    public static void DropPresent(Mob mob){
+        int random = 971049 + ThreadLocalRandom.current().nextInt(24);
+        if (random > 971071)
+            random = 971071;
+
+        ItemBase present = ItemBase.getItemBase(random);
+        if (present != null) {
+            MobLoot toAdd = new MobLoot(mob, present, true);
+
+            if (toAdd != null)
+                mob.getCharItemManager().addItemToInventory(toAdd);
+        }
+    }
+
+    public static void GenerateStrongholdLoot(Mob mob, boolean commander, boolean epic) {
+
+        mob.getCharItemManager().clearInventory();
+
+        int multiplier = 1;
+        if (commander)
+            multiplier = 2;
+        if(epic)
+            multiplier = 10;
+
+        int high = 125000;
+        int low = 50000;
+        int gold = ThreadLocalRandom.current().nextInt(low, high + 1) * multiplier;
+
+        if (gold > 0) {
+            MobLoot goldAmount = new MobLoot(mob, gold);
+            mob.getCharItemManager().addItemToInventory(goldAmount);
+        }
+
+        //present drop chance for all
+        //if (ThreadLocalRandom.current().nextInt(100) < 35)
+        //    DropPresent(mob);
+
+        //random contract drop chance for all
+        if (ThreadLocalRandom.current().nextInt(100) < 40) {
+            int contractTableID = 250;
+            contractTableID += ThreadLocalRandom.current().nextInt(0, 11);
+            if (contractTableID > 259)
+                contractTableID = 659;
+
+                int id = rollRandomItem(contractTableID);
+                ItemBase ib = ItemBase.getItemBase(id);
+                if (ib != null) {
+                    MobLoot contract = new MobLoot(mob, ib, true);
+
+                    if (contract != null)
+                        mob.getCharItemManager().addItemToInventory(contract);
+                }
+        }
+
+        //special commander drop chances
+        if (commander)
+            GenerateCommanderLoot(mob,false);
+
+        //special epic drop chances
+        if (epic) {
+            GenerateCommanderLoot(mob, true);
+            GenerateCommanderLoot(mob,false);
+        }
+    }
+
+    public static void GenerateCommanderLoot(Mob mob, boolean epic){
+        //present chance
+        if (ThreadLocalRandom.current().nextInt(100) < 25)
+            DropPresent(mob);
+
+        //present chance
+        if (ThreadLocalRandom.current().nextInt(100) < 25)
+            DropPresent(mob);
+
+        //chance for glass
+        if (ThreadLocalRandom.current().nextInt(100) < 75) {
+            int glassID = rollRandomItem(126);
+            ItemBase glassItem = ItemBase.getItemBase(glassID);
+            if (glassItem != null) {
+                MobLoot toAdd2 = new MobLoot(mob, glassItem, true);
+
+                if (toAdd2 != null)
+                    mob.getCharItemManager().addItemToInventory(toAdd2);
+            }
+        }
+
+        //chance for disc
+        if (ThreadLocalRandom.current().nextInt(100) < 75) {
+            int discID = rollRandomItem(3202);
+            ItemBase discItem = ItemBase.getItemBase(discID);
+            if (discItem != null) {
+                MobLoot toAdd3 = new MobLoot(mob, discItem, true);
+
+                if (toAdd3 != null)
+                    mob.getCharItemManager().addItemToInventory(toAdd3);
+            }
+        }
+
+        //chance for stat rune
+        if (ThreadLocalRandom.current().nextInt(100) < 75) {
+            int runeID = rollRandomItem(3201);
+            ItemBase runeItem = ItemBase.getItemBase(runeID);
+            if (runeItem != null) {
+                MobLoot toAdd4 = new MobLoot(mob, runeItem, true);
+
+                if (toAdd4 != null)
+                    mob.getCharItemManager().addItemToInventory(toAdd4);
+            }
+        }
+        if(epic){
+            int contractTableID = 250;
+            contractTableID += ThreadLocalRandom.current().nextInt(0, 11);
+            if (contractTableID > 259)
+                contractTableID = 659;
+
+            int id = rollRandomItem(contractTableID);
+            ItemBase ib = ItemBase.getItemBase(id);
+            if (ib != null) {
+                MobLoot contract = new MobLoot(mob, ib, true);
+
+                if (contract != null)
+                    mob.getCharItemManager().addItemToInventory(contract);
+            }
+        }
+    }
 }

src/engine/gameManager/MaintenanceManager.java

@@ -24,7 +24,7 @@ public enum MaintenanceManager {
 
     public static void setMaintDateTime(Building building, LocalDateTime maintDate) {
 
-        building.maintDateTime = maintDate;
+        building.maintDateTime = maintDate.withHour(1).withMinute(0).withSecond(0);
         DbManager.BuildingQueries.updateMaintDate(building);
 
     }
@@ -49,19 +49,15 @@ public enum MaintenanceManager {
 
             if (chargeUpkeep(building) == false)
                 derankList.add(building);
-        }
+            else
-        // Reset maintenance dates for these buildings
-
-        for (Building building : maintList) {
                 setMaintDateTime(building, LocalDateTime.now().plusDays(7));
-
         }
-        // Derak or destroy buildings that did not
-        // have funds available.
 
-        for (Building building : derankList)
+        for (Building building : derankList) {
             building.destroyOrDerank(null);
-
+            if(building.getRank() > 0)
+                setMaintDateTime(building, LocalDateTime.now().plusDays(1));
+        }
         Logger.info("Structures: " + buildingList.size() + " Maint: " + maintList.size() + " Derank: " + derankList.size());
     }
 
@@ -98,6 +94,10 @@ public enum MaintenanceManager {
                 continue;
             }
 
+            //only ToL pays maintenance
+            if(building.getBlueprint().getBuildingGroup() != null && !building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.TOL))
+                continue;
+
             // No maintenance on banestones omfg
 
             if (building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.BANESTONE))
@@ -122,9 +122,9 @@ public enum MaintenanceManager {
 
 
             //no maintenance if day of week doesnt match
-            if (LocalDateTime.now().getDayOfWeek().ordinal() != building.maintDateTime.getDayOfWeek().ordinal()) {
+            //if (LocalDateTime.now().getDayOfWeek().ordinal() != building.maintDateTime.getDayOfWeek().ordinal()) {
-                continue;
+            //    continue;
-            }
+            //}
             //  Add building to maintenance queue
 
             maintList.add(building);
@@ -186,49 +186,8 @@ public enum MaintenanceManager {
         // If this is an R8 tree, validate that we can
         // cover the resources required
 
-        if (building.getRank() == 8) {
-
-            hasResources = true;
-
-            if (warehouse == null)
-                hasResources = false;
-            else {
-
-                resourceValue = warehouse.getResources().get(Warehouse.stoneIB);
-
-                if (resourceValue < 1500)
-                    hasResources = false;
-
-                resourceValue = warehouse.getResources().get(Warehouse.lumberIB);
-
-                if (resourceValue < 1500)
-                    hasResources = false;
-
-                resourceValue = warehouse.getResources().get(Warehouse.galvorIB);
-
-                if (resourceValue < 5)
-                    hasResources = false;
-
-                resourceValue = warehouse.getResources().get(Warehouse.wormwoodIB);
-
-                if (resourceValue < 5)
-                    hasResources = false;
-
-            }
-        }
-        // Validation completed but has failed.  We can derank
-        // the target building and early exit
-
-        if ((hasFunds == false) ||
-                ((building.getRank() == 8) && !hasResources)) {
-
-            // Add cash back to strongbox for lost rank if the building isn't being destroyed
-            // and it's not an R8 deranking
-
-            if ((building.getRank() > 1) && (building.getRank() < 8)) {
-                building.setStrongboxValue(building.getStrongboxValue() + building.getBlueprint().getRankCost(Math.min(building.getRank(), 7)));
-            }
 
+        if (hasFunds == false) {
             return false; // Early exit for having failed to meet maintenance
         }
 
@@ -253,58 +212,6 @@ public enum MaintenanceManager {
             }
         }
 
-        // Early exit as we're done if we're not an R8 tree
-
-        if (building.getRank() < 8)
-            return true;
-
-        // Now for the resources if it's an R8 tree
-
-        // Withdraw Stone
-
-        resourceValue = warehouse.getResources().get(Warehouse.stoneIB);
-
-        if (DbManager.WarehouseQueries.updateStone(warehouse, resourceValue - 1500) == true) {
-            warehouse.getResources().put(Warehouse.stoneIB, resourceValue - 1500);
-            warehouse.AddTransactionToWarehouse(Enum.GameObjectType.Building, building.getObjectUUID(), Enum.TransactionType.WITHDRAWL, Resource.STONE, 1500);
-        } else {
-            Logger.error("stone update failed for warehouse of UUID:" + warehouse.getObjectUUID());
-            return true;
-        }
-
-        // Withdraw Lumber
-
-        resourceValue = warehouse.getResources().get(Warehouse.lumberIB);
-
-        if (DbManager.WarehouseQueries.updateLumber(warehouse, resourceValue - 1500) == true) {
-            warehouse.getResources().put(Warehouse.lumberIB, resourceValue - 1500);
-            warehouse.AddTransactionToWarehouse(Enum.GameObjectType.Building, building.getObjectUUID(), Enum.TransactionType.WITHDRAWL, Resource.LUMBER, 1500);
-        } else {
-            Logger.error("lumber update failed for warehouse of UUID:" + warehouse.getObjectUUID());
-            return true;
-        }
-
-        // Withdraw Galvor
-
-        resourceValue = warehouse.getResources().get(Warehouse.galvorIB);
-
-        if (DbManager.WarehouseQueries.updateGalvor(warehouse, resourceValue - 5) == true) {
-            warehouse.getResources().put(Warehouse.galvorIB, resourceValue - 5);
-            warehouse.AddTransactionToWarehouse(Enum.GameObjectType.Building, building.getObjectUUID(), Enum.TransactionType.WITHDRAWL, Resource.GALVOR, 5);
-        } else {
-            Logger.error("galvor update failed for warehouse of UUID:" + warehouse.getObjectUUID());
-            return true;
-        }
-
-        resourceValue = warehouse.getResources().get(Warehouse.wormwoodIB);
-
-        if (DbManager.WarehouseQueries.updateWormwood(warehouse, resourceValue - 5) == true) {
-            warehouse.getResources().put(Warehouse.wormwoodIB, resourceValue - 5);
-            warehouse.AddTransactionToWarehouse(Enum.GameObjectType.Building, building.getObjectUUID(), Enum.TransactionType.WITHDRAWL, Resource.WORMWOOD, 5);
-        } else {
-            Logger.error("wyrmwood update failed for warehouse of UUID:" + warehouse.getObjectUUID());
-        }
-
         return true;
     }
 

src/engine/gameManager/MovementManager.java

@@ -67,8 +67,10 @@ public enum MovementManager {
             return;
 
         if (toMove.getObjectType().equals(GameObjectType.PlayerCharacter)) {
-            if (((PlayerCharacter) toMove).isCasting())
+            if (((PlayerCharacter) toMove).isCasting()) {
-                ((PlayerCharacter) toMove).update();
+                ((PlayerCharacter) toMove).updateLocation();
+                ((PlayerCharacter) toMove).updateMovementState();
+            }
         }
 
 
@@ -96,7 +98,7 @@ public enum MovementManager {
         if (!toMove.isMoving())
             toMove.resetLastSetLocUpdate();
         else
-            toMove.update();
+            toMove.update(false);
 
         // Update movement for the player
 
@@ -351,7 +353,7 @@ public enum MovementManager {
             ChatManager.chatSystemInfo((PlayerCharacter) ac, "Finished Alt change, setting the end location to " + ac.getEndLoc().getX() + ' ' + ac.getEndLoc().getZ() + " moving=" + ac.isMoving() + " and current location is " + curLoc.getX() + ' ' + curLoc.getZ());
 
         //Send run/walk/sit/stand to tell the client we are flying / landing etc
-        ac.update();
+        ac.update(false);
         ac.stopMovement(ac.getLoc());
         if (ac.isAlive())
             MovementManager.sendRWSSMsg(ac);
@@ -408,7 +410,9 @@ public enum MovementManager {
             if (bonus.getBool(ModType.Stunned, SourceType.None) || bonus.getBool(ModType.CannotMove, SourceType.None))
                 continue;
 
-            member.update();
+            //member.update(false);
+            member.updateLocation();
+            member.updateMovementState();
 
 
             // All checks passed, let's move the player

src/engine/gameManager/NPCManager.java

@@ -340,8 +340,8 @@ public enum NPCManager {
         else
             buildingSlot = BuildingManager.getAvailableSlot(abstractCharacter.building);
 
-        if (buildingSlot == -1)
+        //if (buildingSlot == -1)
-            Logger.error("No available slot for NPC: " + abstractCharacter.getObjectUUID());
+            //Logger.error("No available slot for NPC: " + abstractCharacter.getObjectUUID());
 
         abstractCharacter.building.getHirelings().put(abstractCharacter, buildingSlot);
 

src/engine/gameManager/PowersManager.java

@@ -10,6 +10,7 @@ package engine.gameManager;
 
 import engine.Enum.*;
 import engine.InterestManagement.HeightMap;
+import engine.InterestManagement.InterestManager;
 import engine.InterestManagement.WorldGrid;
 import engine.db.handlers.dbEffectsBaseHandler;
 import engine.db.handlers.dbPowerHandler;
@@ -27,6 +28,7 @@ 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;
@@ -163,6 +165,43 @@ public enum PowersManager {
     public static void usePower(final PerformActionMsg msg, ClientConnection origin,
                                 boolean sendCastToSelf) {
 
+        PlayerCharacter pc = SessionManager.getPlayerCharacter(origin);
+
+        if(pc == null)
+            return;
+
+        if(!pc.isFlying() && powersBaseByToken.get(msg.getPowerUsedID()) != null && powersBaseByToken.get(msg.getPowerUsedID()).isSpell) //cant be sitting if flying
+            CombatManager.toggleSit(false,origin);
+
+
+        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");
+                return;
+            }
+        }
+        //crusader sacrifice
+        if((msg.getPowerUsedID() == 428695403 && msg.getTargetID() == pc.getObjectUUID())){
+            RecyclePowerMsg recyclePowerMsg = new RecyclePowerMsg(msg.getPowerUsedID());
+            Dispatch dispatch = Dispatch.borrow(origin.getPlayerCharacter(), recyclePowerMsg);
+            DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
+
+            // Send Fail to cast message
+            if (pc != null) {
+                sendPowerMsg(pc, 2, msg);
+                if (pc.isCasting()) {
+                    pc.update(false);
+                }
+
+                pc.setIsCasting(false);
+            }
+            return;
+        }
+
+        if(msg.getPowerUsedID() == -1851459567){//backstab
+            applyPower(pc,pc,pc.loc,-1851459567,msg.getNumTrains(),false);
+        }
+
         if (usePowerA(msg, origin, sendCastToSelf)) {
             // Cast failed for some reason, reset timer
 
@@ -171,19 +210,20 @@ public enum PowersManager {
             DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
 
             // Send Fail to cast message
-            PlayerCharacter pc = SessionManager
-                    .getPlayerCharacter(origin);
-
             if (pc != null) {
                 sendPowerMsg(pc, 2, msg);
                 if (pc.isCasting()) {
-                    pc.update();
+                    pc.update(false);
                 }
 
                 pc.setIsCasting(false);
             }
 
         }
+
+        if(msg.getPowerUsedID() == 429429978){
+            origin.getPlayerCharacter().getRecycleTimers().remove(429429978);
+        }
     }
 
     public static void useMobPower(Mob caster, AbstractCharacter target, PowersBase pb, int rank) {
@@ -192,7 +232,8 @@ public enum PowersManager {
         msg.setUnknown04(1);
 
         if (useMobPowerA(msg, caster)) {
-            //sendMobPowerMsg(caster,2,msg); //Lol wtf was i thinking sending msg's to mobs... ZZZZ
+            if(pb.token == -1994153779)
+                InterestManager.setObjectDirty(caster);
         }
     }
 
@@ -205,6 +246,48 @@ public enum PowersManager {
 
         boolean CSRCast = false;
 
+        if(msg.getPowerUsedID() == 430628895) {
+
+            boolean failed = false;// group teleport
+            City city = ZoneManager.getCityAtLocation(playerCharacter.loc);
+            if (city == null) {
+                failed = true;
+            }//else{
+             //   Bane bane = city.getBane();
+             //   if (bane == null) {
+             //       failed = true;
+             //   }else{
+             //       if(!bane.getSiegePhase().equals(SiegePhase.WAR)){
+             //           failed = true;
+             //       }
+             //   }
+            //}
+            if(failed){
+                //check to see if we are at an active mine
+                Zone zone = ZoneManager.findSmallestZone(playerCharacter.loc);
+                if(zone != null){
+                    Mine mine = null;
+                    for(Building building : zone.zoneBuildingSet){
+                        if(building.getBlueprint().getBuildingGroup().equals(BuildingGroup.MINE)){
+                            mine = Mine.getMineFromTower(building.getObjectUUID());
+                        }
+                    }
+                    if(mine != null){
+                        failed = !mine.isActive;
+                    }
+                }
+            }
+
+            if(failed) {
+                playerCharacter.setIsCasting(false);
+
+                RecyclePowerMsg recyclePowerMsg = new RecyclePowerMsg(msg.getPowerUsedID());
+                Dispatch dispatch = Dispatch.borrow(playerCharacter, recyclePowerMsg);
+                DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
+
+                return false;
+            }
+        }
 
         if (MBServerStatics.POWERS_DEBUG) {
             ChatManager.chatSayInfo(
@@ -241,6 +324,7 @@ public enum PowersManager {
 
         // get power
         PowersBase pb = PowersManager.powersBaseByToken.get(msg.getPowerUsedID());
+
         if (pb == null) {
             ChatManager.chatSayInfo(playerCharacter,
                     "This power is not implemented yet.");
@@ -252,6 +336,35 @@ public enum PowersManager {
             // return false;
         }
 
+        //check for movement buffs while flying
+        if(playerCharacter.isFlying()) {
+            switch(pb.token){
+                case 429005674:
+                case 429505739:
+                case 431054700:
+                case 428005600:
+                case 431610080:
+                case 427935608:
+                case 427857146:
+                case 427988218:
+                case 431854842:
+                case 421074170:
+                case 429611355:
+                case 428955899:
+                case 1794395699:
+                case 429428796:
+                case 1514898036:
+                    ChatManager.chatSystemInfo(playerCharacter, "You Cannot Fly While Having A MovementBuff");
+                    //resync stamina
+                    playerCharacter.setStamina(playerCharacter.getStamina(), playerCharacter);
+
+                    // Update all surrounding clients.
+                    TargetedActionMsg cmm = new TargetedActionMsg(playerCharacter);
+                    DispatchMessage.dispatchMsgToInterestArea(playerCharacter, cmm, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
+                    return true;
+            }
+        }
+
         if (playerCharacter.getLastPower() != null)
             return true;
 
@@ -259,6 +372,7 @@ public enum PowersManager {
 
 
         // Check powers for normal users
+        if(msg.getPowerUsedID() != 421084024) {
             if (playerCharacter.getPowers() == null || !playerCharacter.getPowers().containsKey(msg.getPowerUsedID()))
                 if (!playerCharacter.isCSR()) {
                     if (!MBServerStatics.POWERS_DEBUG) {
@@ -269,7 +383,7 @@ public enum PowersManager {
                     }
                 } else
                     CSRCast = true;
-
+        }
         // get numTrains for power
         int trains = msg.getNumTrains();
 
@@ -279,6 +393,14 @@ public enum PowersManager {
             msg.setNumTrains(trains);
         }
 
+        //double stack point values for some useless disc spells
+        switch(pb.token){
+            case 429420458: // BH eyes
+            case 429601664: // huntsman skin the beast
+                msg.setNumTrains(msg.getNumTrains() * 2);
+                break;
+        }
+
         // can't go over total trains by player
         if (playerCharacter.getPowers() != null && playerCharacter.getPowers().containsKey(msg.getPowerUsedID())) {
             CharacterPower cp = playerCharacter.getPowers().get(msg.getPowerUsedID());
@@ -370,15 +492,20 @@ public enum PowersManager {
                 float range = pb.getRange();
                 // verify target is in range
 
+                if(pb.token != 429396028) {
 
                     if (verifyInvalidRange(playerCharacter, target, range))
                         // (pc.getLoc().distance(target.getLoc()) > pb.getRange()) {
                         // TODO send message that target is out of range
                         return true;
-
+// verify target is valid type
-                // verify target is valid type
                     if (!validateTarget(target, playerCharacter, pb))
                         return true;
+                }else{
+                    pb.isSpell = false;
+                }
+
+
 
 
                 if (AbstractWorldObject.IsAbstractCharacter(target))
@@ -409,6 +536,23 @@ public enum PowersManager {
                 }
             }
 
+            if(!passed){
+                if (playerCharacter.getRace().getName().contains("Shade")) {
+                    if(playerCharacter.getHidden() > 0){
+                        switch(msg.getPowerUsedID()){
+                            case -1851459567:
+                            case 2094922127:
+                            case -355707373:
+                            case 246186475:
+                            case 666419835:
+                            case 1480354319:
+                                passed = true;
+                                break;
+                        }
+                    }
+                }
+            }
+
             if (!passed)
                 return true;
         }
@@ -487,7 +631,6 @@ public enum PowersManager {
         // Validity checks passed, move on to casting spell
         //get caster's live counter
         int casterLiveCounter = playerCharacter.getLiveCounter();
-
         // run recycle job for when cast is available again, don't bother adding the timer for CSRs
         if (time > 0) {
             FinishRecycleTimeJob frtj = new FinishRecycleTimeJob(playerCharacter, msg);
@@ -514,7 +657,7 @@ public enum PowersManager {
 
         // make person casting stand up if spell (unless they're casting a chant which does not make them stand up)
         if (pb.isSpell() && !pb.isChant() && playerCharacter.isSit()) {
-            playerCharacter.update();
+            playerCharacter.update(false);
             playerCharacter.setSit(false);
             UpdateStateMsg updateStateMsg = new UpdateStateMsg(playerCharacter);
             DispatchMessage.dispatchMsgToInterestArea(playerCharacter, updateStateMsg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
@@ -522,10 +665,12 @@ public enum PowersManager {
         }
 
         // update cast (use skill) fail condition
+        if(pb.token != 429396028 && pb.breaksForm) {
             playerCharacter.cancelOnCast();
+        }
 
         // update castSpell (use spell) fail condition if spell
-        if (pb.isSpell())
+        if (pb.isSpell() && pb.breaksForm)
             playerCharacter.cancelOnSpell();
 
         // get cast time in ms.
@@ -535,13 +680,12 @@ public enum PowersManager {
 
 
         if (time > 100) {
-            playerCharacter.update();
+            playerCharacter.update(false);
             playerCharacter.setIsCasting(true);
         }
 
 
         playerCharacter.setLastMovementState(playerCharacter.getMovementState());
-
         // run timer job to end cast
         if (time < 1) // run immediately
             finishUsePower(copyMsg, playerCharacter, casterLiveCounter, targetLiveCounter);
@@ -667,10 +811,11 @@ public enum PowersManager {
 
         // make person casting stand up if spell (unless they're casting a chant which does not make them stand up)
         // update cast (use skill) fail condition
+        if(pb.breaksForm)
             caster.cancelOnCast();
 
         // update castSpell (use spell) fail condition if spell
-        if (pb.isSpell())
+        if (pb.isSpell() && pb.breaksForm)
             caster.cancelOnSpell();
 
         // get cast time in ms.
@@ -706,8 +851,37 @@ public enum PowersManager {
         if (playerCharacter == null || msg == null)
             return;
 
+        //handle sprint for bard sprint
+        if(msg.getPowerUsedID() == 429005674){
+            msg.setPowerUsedID(429611355);
+        }
+
+        //handle root and snare break for wildkin's chase
+        if(msg.getPowerUsedID() == 429494441) {
+            playerCharacter.removeEffectBySource(EffectSourceType.Root,40,true);
+            playerCharacter.removeEffectBySource(EffectSourceType.Snare,40,true);
+        }
+
+        //handle power block portion for shade hide
+        if(playerCharacter.getRace().getName().contains("Shade")) {
+            if (msg.getPowerUsedID() == 429407306 || msg.getPowerUsedID() == 429495514) {
+                int trains = msg.getNumTrains() - 1;
+                if (trains < 1)
+                    trains = 1;
+                applyPower(playerCharacter, playerCharacter, playerCharacter.loc, 429397210, trains, false);
+                playerCharacter.removeEffectBySource(EffectSourceType.Invisibility,40,true);
+                applyPower(playerCharacter, playerCharacter, playerCharacter.loc, msg.getPowerUsedID(), msg.getNumTrains(), false);
+            }
+        }
+        if(msg.getTargetType() == GameObjectType.PlayerCharacter.ordinal()) {
+            PlayerCharacter target = PlayerCharacter.getPlayerCharacter(msg.getTargetID());
+            if (msg.getPowerUsedID() == 429601664)
+                if(target.getPromotionClassID() != 2516)//templar
+                    PlayerCharacter.getPlayerCharacter(msg.getTargetID()).removeEffectBySource(EffectSourceType.Transform, msg.getNumTrains(), true);
+        }
+
         if (playerCharacter.isCasting()) {
-            playerCharacter.update();
+            playerCharacter.update(false);
             playerCharacter.updateStamRegen(-100);
         }
 
@@ -747,6 +921,9 @@ public enum PowersManager {
             return;
         }
 
+        if(pb.targetSelf)
+            msg.setTargetID(playerCharacter.getObjectUUID());
+
         int trains = msg.getNumTrains();
 
         // verify player is not stunned or power type is blocked
@@ -809,6 +986,7 @@ public enum PowersManager {
                 }
                 float range = pb.getRange() + speedRange;
 
+                if(pb.token != 429396028) {
 
                     if (verifyInvalidRange(playerCharacter, mainTarget, range)) {
 
@@ -817,7 +995,7 @@ public enum PowersManager {
                     }
                     // (pc.getLoc().distance(target.getLoc()) > pb.getRange()) {
                     // TODO send message that target is out of range
-
+                }
 
             }
 
@@ -915,7 +1093,7 @@ public enum PowersManager {
                     continue;
                 // If something blocks the action, then stop
 
-                if (ab.blocked(target, pb, trains)) {
+                if (ab.blocked(target, pb, trains, playerCharacter)) {
 
                     PowersManager.sendEffectMsg(playerCharacter, 5, ab, pb);
                     continue;
@@ -1002,7 +1180,18 @@ public enum PowersManager {
 
 
         //DispatchMessage.dispatchMsgToInterestArea(playerCharacter, msg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
-
+//handle mob hate values
+        HashSet<AbstractWorldObject> mobs = WorldGrid.getObjectsInRangePartial(playerCharacter.loc,60.0f,MBServerStatics.MASK_MOB);
+        for(AbstractWorldObject awo : mobs){
+            Mob mobTarget = (Mob)awo;
+            if(mobTarget.hate_values != null) {
+                if (mobTarget.hate_values.containsKey(playerCharacter)) {
+                    mobTarget.hate_values.put(playerCharacter, mobTarget.hate_values.get(playerCharacter) + pb.getHateValue(trains));
+                } else {
+                    mobTarget.hate_values.put(playerCharacter, pb.getHateValue(trains));
+                }
+            }
+        }
 
     }
 
@@ -1091,7 +1280,7 @@ public enum PowersManager {
                     continue;
                 // If something blocks the action, then stop
 
-                if (ab.blocked(target, pb, trains))
+                if (ab.blocked(target, pb, trains, caster))
                     continue;
                 // TODO handle overwrite stack order here
                 String stackType = ab.getStackType();
@@ -1233,7 +1422,7 @@ public enum PowersManager {
 
         PlayerCharacter target = SessionManager
                 .getPlayerCharacterByLowerCaseName(msg.getTargetName());
-        if (target == null || target.equals(pc) || target.isCombat()) {
+        if (target == null || target.equals(pc)) {
 
             if (target == null) // Player not found. Send not found message
                 ChatManager.chatInfoError(pc,
@@ -1292,7 +1481,7 @@ public enum PowersManager {
         // Handle Accepting or Denying a summons.
         // set timer based on summon type.
         boolean wentThrough = false;
-        if (msg.accepted())
+        if (msg.accepted()) {
             // summons accepted, let's move the player if within time
             if (source.isAlive()) {
 
@@ -1337,6 +1526,16 @@ public enum PowersManager {
                 else
                     duration = 45000; // Belgosh Summons, 45 seconds
 
+                boolean enemiesNear = false;
+                for (AbstractWorldObject awo : WorldGrid.getObjectsInRangePartial(pc.loc, MBServerStatics.CHARACTER_LOAD_RANGE, MBServerStatics.MASK_PLAYER)) {
+                    PlayerCharacter playerCharacter = (PlayerCharacter) awo;
+                    if (!playerCharacter.guild.getNation().equals(pc.guild.getNation())) {
+                        enemiesNear = true;
+                    }
+                }
+
+                if (enemiesNear && !pc.isInSafeZone())
+                    duration += 60000;
 
                 // Teleport to summoners location
                 FinishSummonsJob fsj = new FinishSummonsJob(source, pc);
@@ -1346,7 +1545,10 @@ public enum PowersManager {
                     timers.put("Summon", jc);
                 wentThrough = true;
             }
-
+        }else{
+            // recycle summons power
+            finishRecycleTime(428523680, source, true);
+        }
         // Summons failed
         if (!wentThrough)
             // summons refused. Let's be nice and reset recycle timer
@@ -1447,7 +1649,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))
+                if (bonus != null && bonus.getBool(ModType.CannotTrack, SourceType.None) || ((PlayerCharacter) awo).getAccount().status.equals(AccountStatus.ADMIN))
                     it.remove();
             }
         }
@@ -1462,8 +1664,28 @@ public enum PowersManager {
         }
 
         // create list of characters
-        HashSet<AbstractCharacter> trackChars = RangeBasedAwo.getTrackList(
+        HashSet<AbstractCharacter> trackChars;
-                allTargets, playerCharacter, maxTargets);
+
+        PowersBase trackPower = PowersManager.getPowerByToken(msg.getPowerToken());
+        if(trackPower != null && trackPower.category.equals("TRACK")){
+            trackChars = getTrackList(playerCharacter);
+        }else{
+            trackChars = RangeBasedAwo.getTrackList(allTargets, playerCharacter, maxTargets);
+        }
+
+
+
+        //switch(msg.getPowerToken()){
+        //    case 431511776: // Hunt Foe Huntress
+        //    case 429578587: // Hunt Foe Scout
+        //    case 429503360: // Track Huntsman
+        //    case 44106356: //
+        //        trackChars = getTrackList(playerCharacter);
+        //        break;
+        //    default:
+        //        trackChars = RangeBasedAwo.getTrackList(allTargets, playerCharacter, maxTargets);
+        //        break;
+        //}
 
         TrackWindowMsg trackWindowMsg = new TrackWindowMsg(msg);
 
@@ -1476,6 +1698,30 @@ public enum PowersManager {
 
     }
 
+    public static HashSet<AbstractCharacter> getTrackList(PlayerCharacter tracker){
+        HashSet<AbstractCharacter> list = new HashSet<AbstractCharacter>();
+        HashSet<AbstractWorldObject> shortList = WorldGrid.getObjectsInRangePartial(tracker.loc,MBServerStatics.CHARACTER_LOAD_RANGE, MBServerStatics.MASK_PLAYER);
+        HashSet<AbstractWorldObject> fullList = WorldGrid.getObjectsInRangePartial(tracker.loc,1408, MBServerStatics.MASK_PLAYER);
+        ArrayList<Guild> guildsPresent = new ArrayList<>();
+        for(AbstractWorldObject awo : shortList){
+            PlayerCharacter pc = (PlayerCharacter)awo;
+            if(!guildsPresent.contains(pc.guild.getNation())){
+                guildsPresent.add(pc.guild.getNation());
+            }
+        }
+        for(AbstractWorldObject awo : fullList){
+            if(awo.equals(tracker))
+                continue;
+            PlayerCharacter pc = (PlayerCharacter)awo;
+            if(!pc.isAlive() || pc.getAccount().status.equals(AccountStatus.ADMIN))
+                continue;
+            if(guildsPresent.contains(pc.guild.getNation()))
+                list.add(pc);
+        }
+
+        return list;
+    }
+
     private static void sendRecyclePower(int token, ClientConnection origin) {
         RecyclePowerMsg recyclePowerMsg = new RecyclePowerMsg(token);
 
@@ -1591,6 +1837,10 @@ public enum PowersManager {
     private static void applyPowerA(AbstractCharacter ac, AbstractWorldObject target,
                                     Vector3fImmutable targetLoc, PowersBase pb, int trains,
                                     boolean fromItem) {
+
+        if(fromItem && pb.token == 429021400)
+            trains = 40;
+
         int time = pb.getCastTime(trains);
         if (!fromItem)
             finishApplyPowerA(ac, target, targetLoc, pb, trains, false);
@@ -1656,7 +1906,7 @@ public enum PowersManager {
             if (trains < ab.getMinTrains() || trains > ab.getMaxTrains())
                 continue;
             // If something blocks the action, then stop
-            if (ab.blocked(target, pb, trains))
+            if (ab.blocked(target, pb, trains, ac))
                 // sendPowerMsg(pc, 5, msg);
                 continue;
             // TODO handle overwrite stack order here
@@ -1729,14 +1979,10 @@ public enum PowersManager {
         }
     }
 
-    public static void runPowerAction(AbstractCharacter source,
+    public static void runPowerAction(AbstractCharacter source, AbstractWorldObject awo, Vector3fImmutable targetLoc, ActionsBase ab, int trains, PowersBase pb) {
-                                      AbstractWorldObject awo, Vector3fImmutable targetLoc,
-                                      ActionsBase ab, int trains, PowersBase pb) {
         AbstractPowerAction pa = ab.getPowerAction();
         if (pa == null) {
-            Logger.error(
+            Logger.error("runPowerAction(): PowerAction not found of IDString: " + ab.getEffectID());
-                    "runPowerAction(): PowerAction not found of IDString: "
-                            + ab.getEffectID());
             return;
         }
         pa.startAction(source, awo, targetLoc, trains, ab, pb);
@@ -2189,7 +2435,7 @@ public enum PowersManager {
 
         // set player is not casting for regens
         if (pc.isCasting()) {
-            pc.update();
+            pc.update(false);
         }
         pc.setIsCasting(false);
 
@@ -2231,7 +2477,8 @@ public enum PowersManager {
     public static boolean testAttack(PlayerCharacter pc, AbstractWorldObject awo,
                                      PowersBase pb, PerformActionMsg msg) {
         // Get defense for target
-        float atr = CharacterSkill.getATR(pc, pb.getSkillName());
+        //float atr = CharacterSkill.getATR(pc, pb.getSkillName());
+        float atr = PlayerCombatStats.getSpellAtr(pc, pb);
         float defense;
 
         if (AbstractWorldObject.IsAbstractCharacter(awo)) {
@@ -2241,28 +2488,26 @@ public enum PowersManager {
             defense = 0f;
         // Get hit chance
 
-        if (pc.getDebug(16)) {
+        //if (pc.getDebug(16)) {
-            String smsg = "ATR: " + atr + ", Defense: " + defense;
+        //    String smsg = "ATR: " + atr + ", Defense: " + defense;
-            ChatManager.chatSystemInfo(pc, smsg);
+         //   ChatManager.chatSystemInfo(pc, smsg);
-        }
+        //}
 
-        int chance;
+        //int chance;
 
-        if (atr > defense || defense == 0)
+        //if (atr > defense || defense == 0)
-            chance = 94;
+        //    chance = 94;
-        else {
+        //else {
-            float dif = atr / defense;
+        //    float dif = atr / defense;
-            if (dif <= 0.8f)
+        //    if (dif <= 0.8f)
-                chance = 4;
+        //        chance = 4;
-            else
+        //    else
-                chance = ((int) (450 * (dif - 0.8f)) + 4);
+        //        chance = ((int) (450 * (dif - 0.8f)) + 4);
-        }
+        //}
 
         // calculate hit/miss
-        int roll = ThreadLocalRandom.current().nextInt(100);
 
-        boolean disable = true;
+        if (CombatManager.LandHit((int)atr,(int)defense)) {
-        if (roll < chance) {
             // Hit, check if dodge kicked in
             if (awo instanceof AbstractCharacter) {
                 AbstractCharacter tarAc = (AbstractCharacter) awo;
@@ -2274,6 +2519,15 @@ public enum PowersManager {
                     dodgeMsg.setTargetID(awo.getObjectUUID());
                     sendPowerMsg(pc, 4, dodgeMsg);
                     return true;
+                } else if (testPassive(pc, tarAc, "Block")) {
+                    // Dodge fired, send dodge message
+                    //PerformActionMsg dodgeMsg = new PerformActionMsg(msg);
+                    //dodgeMsg.setTargetType(awo.getObjectType().ordinal());
+                    //dodgeMsg.setTargetID(awo.getObjectUUID());
+                    //sendPowerMsg(pc, 4, dodgeMsg);
+                    TargetedActionMsg cmm = new TargetedActionMsg(pc, 75, tarAc, MBServerStatics.COMBAT_SEND_BLOCK);
+                    DispatchMessage.sendToAllInRange(tarAc, cmm);
+                    return true;
                 }
             }
             return false;
@@ -2321,7 +2575,12 @@ public enum PowersManager {
             if (AbstractWorldObject.IsAbstractCharacter(awo)) {
                 AbstractCharacter tarAc = (AbstractCharacter) awo;
                 // Handle Dodge passive
-                return testPassive(caster, tarAc, "Dodge");
+                boolean passiveFired = false;
+                passiveFired =  testPassive(caster, tarAc, "Dodge");
+                if(!passiveFired)
+                    passiveFired =  testPassive(caster, tarAc, "Block");
+
+                return passiveFired;
             }
             return false;
         } else
@@ -2562,7 +2821,9 @@ public enum PowersManager {
     }
 
     public static void cancelOnStun(AbstractCharacter ac) {
-
+        if(ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
+            //PlayerCharacter.GroundPlayer((PlayerCharacter)ac);
+        }
     }
 
     private static PowersBase getLastPower(AbstractCharacter ac) {
@@ -2708,6 +2969,127 @@ public enum PowersManager {
         }
     }
 
+    public static boolean breakForm(int token) {
+        switch (token) {
+            case 429505865:
+            case 429407561:
+            case 429492073:
+            case 429644123:
+            case 429393769:
+            case 429545819:
+            case 429426537:
+            case 429590377:
+            case 429508425:
+            case 429541193:
+            case 429573961:
+            case 427924330:
+            case 429402918:
+            case 429545688:
+            case 429005674:
+            case 429637823:
+            case 429590426:
+            case 428066972:
+            case 429441862:
+            case 431611756:
+            case 431578988:
+            case 429502506:
+            case 429398191:
+            case 429447384:
+            case 428892191:
+            case 431579167:
+            case 430977067:
+            case 429409100:
+            case 429441868:
+            case 429594877:
+            case 427908971:
+            case 683741153:
+            case 429770569:
+            case 429452379:
+            case 429605055:
+            case 429086971:
+            case 429443230:
+            case 429505400:
+            case 429492122:
+            case 429643992:
+            case 550062236:
+            case 429498252:
+            case 429611224:
+            case 429441834:
+            case 428918940:
+            case 429633739:
+            case 429633579:
+            case 429568043:
+            case 429048646:
+            case 428392639:
+            case 428425407:
+            case 429054168:
+            case 429021400:
+            case 428955864:
+            case 429119704:
+            case 428890328:
+            case 428923096:
+            case 429218008:
+            case 429086936:
+            case 428988632:
+            case 428688204:
+            case 429514603:
+            case 428924959:
+            case 429393818:
+            case 429720966:
+            case 428982463:
+            case 427933887:
+            case 429572287:
+            case 429501222:
+            case 430694431:
+            case 429436131:
+            case 430006124:
+            case 429611355:
+            case 428005600:
+            case 427935608:
+            case 428949695:
+            case 427988218:
+            case 429414616:
+            case 429496495:
+            case 429428796:
+            case 563795754:
+            case 428988217:
+            case 429432716:
+            case 428955899:
+            case 429393286:
+            case 550062220:
+            case 429495557:
+            case 429401278:
+            case 428377478:
+            case 429409094:
+            case 428191947:
+            case 429434474:
+            case 429403363:
+            case 429512920:
+            case 429419611:
+            case 429645676:
+            case 429602895:
+            case 429605071:
+            case 429592428:
+            case 429500010:
+            case 429406602:
+            case 429426586:
+            case 429633898:
+            case 550062212:
+            case 429994027:
+            case 430813227:
+            case 429928491:
+            case 430026795:
+            case 429517915:
+            case 431854842:
+            case 429767544:
+            case 429502507:
+            case 428398816:
+            case 429446315:
+            case 429441979:
+                return false;
+        }
+        return true;
+    }
 }
 
 

src/engine/gameManager/SimulationManager.java

@@ -10,10 +10,7 @@ package engine.gameManager;
 
 import engine.Enum;
 import engine.Enum.GameObjectType;
-import engine.objects.AbstractGameObject;
+import engine.objects.*;
-import engine.objects.City;
-import engine.objects.PlayerCharacter;
-import engine.objects.Runegate;
 import org.pmw.tinylog.Logger;
 
 import java.sql.Connection;
@@ -33,7 +30,7 @@ public enum SimulationManager {
     SERVERHEARTBEAT;
 
     private static final long CITY_PULSE = 2000;
-    private static final long RUNEGATE_PULSE = 3000;
+    private static final long RUNEGATE_PULSE = 1000;
     private static final long UPDATE_PULSE = 1000;
     private static final long FlIGHT_PULSE = 100;
     public static Duration executionTime = Duration.ofNanos(1);
@@ -96,13 +93,10 @@ public enum SimulationManager {
         }
         try {
 
-            if ((_updatePulseTime != 0)
+            if ((_updatePulseTime != 0) && (System.currentTimeMillis() > _updatePulseTime))
-                    && (System.currentTimeMillis() > _updatePulseTime))
                 pulseUpdate();
         } catch (Exception e) {
-            Logger.error(
+            Logger.error("Fatal error in Update Pulse: DISABLED");
-                    "Fatal error in Update Pulse: DISABLED");
-            //  _runegatePulseTime = 0;
         }
 
         try {
@@ -116,9 +110,18 @@ public enum SimulationManager {
         }
 
         try {
-            if ((_cityPulseTime != 0)
+            if ((_cityPulseTime != 0) && (System.currentTimeMillis() > _cityPulseTime)) {
-                    && (System.currentTimeMillis() > _cityPulseTime))
+                try {
                     pulseCities();
+                }catch(Exception e){
+
+                }
+                try {
+                    ArenaManager.pulseArenas();
+                }catch(Exception e){
+
+                }
+            }
         } catch (Exception e) {
             Logger.error(
                     "Fatal error in City Pulse: DISABLED. Error Message : "
@@ -154,7 +157,11 @@ public enum SimulationManager {
 
             if (player == null)
                 continue;
-            player.update();
+            try {
+                player.update(false);
+            }catch(Exception e){
+
+            }
         }
 
         _updatePulseTime = System.currentTimeMillis() + 500;
@@ -203,8 +210,12 @@ public enum SimulationManager {
             city = (City) cityObject;
             city.onEnter();
         }
-
+        for(Mine mine : Mine.getMines()){
+            if(mine != null && mine.isActive)
+                mine.onEnter();
+        }
         _cityPulseTime = System.currentTimeMillis() + CITY_PULSE;
+
     }
 
     /*
@@ -214,6 +225,10 @@ public enum SimulationManager {
     private void pulseRunegates() {
 
         for (Runegate runegate : Runegate._runegates.values()) {
+            for(Portal portal : runegate._portals)
+                if(!portal.isActive())
+                    portal.activate(false);
+
             runegate.collidePortals();
         }
 

src/engine/gameManager/SpecialLootHandler.java

@@ -0,0 +1,396 @@
+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 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){
+            contactId = getContractForZone(zone);
+        }
+        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;
+    }
+    public static int getContractForZone(Zone zone){
+        Random random = new Random();
+        switch (zone.getObjectUUID())
+        {
+            case 178:
+                // Kralgaar Holm
+                return DWARVEN_contracts.get(random.nextInt(DWARVEN_contracts.size()));
+            case 122:
+                // Aurrochs Skrae
+                return INVORRI_contracts.get(random.nextInt(INVORRI_contracts.size()));
+            case 197:
+                // Ymur's Crown
+                return INVORRI_contracts.get(random.nextInt(INVORRI_contracts.size()));
+            case 234:
+                // Ecklund Wilds
+                return INVORRI_contracts.get(random.nextInt(INVORRI_contracts.size()));
+            case 313:
+                // Greensward Pyre
+                return SHADE_contracts.get(random.nextInt(SHADE_contracts.size()));
+            case 331:
+                // The Doomplain
+                return VAMPIRE_contracts.get(random.nextInt(VAMPIRE_contracts.size()));
+            case 353:
+                // Thollok Marsh
+                return LIZARDMAN_contracts.get(random.nextInt(LIZARDMAN_contracts.size()));
+            case 371:
+                // The Black Bog
+                return LIZARDMAN_contracts.get(random.nextInt(LIZARDMAN_contracts.size()));
+            case 388:
+                // Sevaath Mere
+                return LIZARDMAN_contracts.get(random.nextInt(LIZARDMAN_contracts.size()));
+            case 418:
+                // Valkos Wilds
+                return GWENDANNEN_contracts.get(random.nextInt(GWENDANNEN_contracts.size()));
+            case 437:
+                // Grimscairne
+                return SHADE_contracts.get(random.nextInt(SHADE_contracts.size()));
+            case 475:
+                // Phaedra's Prize
+                return AMAZON_contracts.get(random.nextInt(AMAZON_contracts.size()));
+            case 491:
+                // Holloch Forest
+                return GWENDANNEN_contracts.get(random.nextInt(GWENDANNEN_contracts.size()));
+            case 508:
+                // Aeran Belendor
+                return ELVEN_contracts.get(random.nextInt(ELVEN_contracts.size()));
+            case 532:
+                // Tainted Swamp
+                return NEPHILIM_contracts.get(random.nextInt(NEPHILIM_contracts.size()));
+            case 550:
+                // Aerath Hellendroth
+                return ELVEN_contracts.get(random.nextInt(ELVEN_contracts.size()));
+            case 569:
+                // Aedroch Highlands
+                return GWENDANNEN_contracts.get(random.nextInt(GWENDANNEN_contracts.size()));
+            case 590:
+                // Fellgrim Forest
+                return GWENDANNEN_contracts.get(random.nextInt(GWENDANNEN_contracts.size()));
+            case 616:
+                // Derros Plains
+                return CENTAUR_contracts.get(random.nextInt(CENTAUR_contracts.size()));
+            case 632:
+                // Ashfell Plain
+                return SHADE_contracts.get(random.nextInt(SHADE_contracts.size()));
+            case 717:
+                // Kharsoom
+                return IREKEI_contracts.get(random.nextInt(IREKEI_contracts.size()));
+            case 737:
+                // Leth'khalivar Desert
+                return IREKEI_contracts.get(random.nextInt(IREKEI_contracts.size()));
+            case 761:
+                // The Blood Sands
+                return IREKEI_contracts.get(random.nextInt(IREKEI_contracts.size()));
+            case 785:
+                // Vale of Nar Addad
+                return IREKEI_contracts.get(random.nextInt(IREKEI_contracts.size()));
+            case 824:
+                // Western Battleground
+                return NEPHILIM_contracts.get(random.nextInt(NEPHILIM_contracts.size()));
+            case 842:
+                // Pandemonium
+                return NEPHILIM_contracts.get(random.nextInt(NEPHILIM_contracts.size()));
+            case 951:
+                //Bone Marches
+                return VAMPIRE_contracts.get(random.nextInt(VAMPIRE_contracts.size()));
+            case 952:
+                //plain of ashes
+                return VAMPIRE_contracts.get(random.nextInt(VAMPIRE_contracts.size()));
+        }
+        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);
+        Random random = new Random();
+        if(roll == 125){
+            runeID = STAT_RUNES.get(random.nextInt(STAT_RUNES.size()));
+        }
+        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/StrongholdManager.java

@@ -0,0 +1,347 @@
+package engine.gameManager;
+
+import engine.Enum;
+import engine.InterestManagement.InterestManager;
+import engine.InterestManagement.WorldGrid;
+import engine.math.Vector3f;
+import engine.math.Vector3fImmutable;
+import engine.objects.*;
+import org.pmw.tinylog.Logger;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class StrongholdManager {
+
+    public static void processStrongholds() {
+        ArrayList<Mine> mines = Mine.getMines();
+
+
+        //process strongholds selecting 3 randomly to become active
+        int count = 0;
+        while (count < 3) {
+            int random = ThreadLocalRandom.current().nextInt(1, mines.size()) - 1;
+            Mine mine = mines.get(random);
+            if (mine != null) {
+                if (!mine.isActive && !mine.isStronghold) {
+                    StartStronghold(mine);
+                    count++;
+                }
+            }
+        }
+    }
+
+    public static void StartStronghold(Mine mine){
+
+        //remove buildings
+        Building tower = BuildingManager.getBuilding(mine.getBuildingID());
+        if(tower == null)
+            return;
+
+        mine.isStronghold = true;
+        mine.strongholdMobs = new ArrayList<>();
+        mine.oldBuildings = new HashMap<>();
+
+        Zone mineZone = ZoneManager.findSmallestZone(tower.loc);
+        for(Building building : mineZone.zoneBuildingSet){
+            mine.oldBuildings.put(building.getObjectUUID(),building.meshUUID);
+            building.setMeshUUID(407650);
+            building.setMeshScale(new Vector3f(0,0,0));
+            InterestManager.setObjectDirty(building);
+            WorldGrid.updateObject(building);
+        }
+
+        //update tower to become stronghold mesh
+        tower.setMeshUUID(getStrongholdMeshID(mine.getParentZone()));
+        tower.setMeshScale(new Vector3f(1,1,1));
+        InterestManager.setObjectDirty(tower);
+        WorldGrid.updateObject(tower);
+
+        //create elite mobs
+        for(int i = 0; i < mine.capSize * 2; i++){
+            Vector3fImmutable loc = Vector3fImmutable.getRandomPointOnCircle(tower.loc,30);
+            MobBase guardBase = MobBase.getMobBase(getStrongholdGuardianID(tower.meshUUID));
+            Mob guard = Mob.createStrongholdMob(guardBase.getLoadID(), loc, Guild.getErrantGuild(),true,mineZone,null,0, guardBase.getFirstName(),65);
+            if(guard != null){
+                guard.parentZone = mine.getParentZone();
+                guard.bindLoc = loc;
+                guard.setLoc(loc);
+                guard.StrongholdGuardian = true;
+                guard.equipmentSetID = getStrongholdMobEquipSetID(guard);
+                guard.runAfterLoad();
+                guard.setLevel((short)65);
+                guard.setResists(new Resists("Elite"));
+                guard.spawnTime = 1000000000;
+                guard.BehaviourType = Enum.MobBehaviourType.Aggro;
+                mine.strongholdMobs.add(guard);
+                LootManager.GenerateStrongholdLoot(guard,false,false);
+                guard.healthMax  = 12500;
+                guard.setHealth(guard.healthMax);
+                guard.maxDamageHandOne = 1550;
+                guard.minDamageHandOne = 750;
+                guard.atrHandOne = 1800;
+                guard.defenseRating = 2200;
+                guard.setFirstName("Elite Guardian");
+                InterestManager.setObjectDirty(guard);
+                WorldGrid.addObject(guard,loc.x,loc.z);
+                WorldGrid.updateObject(guard);
+                guard.stronghold = mine;
+                guard.mobPowers.clear();
+                guard.mobPowers.put(429399948,20); // find weakness
+            }
+        }
+        //create stronghold commander
+        Vector3fImmutable loc = tower.loc;
+        MobBase commanderBase = MobBase.getMobBase(getStrongholdCommanderID(tower.meshUUID));
+        Mob commander = Mob.createStrongholdMob(commanderBase.getLoadID(), loc,Guild.getErrantGuild(),true,mineZone,null,0, commanderBase.getFirstName(),75);
+        if(commander != null){
+            commander.parentZone = mine.getParentZone();
+            commander.bindLoc = loc;
+            commander.setLoc(loc);
+            commander.StrongholdCommander = true;
+            commander.equipmentSetID = getStrongholdMobEquipSetID(commander);
+            commander.runAfterLoad();
+            commander.setLevel((short)75);
+            commander.setResists(new Resists("Elite"));
+            commander.spawnTime = 1000000000;
+            commander.BehaviourType = Enum.MobBehaviourType.Aggro;
+            commander.mobPowers.clear();
+            commander.mobPowers.put(429032838, 40); // gravechill
+            commander.mobPowers.put(429757701,20); // magebolt
+            commander.mobPowers.put(429121388,20); // blight
+            commander.mobPowers.put(431566891,20); // lightning bolt
+            commander.mobPowers.put(428716075,20); // fire bolt
+            commander.mobPowers.put(429010987,20); // ice bolt
+            mine.strongholdMobs.add(commander);
+            LootManager.GenerateStrongholdLoot(commander,true, false);
+            commander.healthMax = 50000;
+            commander.setHealth(commander.healthMax);
+            commander.maxDamageHandOne = 3500;
+            commander.minDamageHandOne = 1500;
+            commander.atrHandOne = 3500;
+            commander.defenseRating = 3500;
+            commander.setFirstName("Guardian Commander");
+            InterestManager.setObjectDirty(commander);
+            WorldGrid.addObject(commander,loc.x,loc.z);
+            WorldGrid.updateObject(commander);
+            commander.stronghold = mine;
+        }
+
+        mine.isActive = true;
+        tower.setProtectionState(Enum.ProtectionState.PROTECTED);
+        tower.getBounds().setRegions(tower);
+        InterestManager.setObjectDirty(tower);
+        WorldGrid.updateObject(tower);
+        ChatManager.chatSystemChannel(mine.getZoneName() + "'s Stronghold Has Begun!");
+        Logger.info(mine.getZoneName() + "'s Stronghold Has Begun!");
+    }
+
+    public static void EndStronghold(Mine mine){
+
+        //restore the buildings
+        Building tower = BuildingManager.getBuilding(mine.getBuildingID());
+        if(tower == null)
+            return;
+
+        mine.isStronghold = false;
+
+        //get rid of the mobs
+        for(Mob mob : mine.strongholdMobs) {
+            mob.despawn();
+            mob.removeFromCache();
+            DbManager.MobQueries.DELETE_MOB(mob);
+        }
+
+        //restore the buildings
+        Zone mineZone = ZoneManager.findSmallestZone(tower.loc);
+        for(Building building : mineZone.zoneBuildingSet){
+            if(mine.oldBuildings.containsKey(building.getObjectUUID())) {
+                building.setMeshUUID(mine.oldBuildings.get(building.getObjectUUID()));
+                building.setMeshScale(new Vector3f(1, 1, 1));
+                InterestManager.setObjectDirty(building);
+                WorldGrid.updateObject(building);
+            }
+        }
+
+        //update tower to become Mine Tower again
+        tower.setMeshUUID(1500100);
+
+        mine.isActive = false;
+        tower.setProtectionState(Enum.ProtectionState.NPC);
+        tower.getBounds().setRegions(tower);
+        InterestManager.setObjectDirty(tower);
+        WorldGrid.updateObject(tower);
+        ChatManager.chatSystemChannel(mine.getZoneName() + "'s Stronghold Has Concluded!");
+        Logger.info(mine.getZoneName() + "'s Stronghold Has Concluded!");
+    }
+
+    public static int getStrongholdMeshID(Zone parent){
+        while(!parent.isMacroZone()){
+            parent = parent.getParent();
+            if(parent.getName().equalsIgnoreCase("seafloor")){
+                return 0;
+            }
+        }
+        switch(parent.getObjectUUID()){
+            case 197:
+            case 234:
+            case 178:
+            case 122:
+                return 814000; //Frost Giant Hall (ICE)
+            case 968:
+            case 951:
+            case 313:
+            case 331:
+                return 5001500; // Lich Queens Keep (UNDEAD)
+            case 785:
+            case 761:
+            case 717:
+            case 737:
+                return 1306600; // Temple of the Dragon (DESERT)
+            case 353:
+            case 371:
+            case 388:
+            case 532:
+                return 564600; // Undead Lord's Keep (SWAMP)
+            case 550:
+            case 508:
+            case 475:
+            case 418:
+                return 1326600; // elven hall
+            case 437:
+            case 491:
+            case 590:
+            case 569:
+                return 602400;
+            case 824:
+            case 842:
+            case 632:
+                return 1600000; // chaos temple
+        }
+        return 456100; // small stockade
+    }
+
+    public static int getStrongholdGuardianID(int ID){
+        switch(ID){
+            case 814000:
+                return 253004; // Mountain Giant Raider Axe
+            case 5001500:
+                return 253008; // Vampire Spear Warrior
+            case 1306600:
+                return 253007; // Desert Orc Warrior
+            case 564600:
+                return 253010; // Kolthoss Warrior
+            case 1326600:
+                return 253005; //elven warrior
+            case 602400:
+                return 253009; // templar missionary
+            case 1600000:
+                return 253006; // scourger
+        }
+        return 13434; // human sword and board warrior
+    }
+
+    public static int getStrongholdEpicID(int ID){
+        switch(ID){
+            case 814000:
+                return 253023; // Mountain Giant Raider Axe
+            case 5001500:
+                return 253022; // Vampire Spear Warrior
+            case 1306600:
+                return 253021; // Desert Orc Warrior
+            case 564600:
+                return 253018; // Kolthoss Warrior
+            case 1326600:
+                return 253019; //elven warrior
+            case 602400:
+                return 253024; // templar missionary
+            case 1600000:
+                return 253020; // scourger
+        }
+        return 13434; // human sword and board warrior
+    }
+
+    public static int getStrongholdCommanderID(int ID){
+        switch(ID){
+            case 814000:
+                return 253017;
+            case 5001500:
+                return 253012;
+            case 1306600:
+                return 253016; // Desert Orc Xbow
+            case 564600:
+                return 253011; // xbow kolthoss
+            case 1326600:
+                return 253013; //elven bow warrior
+            case 602400:
+                return 253015; // dune giant with xbow
+            case 1600000:
+                return 253014; // barbator
+        }
+        return 13433;
+    }
+
+    public static int getStrongholdMobEquipSetID(Mob mob) {
+        if(mob.StrongholdGuardian){
+            return 6327;
+        }else{
+            return 10790;
+        }
+    }
+
+    public static void CheckToEndStronghold(Mine mine) {
+
+        boolean stillAlive = false;
+        for (Mob mob : mine.strongholdMobs)
+            if (mob.isAlive())
+                stillAlive = true;
+
+        if (!stillAlive) {
+            // Epic encounter
+
+            Building tower = BuildingManager.getBuilding(mine.getBuildingID());
+            if (tower == null)
+                return;
+
+            Zone mineZone = ZoneManager.findSmallestZone(tower.loc);
+
+            Vector3fImmutable loc = tower.loc;
+            MobBase commanderBase = MobBase.getMobBase(getStrongholdEpicID(tower.meshUUID));
+            Mob commander = Mob.createStrongholdMob(commanderBase.getLoadID(), loc, Guild.getErrantGuild(), true, mineZone, null, 0, commanderBase.getFirstName(), 75);
+            if (commander != null) {
+                commander.parentZone = mine.getParentZone();
+                commander.bindLoc = loc;
+                commander.setLoc(loc);
+                commander.StrongholdEpic = true;
+                commander.equipmentSetID = getStrongholdMobEquipSetID(commander);
+                commander.runAfterLoad();
+                commander.setLevel((short) 85);
+                commander.setResists(new Resists("Elite"));
+                commander.spawnTime = 1000000000;
+                commander.BehaviourType = Enum.MobBehaviourType.Aggro;
+                commander.mobPowers.clear();
+                commander.mobPowers.put(429032838, 40); // gravechill
+                commander.mobPowers.put(429757701,40); // magebolt
+                commander.mobPowers.put(429121388,40); // blight
+                commander.mobPowers.put(431566891,40); // lightning bolt
+                commander.mobPowers.put(428716075,40); // fire bolt
+                commander.mobPowers.put(429010987,40); // ice bolt
+                mine.strongholdMobs.add(commander);
+                LootManager.GenerateStrongholdLoot(commander, true, true);
+                commander.healthMax = 250000;
+                commander.setHealth(commander.healthMax);
+                commander.maxDamageHandOne = 5000;
+                commander.minDamageHandOne = 2500;
+                commander.atrHandOne = 5000;
+                commander.defenseRating = 3500;
+                commander.setFirstName("Defender of " + mine.getParentZone().getParent().getName());
+                InterestManager.setObjectDirty(commander);
+                WorldGrid.addObject(commander,loc.x,loc.z);
+                WorldGrid.updateObject(commander);
+                commander.stronghold = mine;
+
+            }
+        }
+    }
+}

src/engine/gameManager/ZergManager.java

@@ -0,0 +1,195 @@
+package engine.gameManager;
+import engine.objects.Guild;
+public class ZergManager {
+
+    public static float getCurrentMultiplier(int count, int maxCount){
+        switch(maxCount) {
+            case 3: return getMultiplier3Man(count);
+            case 5: return getMultiplier5Man(count);
+            case 10: return getMultiplier10Man(count);
+            case 20: return getMultiplier20Man(count);
+            case 30: return getMultiplier30Man(count);
+            case 40: return getMultiplier40Man(count);
+            default: return 1.0f; //unlimited
+        }
+    }
+    public static float getMultiplier3Man(int count) {
+        if(count < 4)
+            return 1.0f;
+
+        if(count > 6)
+            return 0.0f;
+
+        switch(count){
+            case 4: return 0.50f;
+            case 5: return 0.0f;
+            case 6: return 0.0f;
+            default: return 1.0f;
+        }
+    }
+    public static float getMultiplier5Man(int count) {
+        if(count < 6)
+            return 1.0f;
+
+        if(count > 10)
+            return 0.0f;
+
+        switch(count){
+            case 6: return 0.75f;
+            case 7: return 0.57f;
+            case 8: return 0.44f;
+            case 9: return 0.33f;
+            case 10: return 0.25f;
+            default: return 1.0f;
+        }
+    }
+    public static float getMultiplier10Man(int count) {
+        if(count < 11)
+            return 1.0f;
+
+        if(count > 20)
+            return 0.0f;
+
+        switch(count){
+            case 11: return 0.86f;
+            case 12: return 0.75f;
+            case 13: return 0.65f;
+            case 14: return 0.57f;
+            case 15: return 0.50f;
+            case 16: return 0.44f;
+            case 17: return 0.38f;
+            case 18: return 0.33f;
+            case 19: return 0.29f;
+            case 20: return 0.25f;
+            default: return 1.0f;
+        }
+    }
+    public static float getMultiplier20Man(int count) {
+        if(count < 21)
+            return 1.0f;
+
+        if(count > 40)
+            return 0.0f;
+
+        switch (count)
+        {
+            case 21: return 0.93f;
+            case 22: return 0.86f;
+            case 23: return 0.80f;
+            case 24: return 0.75f;
+            case 25: return 0.70f;
+            case 26: return 0.65f;
+            case 27: return 0.61f;
+            case 28: return 0.57f;
+            case 29: return 0.53f;
+            case 30: return 0.50f;
+            case 31: return 0.47f;
+            case 32: return 0.44f;
+            case 33: return 0.41f;
+            case 34: return 0.38f;
+            case 35: return 0.36f;
+            case 36: return 0.33f;
+            case 37: return 0.31f;
+            case 38: return 0.29f;
+            case 39: return 0.27f;
+            case 40: return 0.25f;
+            default: return 1.0f;
+        }
+
+    }
+    public static float getMultiplier30Man(int count) {
+        if(count < 31)
+            return 1.0f;
+
+        if(count > 60)
+            return 0.0f;
+
+        switch (count)
+        {
+            case 31: return 0.95f;
+            case 32: return 0.91f;
+            case 33: return 0.86f;
+            case 34: return 0.82f;
+            case 35: return 0.79f;
+            case 36: return 0.75f;
+            case 37: return 0.72f;
+            case 38: return 0.68f;
+            case 39: return 0.65f;
+            case 40: return 0.63f;
+            case 41: return 0.60f;
+            case 42: return 0.57f;
+            case 43: return 0.55f;
+            case 44: return 0.52f;
+            case 45: return 0.50f;
+            case 46: return 0.48f;
+            case 47: return 0.46f;
+            case 48: return 0.44f;
+            case 49: return 0.42f;
+            case 50: return 0.40f;
+            case 51: return 0.38f;
+            case 52: return 0.37f;
+            case 53: return 0.35f;
+            case 54: return 0.33f;
+            case 55: return 0.32f;
+            case 56: return 0.30f;
+            case 57: return 0.29f;
+            case 58: return 0.28f;
+            case 59: return 0.26f;
+            case 60: return 0.25f;
+            default: return 1.0f;
+        }
+
+    }
+    public static float getMultiplier40Man(int count) {
+        if(count < 41)
+            return 1.0f;
+
+        if(count > 80)
+            return 0.0f;
+
+        switch (count)
+        {
+            case 41: return 0.96f;
+            case 42: return 0.93f;
+            case 43: return 0.90f;
+            case 44: return 0.86f;
+            case 45: return 0.83f;
+            case 46: return 0.80f;
+            case 47: return 0.78f;
+            case 48: return 0.75f;
+            case 49: return 0.72f;
+            case 50: return 0.70f;
+            case 51: return 0.68f;
+            case 52: return 0.65f;
+            case 53: return 0.63f;
+            case 54: return 0.61f;
+            case 55: return 0.59f;
+            case 56: return 0.57f;
+            case 57: return 0.55f;
+            case 58: return 0.53f;
+            case 59: return 0.52f;
+            case 60: return 0.50f;
+            case 61: return 0.48f;
+            case 62: return 0.47f;
+            case 63: return 0.45f;
+            case 64: return 0.44f;
+            case 65: return 0.42f;
+            case 66: return 0.41f;
+            case 67: return 0.40f;
+            case 68: return 0.38f;
+            case 69: return 0.37f;
+            case 70: return 0.36f;
+            case 71: return 0.35f;
+            case 72: return 0.33f;
+            case 73: return 0.32f;
+            case 74: return 0.31f;
+            case 75: return 0.30f;
+            case 76: return 0.29f;
+            case 77: return 0.28f;
+            case 78: return 0.27f;
+            case 79: return 0.26f;
+            case 80: return 0.25f;
+            default: return 1.0f;
+        }
+    }
+}

src/engine/gameManager/ZoneManager.java

@@ -19,14 +19,12 @@ import engine.objects.Building;
 import engine.objects.City;
 import engine.objects.Zone;
 import engine.server.MBServerStatics;
-import org.pmw.tinylog.Logger;
 
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ThreadLocalRandom;
 
 /*
  * Class contains methods and structures which
@@ -109,20 +107,6 @@ public enum ZoneManager {
 
     }
 
-    // Returns the number of available hotZones
-    // remaining in this cycle (1am)
-
-    public static int availableHotZones() {
-
-        int count = 0;
-
-        for (Zone zone : ZoneManager.macroZones)
-            if (ZoneManager.validHotZone(zone))
-                count = count + 1;
-
-        return count;
-    }
-
     // Resets the  availability of hotZones
     // for this cycle
 
@@ -217,63 +201,6 @@ public enum ZoneManager {
         ZoneManager.playerCityZones.add(zone);
     }
 
-    public static final void generateAndSetRandomHotzone() {
-
-        Zone hotZone;
-        ArrayList<Integer> zoneArray = new ArrayList<>();
-
-        if (ZoneManager.macroZones.isEmpty())
-            return;
-
-        // Reset hotZone availability if none are left.
-
-        if (ZoneManager.availableHotZones() == 0)
-            ZoneManager.resetHotZones();
-
-        for (Zone zone : ZoneManager.macroZones)
-            if (validHotZone(zone))
-                zoneArray.add(zone.getObjectUUID());
-
-        int entryIndex = ThreadLocalRandom.current().nextInt(zoneArray.size());
-
-        hotZone = ZoneManager.getZoneByUUID(zoneArray.get(entryIndex));
-
-        if (hotZone == null) {
-            Logger.error("Hotzone is null");
-            return;
-        }
-
-        ZoneManager.setHotZone(hotZone);
-
-    }
-
-    public static final boolean validHotZone(Zone zone) {
-
-        if (zone.getSafeZone() == (byte) 1)
-            return false; // no safe zone hotzones// if (this.hotzone == null)
-
-        if (zone.getNodes().isEmpty())
-            return false;
-
-        if (zone.equals(ZoneManager.seaFloor))
-            return false;
-
-        //no duplicate hotZones
-
-        if (zone.hasBeenHotzone == true)
-            return false;
-
-        // Enforce min level
-
-        if (zone.minLvl < Integer.parseInt(ConfigManager.MB_HOTZONE_MIN_LEVEL.getValue()))
-            return false;
-
-        if (ZoneManager.hotZone != null)
-            return ZoneManager.hotZone.getObjectUUID() != zone.getObjectUUID();
-
-        return true;
-    }
-
     // Converts world coordinates to coordinates local to a given zone.
 
     public static Vector3fImmutable worldToLocal(Vector3fImmutable worldVector,

src/engine/job/AbstractJob.java

@@ -68,7 +68,7 @@ public abstract class AbstractJob implements Runnable {
         this.markStopRunTime();
     }
 
-    protected abstract void doJob();
+    public abstract void doJob();
 
     public void executeJob(String threadName) {
         this.workerID.set(threadName);

src/engine/job/AbstractScheduleJob.java

@@ -17,7 +17,7 @@ public abstract class AbstractScheduleJob extends AbstractJob {
     }
 
     @Override
-    protected abstract void doJob();
+    public abstract void doJob();
 
     public void cancelJob() {
         JobScheduler.getInstance().cancelScheduledJob(this);

src/engine/job/JobContainer.java

@@ -16,7 +16,7 @@ public class JobContainer implements Comparable<JobContainer> {
     final long timeOfExecution;
     final boolean noTimer;
 
-    JobContainer(AbstractJob job, long timeOfExecution) {
+    public JobContainer(AbstractJob job, long timeOfExecution) {
         if (job == null) {
             throw new IllegalArgumentException("No 'null' jobs allowed.");
         }

src/engine/job/JobThread.java

@@ -0,0 +1,75 @@
+package engine.job;
+
+import engine.server.world.WorldServer;
+import org.pmw.tinylog.Logger;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class JobThread implements Runnable {
+    private final AbstractJob currentJob;
+    private final ReentrantLock lock = new ReentrantLock();
+
+    private static Long nextThreadPrint;
+
+    public JobThread(AbstractJob job){
+        this.currentJob = job;
+    }
+
+    @Override
+    public void run() {
+        try {
+            if (this.currentJob != null) {
+                if (lock.tryLock(5, TimeUnit.SECONDS)) { // Timeout to prevent deadlock
+                    try {
+                        this.currentJob.doJob();
+                    } finally {
+                        lock.unlock();
+                    }
+                } else {
+                    Logger.warn("JobThread could not acquire lock in time, skipping job.");
+                }
+            }
+        } catch (Exception e) {
+            Logger.error(e);
+        }
+    }
+
+    public static void startJobThread(AbstractJob job){
+        JobThread jobThread = new JobThread(job);
+        Thread thread = new Thread(jobThread);
+        thread.setName("JOB THREAD: " + job.getWorkerID());
+        thread.start();
+
+       if(JobThread.nextThreadPrint == null){
+           JobThread.nextThreadPrint = System.currentTimeMillis();
+       }else{
+           if(JobThread.nextThreadPrint < System.currentTimeMillis()){
+               JobThread.tryPrintThreads();
+               JobThread.nextThreadPrint = System.currentTimeMillis() + 10000L;
+           }
+       }
+    }
+
+    public static void tryPrintThreads(){
+        ThreadGroup rootGroup = Thread.currentThread().getThreadGroup();
+        while (rootGroup.getParent() != null) {
+            rootGroup = rootGroup.getParent();
+        }
+
+        // Estimate the number of threads
+        int activeThreads = rootGroup.activeCount();
+
+        // Create an array to hold the threads
+        Thread[] threads = new Thread[activeThreads];
+
+        // Get the active threads
+        rootGroup.enumerate(threads, true);
+
+        int availableThreads = Runtime.getRuntime().availableProcessors();
+
+        // Print the count
+        if(threads.length > 30)
+            Logger.info("Total threads in application: " + threads.length + " / " + availableThreads);
+    }
+}

src/engine/job/JobWorker.java

@@ -58,10 +58,13 @@ public class JobWorker extends ControlledRunnable {
             } else {
 
                 // execute the new job..
-                this.currentJob.executeJob(this.getThreadName());
+                //this.currentJob.executeJob(this.getThreadName());
+                if(this.currentJob != null) {
+                    JobThread.startJobThread(this.currentJob);
                     this.currentJob = null;
                 }
-
+            }
+            Thread.yield();
         }
         return true;
     }

src/engine/jobs/AbstractEffectJob.java

@@ -45,7 +45,7 @@ public abstract class AbstractEffectJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected abstract void doJob();
+    public abstract void doJob();
 
     @Override
     protected abstract void _cancelJob();
@@ -117,7 +117,7 @@ public abstract class AbstractEffectJob extends AbstractScheduleJob {
     }
 
     public void endEffect() {
-        if (this.eb == null)
+        if (this.eb == null || this.power == null)
             return;
         this.eb.endEffect(this.source, this.target, this.trains, this.power, this);
     }

src/engine/jobs/ActivateBaneJob.java

@@ -29,7 +29,7 @@ public class ActivateBaneJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         City city;
 

src/engine/jobs/AttackJob.java

@@ -9,9 +9,11 @@
 
 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 {
 
@@ -27,7 +29,18 @@ public class AttackJob extends AbstractJob {
     }
 
     @Override
-    protected void doJob() {
+    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/BaneDefaultTimeJob.java

@@ -24,7 +24,7 @@ public class BaneDefaultTimeJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         //bane already set.
         if (this.bane.getLiveDate() != null) {

src/engine/jobs/BasicScheduledJob.java

@@ -97,7 +97,7 @@ public class BasicScheduledJob extends AbstractJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         if (execution == null) {
             Logger.error("BasicScheduledJob executed with nothing to execute.");
             return;

src/engine/jobs/BonusCalcJob.java

@@ -22,7 +22,7 @@ public class BonusCalcJob extends AbstractJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         if (this.ac != null) {
             this.ac.applyBonuses();
 

src/engine/jobs/CSessionCleanupJob.java

@@ -22,7 +22,7 @@ public class CSessionCleanupJob extends AbstractJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         SessionManager.cSessionCleanup(secKey);
     }
 }

src/engine/jobs/ChangeAltitudeJob.java

@@ -27,7 +27,7 @@ public class ChangeAltitudeJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         if (this.ac != null)
             MovementManager.finishChangeAltitude(ac, targetAlt);
     }

src/engine/jobs/ChantJob.java

@@ -36,7 +36,7 @@ public class ChantJob extends AbstractEffectJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         if (this.aej == null || this.source == null || this.target == null || this.action == null || this.power == null || this.source == null || this.eb == null)
             return;
         PlayerBonuses bonuses = null;

src/engine/jobs/CloseGateJob.java

@@ -29,7 +29,7 @@ public class CloseGateJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         if (building == null) {
             Logger.error("Rungate building was null");

src/engine/jobs/DamageOverTimeJob.java

@@ -37,7 +37,7 @@ public class DamageOverTimeJob extends AbstractEffectJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         if (this.target.getObjectType().equals(GameObjectType.Building)
                 && ((Building) this.target).isVulnerable() == false) {
             _cancelJob();
@@ -60,6 +60,8 @@ public class DamageOverTimeJob extends AbstractEffectJob {
 
         if (this.iteration < 0) {
             PowersManager.finishEffectTime(this.source, this.target, this.action, this.trains);
+            if (AbstractWorldObject.IsAbstractCharacter(source))
+                eb.startEffect((AbstractCharacter) this.source, this.target, this.trains, this);
             return;
         }
         this.skipSendEffect = true;

src/engine/jobs/DatabaseUpdateJob.java

@@ -28,7 +28,7 @@ public class DatabaseUpdateJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         if (this.ago == null)
             return;
         ago.removeDatabaseJob(this.type, false);

src/engine/jobs/DebugTimerJob.java

@@ -29,7 +29,7 @@ public class DebugTimerJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         if (this.pc == null) {
             return;
         }

src/engine/jobs/DeferredPowerJob.java

@@ -37,7 +37,7 @@ public class DeferredPowerJob extends AbstractEffectJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         //Power ended with no attack, cancel weapon power boost
         if (this.source != null && this.source instanceof PlayerCharacter) {
             ((PlayerCharacter) this.source).setWeaponPower(null);

src/engine/jobs/DisconnectJob.java

@@ -22,7 +22,7 @@ public class DisconnectJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         if (this.origin != null) {
             this.origin.disconnect();
         }

src/engine/jobs/DoorCloseJob.java

@@ -28,7 +28,7 @@ public class DoorCloseJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         int doorNumber;
 

src/engine/jobs/EndFearJob.java

@@ -22,7 +22,7 @@ public class EndFearJob extends AbstractEffectJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         //cancel fear for mob.
 

src/engine/jobs/FinishCooldownTimeJob.java

@@ -26,7 +26,7 @@ public class FinishCooldownTimeJob extends AbstractJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         PowersManager.finishCooldownTime(this.msg, this.pc);
     }
 }

src/engine/jobs/FinishEffectTimeJob.java

@@ -22,7 +22,7 @@ public class FinishEffectTimeJob extends AbstractEffectJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         PowersManager.finishEffectTime(this.source, this.target, this.action, this.trains);
     }
 

src/engine/jobs/FinishRecycleTimeJob.java

@@ -26,7 +26,7 @@ public class FinishRecycleTimeJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         PowersManager.finishRecycleTime(this.msg, this.pc, false);
     }
 

src/engine/jobs/FinishSpireEffectJob.java

@@ -20,7 +20,7 @@ public class FinishSpireEffectJob extends AbstractEffectJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         PlayerCharacter pc = (PlayerCharacter) target;
 

src/engine/jobs/FinishSummonsJob.java

@@ -31,7 +31,7 @@ public class FinishSummonsJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         if (this.target == null)
             return;
@@ -47,13 +47,13 @@ public class FinishSummonsJob extends AbstractScheduleJob {
             return;
 
         // cannot summon a player in combat
-        if (this.target.isCombat()) {
+        //if (this.target.isCombat()) {
 
-            ErrorPopupMsg.sendErrorMsg(this.source, "Cannot summon player in combat.");
+        //    ErrorPopupMsg.sendErrorMsg(this.source, "Cannot summon player in combat.");
 
-            PowersManager.finishRecycleTime(428523680, this.source, false);
+        //    PowersManager.finishRecycleTime(428523680, this.source, false);
-            return;
+        //    return;
-        }
+        //}
 
         if (this.target.getBonuses() != null && this.target.getBonuses().getBool(ModType.BlockedPowerType, SourceType.SUMMON)) {
             ErrorPopupMsg.sendErrorMsg(this.target, "You have been blocked from receiving summons!");

src/engine/jobs/LoadEffectsJob.java

@@ -28,7 +28,7 @@ public class LoadEffectsJob extends AbstractJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         if (this.originToSend == null) {
             return;
         }

src/engine/jobs/LogoutCharacterJob.java

@@ -25,7 +25,7 @@ public class LogoutCharacterJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         server.logoutCharacter(this.pc);
     }
 

src/engine/jobs/NoTimeJob.java

@@ -19,7 +19,7 @@ public class NoTimeJob extends AbstractEffectJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
     }
 
     @Override

src/engine/jobs/PersistentAoeJob.java

@@ -40,11 +40,19 @@ public class PersistentAoeJob extends AbstractEffectJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         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;
+            }
+        }
+
         if (!this.source.isAlive())
             PowersManager.finishEffectTime(this.source, this.target, this.action, this.trains);
         else if (this.iteration < this.power.getChantIterations()) {

src/engine/jobs/RefreshGroupJob.java

@@ -45,7 +45,7 @@ public class RefreshGroupJob extends AbstractJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         if (this.pc == null || this.origin == null || grp == null) {
             return;

src/engine/jobs/RemoveCorpseJob.java

@@ -22,7 +22,7 @@ public class RemoveCorpseJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         if (this.corpse != null)
             Corpse.removeCorpse(corpse, true);

src/engine/jobs/SiegeSpireWithdrawlJob.java

@@ -25,7 +25,7 @@ public class SiegeSpireWithdrawlJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         if (spire == null)
             return;

src/engine/jobs/StuckJob.java

@@ -30,7 +30,7 @@ public class StuckJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         Vector3fImmutable stuckLoc;
         Building building = null;

src/engine/jobs/SummonSendJob.java

@@ -27,7 +27,7 @@ public class SummonSendJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         if (this.source == null)
             return;

src/engine/jobs/TeleportJob.java

@@ -39,7 +39,7 @@ public class TeleportJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         if (this.pc == null || this.npc == null || this.origin == null)
             return;

src/engine/jobs/TrackJob.java

@@ -35,7 +35,7 @@ public class TrackJob extends AbstractEffectJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         if (this.tpa == null || this.target == null || this.action == null || this.source == null || this.eb == null || !(this.source instanceof PlayerCharacter))
             return;

src/engine/jobs/TransferStatOTJob.java

@@ -29,7 +29,7 @@ public class TransferStatOTJob extends AbstractEffectJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         if (this.dot == null || this.target == null || this.action == null || this.source == null || this.eb == null || this.action == null || this.power == null)
             return;
         if (!this.target.isAlive()) {

src/engine/jobs/UpdateGroupJob.java

@@ -26,7 +26,7 @@ public class UpdateGroupJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         if (this.group == null)
             return;

src/engine/jobs/UpgradeBuildingJob.java

@@ -1,7 +1,9 @@
 package engine.jobs;
 
+import engine.gameManager.ZoneManager;
 import engine.job.AbstractScheduleJob;
 import engine.objects.Building;
+import engine.objects.City;
 import org.pmw.tinylog.Logger;
 
 /*
@@ -20,7 +22,7 @@ public class UpgradeBuildingJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
 
         // Must have a building to rank!
@@ -41,6 +43,18 @@ public class UpgradeBuildingJob extends AbstractScheduleJob {
 
         rankingBuilding.setRank(rankingBuilding.getRank() + 1);
 
+        if(rankingBuilding.getBlueprint().isWallPiece()){
+            City cityObject = ZoneManager.getCityAtLocation(rankingBuilding.loc);
+            if(cityObject.getTOL().getRank() == 8) {
+                if (rankingBuilding.getBlueprint() != null && rankingBuilding.getBlueprint().getBuildingGroup() != null && rankingBuilding.getBlueprint().isWallPiece()) {
+                    float currentHealthRatio = rankingBuilding.getCurrentHitpoints() / rankingBuilding.healthMax;
+                    float newMax = rankingBuilding.healthMax * 1.1f;
+                    rankingBuilding.setMaxHitPoints(newMax);
+                    rankingBuilding.setHealth(rankingBuilding.healthMax * currentHealthRatio);
+                }
+            }
+        }
+
         // Reload the object
 
 

src/engine/jobs/UpgradeNPCJob.java

@@ -27,7 +27,7 @@ public class UpgradeNPCJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
 
         int newRank;
 

src/engine/jobs/UseItemJob.java

@@ -34,7 +34,7 @@ public class UseItemJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         PowersManager.finishApplyPower(ac, target, Vector3fImmutable.ZERO, pb, trains, liveCounter);
     }
 

src/engine/jobs/UseMobPowerJob.java

@@ -35,7 +35,7 @@ public class UseMobPowerJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         PowersManager.finishUseMobPower(this.msg, this.caster, casterLiveCounter, targetLiveCounter);
     }
 

src/engine/jobs/UsePowerJob.java

@@ -35,7 +35,7 @@ public class UsePowerJob extends AbstractScheduleJob {
     }
 
     @Override
-    protected void doJob() {
+    public void doJob() {
         PowersManager.finishUsePower(this.msg, this.pc, casterLiveCounter, targetLiveCounter);
     }
 

src/engine/loot/ItemTableEntry.java

@@ -9,10 +9,12 @@
 package engine.loot;
 
 import engine.gameManager.LootManager;
+import org.pmw.tinylog.Logger;
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
 
 public class ItemTableEntry {
     public int minRoll;
@@ -35,11 +37,23 @@ public class ItemTableEntry {
         List<ItemTableEntry> itemTableEntryList;
 
         itemTableEntryList = LootManager._itemTables.get(itemTable);
-
+        if(itemTableEntryList != null) {
             for (ItemTableEntry iteration : itemTableEntryList)
                 if (roll >= iteration.minRoll && roll <= iteration.maxRoll)
                     itemTableEntry = iteration;
-
+        }
         return itemTableEntry;
     }
+
+    public static Integer getRandomItem(int itemTable) {
+        int id = 0;
+        List<ItemTableEntry> itemTableEntryList;
+
+        itemTableEntryList = LootManager._itemTables.get(itemTable);
+
+        if(itemTableEntryList != null && itemTableEntryList.size() > 1){
+            id =  itemTableEntryList.get(ThreadLocalRandom.current().nextInt(0, itemTableEntryList.size())).cacheID;
+        }
+        return id;
+    }
 }

src/engine/loot/ModTableEntry.java

@@ -33,11 +33,11 @@ public class ModTableEntry {
         List<ModTableEntry> itemTableEntryList;
 
         itemTableEntryList = LootManager._modTables.get(modTablwe);
-
+        if(itemTableEntryList != null) {
             for (ModTableEntry iteration : itemTableEntryList)
                 if (roll >= iteration.minRoll && roll <= iteration.maxRoll)
                     modTableEntry = iteration;
-
+        }
         return modTableEntry;
     }
 }

src/engine/math/Bounds.java

@@ -220,7 +220,7 @@ public class Bounds {
             //player is inside building region, skip collision check. we only do collision from the outside.
             if (player.region != null && player.region.parentBuildingID == building.getObjectUUID())
                 continue;
-            if (building.getBounds().colliders == null)
+            if (building.getBounds() == null || building.getBounds().colliders == null)
                 continue;
 
             for (Colliders collider : building.getBounds().colliders) {

src/engine/mobileAI/MobAI.java

@@ -9,17 +9,18 @@
 package engine.mobileAI;
 
 import engine.Enum;
-import engine.Enum.DispatchChannel;
+import engine.InterestManagement.InterestManager;
 import engine.InterestManagement.WorldGrid;
 import engine.gameManager.*;
 import engine.math.Vector3f;
 import engine.math.Vector3fImmutable;
+import engine.mobileAI.MobHandlers.MobHandler;
 import engine.mobileAI.Threads.MobAIThread;
 import engine.mobileAI.utilities.CombatUtilities;
 import engine.mobileAI.utilities.MovementUtilities;
 import engine.net.DispatchMessage;
 import engine.net.client.msg.PerformActionMsg;
-import engine.net.client.msg.PowerProjectileMsg;
+import engine.net.client.msg.UpdateStateMsg;
 import engine.objects.*;
 import engine.powers.ActionsBase;
 import engine.powers.PowersBase;
@@ -27,6 +28,7 @@ import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map.Entry;
 import java.util.concurrent.ConcurrentHashMap;
@@ -49,18 +51,19 @@ public class MobAI {
                 return;
             }
 
-            if (target.getObjectType() == Enum.GameObjectType.PlayerCharacter && canCast(mob)) {
+            //mob casting disabled
+            //if (target.getObjectType() == Enum.GameObjectType.PlayerCharacter && canCast(mob)) {
 
-                if (mob.isPlayerGuard() == false && MobCast(mob)) {
+                //if (mob.isPlayerGuard() == false && MobCast(mob)) {
-                    mob.updateLocation();
+                //    mob.updateLocation();
-                    return;
+                //    return;
-                }
+                //}
 
-                if (mob.isPlayerGuard() == true && GuardCast(mob)) {
+                //if (mob.isPlayerGuard() == true && GuardCast(mob)) {
-                    mob.updateLocation();
+                //    mob.updateLocation();
-                    return;
+                //    return;
-                }
+                //}
-            }
+            //}
 
             if (!CombatUtilities.inRangeToAttack(mob, target))
                 return;
@@ -82,8 +85,18 @@ public class MobAI {
 
             mob.updateLocation();
 
+            if(mob.StrongholdGuardian || mob.StrongholdEpic){
+                // attempt to ground all players in attack range
+                for(int i : mob.playerAgroMap.keySet()){
+                    PlayerCharacter tar = PlayerCharacter.getFromCache(i);
+                    if(tar != null && tar.loc.distanceSquared(mob.loc) < 80){
+                        PowersManager.applyPower(mob,tar,tar.loc, 111111,40,false);
+                    }
+                }
+            }
+
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
         }
     }
 
@@ -96,10 +109,16 @@ public class MobAI {
                 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);
 
-            if (!MovementUtilities.inRangeDropAggro(mob, target)) {
+            if (MovementUtilities.outOfAggroRange(mob, target)) {
                 mob.setCombatTarget(null);
                 return;
             }
@@ -116,6 +135,9 @@ public class MobAI {
                 if (mob.isMoving() && mob.getRange() > 20)
                     return;
 
+                if(target.combatStats == null)
+                    target.combatStats = new PlayerCombatStats(target);
+
                 // add timer for last attack.
 
                 ItemBase mainHand = mob.getWeaponItemBase(true);
@@ -146,8 +168,14 @@ public class MobAI {
                 if (target.getPet().getCombatTarget() == null && target.getPet().assist == true)
                     target.getPet().setCombatTarget(mob);
 
+            try{
+                InterestManager.forceLoad(mob);
+            }catch(Exception e){
+
+            }
+
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackPlayer" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackPlayer" + " " + e.getMessage());
         }
 
     }
@@ -156,6 +184,9 @@ public class MobAI {
 
         try {
 
+            if(mob == null || target == null)
+                return;
+
             if (target.getRank() == -1 || !target.isVulnerable() || BuildingManager.getBuildingFromCache(target.getObjectUUID()) == null) {
                 mob.setCombatTarget(null);
                 return;
@@ -165,8 +196,8 @@ public class MobAI {
 
             if (playercity != null)
                 for (Mob guard : playercity.getParent().zoneMobSet)
-                    if (guard.BehaviourType != null && guard.BehaviourType.ordinal() == Enum.MobBehaviourType.GuardCaptain.ordinal())
+                    if (guard.BehaviourType != null && guard.BehaviourType.equals(Enum.MobBehaviourType.GuardCaptain))
-                        if (guard.getCombatTarget() == null && !guard.getGuild().equals(mob.getGuild()))
+                        if (guard.getCombatTarget() == null && guard.getGuild() != null && mob.getGuild() != null && !guard.getGuild().equals(mob.getGuild()))
                             guard.setCombatTarget(mob);
 
             if (mob.isSiege())
@@ -195,14 +226,14 @@ public class MobAI {
                 mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
             }
 
-            if (mob.isSiege()) {
+            //if (mob.isSiege()) {
-                PowerProjectileMsg ppm = new PowerProjectileMsg(mob, target);
+            //    PowerProjectileMsg ppm = new PowerProjectileMsg(mob, target);
-                ppm.setRange(50);
+            //    ppm.setRange(50);
-                DispatchMessage.dispatchMsgToInterestArea(mob, ppm, DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
+            //    DispatchMessage.dispatchMsgToInterestArea(mob, ppm, DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
-            }
+            //}
 
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackBuilding" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackBuilding" + " " + e.getMessage());
         }
     }
 
@@ -241,7 +272,7 @@ public class MobAI {
                 }
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackMob" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackMob" + " " + e.getMessage());
         }
     }
 
@@ -294,7 +325,7 @@ public class MobAI {
                         }
                     }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
         }
     }
 
@@ -308,33 +339,37 @@ public class MobAI {
             if (mob == null)
                 return false;
 
-            if(mob.isPlayerGuard == true){
+            if (mob.nextCastTime == 0)
+                mob.nextCastTime = System.currentTimeMillis() - 1000L;
+
+            if(mob.nextCastTime > System.currentTimeMillis())
+                return false;
+
+            if(mob.isPlayerGuard){
 
-                int contractID;
+                int contractID = 0;
 
-                if(mob.BehaviourType.equals(Enum.MobBehaviourType.GuardMinion))
+                if(mob.BehaviourType.equals(Enum.MobBehaviourType.GuardMinion) && mob.npcOwner != null)
                     contractID = mob.npcOwner.contract.getContractID();
-                 else
+                 else if(mob.contract != null)
                     contractID = mob.contract.getContractID();
 
-                if(Enum.MinionType.ContractToMinionMap.get(contractID).isMage() == false)
+                if(Enum.MinionType.ContractToMinionMap.containsKey(contractID) && !Enum.MinionType.ContractToMinionMap.get(contractID).isMage())
                     return false;
             }
 
-            if (mob.mobPowers.isEmpty())
+            if (mob.mobPowers == null || mob.mobPowers.isEmpty())
                 return false;
 
             if (!mob.canSee((PlayerCharacter) mob.getCombatTarget())) {
                 mob.setCombatTarget(null);
                 return false;
             }
-            if (mob.nextCastTime == 0)
-                mob.nextCastTime = System.currentTimeMillis();
 
             return mob.nextCastTime <= System.currentTimeMillis();
 
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: canCast" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: canCast" + " " + e.getMessage());
         }
         return false;
     }
@@ -388,6 +423,9 @@ public class MobAI {
 
             PowersBase mobPower = PowersManager.getPowerByToken(powerToken);
 
+            if(mobPower.powerCategory.equals(Enum.PowerCategoryType.DEBUFF))
+                return false;
+
             //check for hit-roll
 
             if (mobPower.requiresHitRoll)
@@ -400,7 +438,7 @@ public class MobAI {
 
                 PerformActionMsg msg;
 
-                if (!mobPower.isHarmful() || mobPower.targetSelf) {
+                if (!mob.StrongholdCommander && !mob.StrongholdEpic && (!mobPower.isHarmful() || mobPower.targetSelf)) {
                     PowersManager.useMobPower(mob, mob, mobPower, powerRank);
                     msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, mob);
                 } else {
@@ -411,13 +449,13 @@ public class MobAI {
                 msg.setUnknown04(2);
 
                 PowersManager.finishUseMobPower(msg, mob, 0, 0);
-                long randomCooldown = (long)((ThreadLocalRandom.current().nextInt(10,15) * 1000) * MobAIThread.AI_CAST_FREQUENCY);
+                long delay = 20000L;
+                mob.nextCastTime = System.currentTimeMillis() + delay;
 
-                mob.nextCastTime = System.currentTimeMillis() + randomCooldown;
                 return true;
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
         }
         return false;
     }
@@ -536,11 +574,10 @@ public class MobAI {
                 PowersManager.finishUseMobPower(msg, mob, 0, 0);
 
                 long randomCooldown = (long)((ThreadLocalRandom.current().nextInt(10,15) * 1000) * MobAIThread.AI_CAST_FREQUENCY);
-                mob.nextCastTime = System.currentTimeMillis() + randomCooldown;
                 return true;
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
         }
         return false;
     }
@@ -576,7 +613,7 @@ public class MobAI {
                 mob.nextCallForHelp = System.currentTimeMillis() + 60000;
 
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCallForHelp" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCallForHelp" + " " + e.getMessage());
         }
     }
 
@@ -584,6 +621,35 @@ public class MobAI {
 
         try {
 
+            //if(mob.isSiege() || mob.isPet() || mob.isPlayerGuard()){
+            //    SuperSimpleMobAI.run(mob);
+            //    return;
+            //}
+            //boolean override;
+            //switch (mob.BehaviourType) {
+            //    case GuardCaptain:
+            //    case GuardMinion:
+            //    case GuardWallArcher:
+            //    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;
+            //}
+
             //always check the respawn que, respawn 1 mob max per second to not flood the client
 
             if (mob == null)
@@ -625,9 +691,6 @@ public class MobAI {
 
                 //check to send mob home for player guards to prevent exploit of dragging guards away and then teleporting
 
-                if (mob.BehaviourType.ordinal() != Enum.MobBehaviourType.Pet1.ordinal())
-                    CheckToSendMobHome(mob);
-
                 return;
             }
 
@@ -646,7 +709,11 @@ public class MobAI {
                 return;
             }
 
-            if (mob.BehaviourType.ordinal() != Enum.MobBehaviourType.Pet1.ordinal())
+            if(mob.isAlive())
+                if(!mob.getMovementLoc().equals(Vector3fImmutable.ZERO))
+                    mob.setLoc(mob.getMovementLoc());
+
+            if(mob.isPet() == false && mob.isPlayerGuard == false)
                 CheckToSendMobHome(mob);
 
             if (mob.getCombatTarget() != null) {
@@ -690,18 +757,22 @@ public class MobAI {
                     HamletGuardLogic(mob);
                     break;
                 default:
+                    //SuperSimpleMobAI.run(mob);
+                    //MobHandler.run(mob);
                     DefaultLogic(mob);
                     break;
             }
             if(mob.isAlive())
                 RecoverHealth(mob);
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: DetermineAction" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: DetermineAction" + " " + e.getMessage());
         }
     }
 
     private static void CheckForAggro(Mob aiAgent) {
 
+
+        //old system
         try {
 
             //looks for and sets mobs combatTarget
@@ -736,13 +807,11 @@ public class MobAI {
                     continue;
 
                 // No aggro for this race type
-
+                if (aiAgent.notEnemy.size() > 0 && aiAgent.notEnemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()))
-                if (aiAgent.notEnemy.size() > 0 && aiAgent.notEnemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()) == true)
                     continue;
 
                 //mob has enemies and this player race is not it
-
+                if (aiAgent.enemy.size() > 0 && !aiAgent.enemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()))
-                if (aiAgent.enemy.size() > 0 && aiAgent.enemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()) == false)
                     continue;
 
                 if (MovementUtilities.inRangeToAggro(aiAgent, loadedPlayer)) {
@@ -771,7 +840,7 @@ public class MobAI {
                 }
             }
         } catch (Exception e) {
-            Logger.info(aiAgent.getObjectUUID() + " " + aiAgent.getName() + " Failed At: CheckForAggro" + " " + e.getMessage());
+            //(aiAgent.getObjectUUID() + " " + aiAgent.getName() + " Failed At: CheckForAggro" + " " + e.getMessage());
         }
     }
 
@@ -832,7 +901,7 @@ public class MobAI {
 
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckMobMovement" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckMobMovement" + " " + e.getMessage());
         }
     }
 
@@ -857,9 +926,7 @@ public class MobAI {
                         return;
                     }
                     //No items in inventory.
-                } else {
+                } else if (aiAgent.isHasLoot()) {
-                    //Mob's Loot has been looted.
-                    if (aiAgent.isHasLoot()) {
                     if (System.currentTimeMillis() > aiAgent.deathTime + MBServerStatics.DESPAWN_TIMER_ONCE_LOOTED) {
                         aiAgent.despawn();
                         aiAgent.deathTime = System.currentTimeMillis();
@@ -873,15 +940,22 @@ public class MobAI {
                             return;
                         }
                     }
+                return;
                 }
-            } else if (System.currentTimeMillis() > (aiAgent.deathTime + (aiAgent.spawnTime * 1000))) {
 
-                if (Zone.respawnQue.contains(aiAgent) == false) {
+            if(Mob.discDroppers.contains(aiAgent))
+                return;
+
+            if(aiAgent.StrongholdGuardian || aiAgent.StrongholdEpic || aiAgent.StrongholdCommander)
+                return;
+
+            if (aiAgent.despawned && System.currentTimeMillis() > (aiAgent.deathTime + (aiAgent.spawnTime * 1000L))) {
+                if (!Zone.respawnQue.contains(aiAgent)) {
                     Zone.respawnQue.add(aiAgent);
                 }
             }
         } catch (Exception e) {
-            Logger.info(aiAgent.getObjectUUID() + " " + aiAgent.getName() + " Failed At: CheckForRespawn" + " " + e.getMessage());
+            //(aiAgent.getObjectUUID() + " " + aiAgent.getName() + " Failed At: CheckForRespawn" + " " + e.getMessage());
         }
     }
 
@@ -896,8 +970,10 @@ public class MobAI {
             if (mob.getCombatTarget() == null)
                 return;
 
-            if (mob.getCombatTarget().getObjectType().equals(Enum.GameObjectType.PlayerCharacter) && MovementUtilities.inRangeDropAggro(mob, (PlayerCharacter) mob.getCombatTarget()) == false && mob.BehaviourType.ordinal() != Enum.MobBehaviourType.Pet1.ordinal()) {
+            if(!mob.isCombat())
+                enterCombat(mob);
 
+            if (mob.getCombatTarget().getObjectType().equals(Enum.GameObjectType.PlayerCharacter) && MovementUtilities.outOfAggroRange(mob, (PlayerCharacter) mob.getCombatTarget()) && mob.BehaviourType.ordinal() != Enum.MobBehaviourType.Pet1.ordinal()) {
                 mob.setCombatTarget(null);
                 return;
             }
@@ -905,26 +981,38 @@ public class MobAI {
                 AttackTarget(mob, mob.getCombatTarget());
 
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckForAttack" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckForAttack" + " " + e.getMessage());
         }
     }
 
     private static void CheckToSendMobHome(Mob mob) {
 
+        if(mob.isNecroPet())
+            return;
+
         try {
+
+            //trebs dont recall
+            if(mob.isSiege())
+                return;
+
+            if(mob.BehaviourType.equals(Enum.MobBehaviourType.Pet1)){
+                if(mob.loc.distanceSquared(mob.getOwner().loc) > 60 * 60)
+                    mob.teleport(mob.getOwner().loc);
+                return;
+            }
+
             if (mob.BehaviourType.isAgressive) {
 
                 if (mob.isPlayerGuard()) {
                     if (mob.BehaviourType.ordinal() == Enum.MobBehaviourType.GuardCaptain.ordinal())
                         CheckForPlayerGuardAggro(mob);
                 } else {
-                    CheckForAggro(mob);
+                    if(mob.combatTarget == null)
+                        NewAggroMechanic(mob);
                 }
             }
 
-            if (mob.getCombatTarget() != null && CombatUtilities.inRange2D(mob, mob.getCombatTarget(), MobAIThread.AI_BASE_AGGRO_RANGE * 0.5f))
-                return;
-
             if (mob.isPlayerGuard() && !mob.despawned) {
 
                 City current = ZoneManager.getCityAtLocation(mob.getLoc());
@@ -934,7 +1022,6 @@ public class MobAI {
                     PowersBase recall = PowersManager.getPowerByToken(-1994153779);
                     PowersManager.useMobPower(mob, mob, recall, 40);
                     mob.setCombatTarget(null);
-
                     if (mob.BehaviourType.ordinal() == Enum.MobBehaviourType.GuardCaptain.ordinal() && mob.isAlive()) {
 
                         //guard captain pulls his minions home with him
@@ -945,7 +1032,7 @@ public class MobAI {
                         }
                     }
                 }
-            } else if (MovementUtilities.inRangeOfBindLocation(mob) == false) {
+            } else if (!MovementUtilities.inRangeOfBindLocation(mob)) {
 
                 PowersBase recall = PowersManager.getPowerByToken(-1994153779);
                 PowersManager.useMobPower(mob, mob, recall, 40);
@@ -953,9 +1040,10 @@ public class MobAI {
 
                 for (Entry playerEntry : mob.playerAgroMap.entrySet())
                     PlayerCharacter.getFromCache((int) playerEntry.getKey()).setHateValue(0);
+                mob.setCombatTarget(null);
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckToSendMobHome" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckToSendMobHome" + " " + e.getMessage());
         }
     }
 
@@ -963,6 +1051,11 @@ public class MobAI {
 
         try {
 
+            if(mob.combatTarget != null && mob.combatTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter) && !mob.canSee((PlayerCharacter)mob.combatTarget)){
+                mob.setCombatTarget(null);
+                return;
+            }
+
             float rangeSquared = mob.getRange() * mob.getRange();
             float distanceSquared = mob.getLoc().distanceSquared2D(mob.getCombatTarget().getLoc());
 
@@ -993,7 +1086,7 @@ public class MobAI {
             mob.updateMovementState();
             mob.updateLocation();
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: chaseTarget" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: chaseTarget" + " " + e.getMessage());
         }
     }
 
@@ -1006,7 +1099,7 @@ public class MobAI {
 
                 //dont scan self.
 
-                if (mob.equals(awoMob) || (mob.agentType.equals(Enum.AIAgentType.GUARD)) == true)
+                if (mob.equals(awoMob) || (mob.agentType.equals(Enum.AIAgentType.GUARD)) || (mob.agentType.equals(Enum.AIAgentType.PET)))
                     continue;
 
                 Mob aggroMob = (Mob) awoMob;
@@ -1025,37 +1118,41 @@ public class MobAI {
                 mob.setCombatTarget(aggroMob);
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: SafeGuardAggro" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: SafeGuardAggro" + " " + e.getMessage());
         }
     }
 
+    public static void checkToDropGuardAggro(Mob mob){
+        City city = mob.guardedCity;
+
+        if(city == null)
+            return;
+        if(mob.combatTarget == null)
+            return;
+
+        //if(city._playerMemory.contains(mob.combatTarget.getObjectUUID()) && mob.combatTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter))
+        //    mob.setCombatTarget(null);
+    }
+
     public static void GuardCaptainLogic(Mob mob) {
 
         try {
+            checkToDropGuardAggro(mob);
             if (mob.getCombatTarget() == null)
                 CheckForPlayerGuardAggro(mob);
 
-            AbstractWorldObject newTarget = ChangeTargetFromHateValue(mob);
-
-            if (newTarget != null) {
-
-                if (newTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {
-                    if (GuardCanAggro(mob, (PlayerCharacter) newTarget))
-                        mob.setCombatTarget(newTarget);
-                } else
-                    mob.setCombatTarget(newTarget);
-
-            }
             CheckMobMovement(mob);
             CheckForAttack(mob);
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardCaptainLogic" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardCaptainLogic" + " " + e.getMessage());
         }
     }
 
     public static void GuardMinionLogic(Mob mob) {
 
         try {
+            checkToDropGuardAggro(mob);
+
             boolean isComanded = mob.npcOwner.isAlive();
             if (!isComanded) {
                 GuardCaptainLogic(mob);
@@ -1069,19 +1166,21 @@ public class MobAI {
             CheckMobMovement(mob);
             CheckForAttack(mob);
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardMinionLogic" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardMinionLogic" + " " + e.getMessage());
         }
     }
 
     public static void GuardWallArcherLogic(Mob mob) {
 
         try {
+            checkToDropGuardAggro(mob);
+
             if (mob.getCombatTarget() == null)
                 CheckForPlayerGuardAggro(mob);
             else
                 CheckForAttack(mob);
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardWallArcherLogic" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardWallArcherLogic" + " " + e.getMessage());
         }
     }
 
@@ -1093,12 +1192,16 @@ public class MobAI {
                 if (ZoneManager.getSeaFloor().zoneMobSet.contains(mob))
                     mob.killCharacter("no owner");
 
+            if(!mob.isSiege())
+                mob.BehaviourType.canRoam = true;
+
+
             if (MovementUtilities.canMove(mob) && mob.BehaviourType.canRoam)
                 CheckMobMovement(mob);
 
             CheckForAttack(mob);
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: PetLogic" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: PetLogic" + " " + e.getMessage());
         }
     }
 
@@ -1114,7 +1217,7 @@ public class MobAI {
 
             CheckForAttack(mob);
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: HamletGuardLogic" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: HamletGuardLogic" + " " + e.getMessage());
         }
     }
 
@@ -1129,17 +1232,11 @@ public class MobAI {
 
             if (mob.BehaviourType.isAgressive) {
 
-                AbstractWorldObject newTarget = ChangeTargetFromHateValue(mob);
-
-                if (newTarget != null)
-                    mob.setCombatTarget(newTarget);
-                else {
                 if (mob.getCombatTarget() == null) {
                     if (mob.BehaviourType == Enum.MobBehaviourType.HamletGuard)
                         SafeGuardAggro(mob);  //safehold guard
                     else
-                            CheckForAggro(mob);   //normal aggro
+                        NewAggroMechanic(mob);//CheckForAggro(mob);   //normal aggro
-                    }
                 }
             }
 
@@ -1153,8 +1250,9 @@ public class MobAI {
             if (!mob.BehaviourType.isWimpy && mob.getCombatTarget() != null)
                 CheckForAttack(mob);
 
+
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: DefaultLogic" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: DefaultLogic" + " " + e.getMessage());
         }
     }
 
@@ -1204,7 +1302,7 @@ public class MobAI {
                 }
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckForPlayerGuardAggro" + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckForPlayerGuardAggro" + e.getMessage());
         }
     }
 
@@ -1267,7 +1365,7 @@ public class MobAI {
                 }
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardCanAggro" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardCanAggro" + " " + e.getMessage());
         }
         return false;
     }
@@ -1316,56 +1414,100 @@ public class MobAI {
                 }
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: randomGuardPatrolPoints" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: randomGuardPatrolPoints" + " " + e.getMessage());
         }
     }
 
-    public static AbstractWorldObject ChangeTargetFromHateValue(Mob mob) {
+    public static void RecoverHealth(Mob mob) {
-
+        //recover health
         try {
+            if (mob.getTimestamps().containsKey("HEALTHRECOVERED") == false)
+                mob.getTimestamps().put("HEALTHRECOVERED", System.currentTimeMillis());
 
-            float CurrentHateValue = 0;
+            if (mob.isSit() && mob.getTimeStamp("HEALTHRECOVERED") < System.currentTimeMillis() + 3000)
+                if (mob.getHealth() < mob.getHealthMax()) {
 
-            if (mob.getCombatTarget() != null && mob.getCombatTarget().getObjectType().equals(Enum.GameObjectType.PlayerCharacter))
+                    float recoveredHealth = mob.getHealthMax() * ((1 + mob.getBonuses().getFloatPercentAll(Enum.ModType.HealthRecoverRate, Enum.SourceType.None)) * 0.01f);
-                CurrentHateValue = ((PlayerCharacter) mob.getCombatTarget()).getHateValue();
+                    mob.setHealth(mob.getHealth() + recoveredHealth);
+                    mob.getTimestamps().put("HEALTHRECOVERED", System.currentTimeMillis());
 
-            AbstractWorldObject mostHatedTarget = null;
+                    if (mob.getHealth() > mob.getHealthMax())
+                        mob.setHealth(mob.getHealthMax());
+                }
+        } catch (Exception e) {
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: RecoverHealth" + " " + e.getMessage());
+        }
+    }
 
-            for (Entry playerEntry : mob.playerAgroMap.entrySet()) {
+    public static void enterCombat(Mob mob){
+        mob.setCombat(true);
+        UpdateStateMsg rwss = new UpdateStateMsg();
+        rwss.setPlayer(mob);
+        DispatchMessage.sendToAllInRange(mob, rwss);
+    }
 
-                PlayerCharacter potentialTarget = PlayerCharacter.getFromCache((int) playerEntry.getKey());
+    public static void NewAggroMechanic(Mob mob){
 
-                if (potentialTarget.equals(mob.getCombatTarget()))
+        if(mob == null || !mob.isAlive() || mob.playerAgroMap.isEmpty()){
-                    continue;
+            return;
+        }
 
-                if (potentialTarget != null && potentialTarget.getHateValue() > CurrentHateValue && MovementUtilities.inRangeToAggro(mob, potentialTarget)) {
+        if(mob.BehaviourType.equals(Enum.MobBehaviourType.HamletGuard)){
-                    CurrentHateValue = potentialTarget.getHateValue();
+            return;
-                    mostHatedTarget = potentialTarget;
         }
 
+        if(mob.hate_values == null)
+            mob.hate_values = new HashMap<>();
+
+        if(mob.combatTarget != null)
+            return;
+
+        HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(mob.loc,60.0f,MBServerStatics.MASK_PLAYER);
+
+        if(inRange.isEmpty()){
+            mob.setCombatTarget(null);
+            return;
         }
-            return mostHatedTarget;
+
-        } catch (Exception e) {
+        //clear out any players who are not in hated range anymore
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: ChangeTargetFromMostHated" + " " + e.getMessage());
+        ArrayList<PlayerCharacter> toRemove = new ArrayList<>();
+        for(PlayerCharacter pc : mob.hate_values.keySet()){
+            if(!inRange.contains(pc))
+                toRemove.add(pc);
         }
-        return null;
+        for(PlayerCharacter pc : toRemove){
+            mob.hate_values.remove(pc);
         }
 
-    public static void RecoverHealth(Mob mob){
+        //find most hated target
-        //recover health
+        PlayerCharacter mostHated = (PlayerCharacter)inRange.iterator().next();
+        for(AbstractWorldObject awo : inRange){
+            PlayerCharacter loadedPlayer = (PlayerCharacter)awo;
+            if (loadedPlayer == null)
+                continue;
 
-        if (mob.getTimestamps().containsKey("HEALTHRECOVERED") == false)
+            //Player is Dead, Mob no longer needs to attempt to aggro. Remove them from aggro map.
-            mob.getTimestamps().put("HEALTHRECOVERED", System.currentTimeMillis());
+            if (!loadedPlayer.isAlive())
+                continue;
 
-        if (mob.isSit() && mob.getTimeStamp("HEALTHRECOVERED") < System.currentTimeMillis() + 3000)
+            //Can't see target, skip aggro.
-            if (mob.getHealth() < mob.getHealthMax()) {
+            if (!mob.canSee(loadedPlayer))
+                continue;
 
-                float recoveredHealth = mob.getHealthMax() * ((1 + mob.getBonuses().getFloatPercentAll(Enum.ModType.HealthRecoverRate, Enum.SourceType.None)) * 0.01f);
+            // No aggro for this race type
-                mob.setHealth(mob.getHealth() + recoveredHealth);
+            if (mob.notEnemy != null && mob.notEnemy.size() > 0 && mob.notEnemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()))
-                mob.getTimestamps().put("HEALTHRECOVERED", System.currentTimeMillis());
+                continue;
 
-                if (mob.getHealth() > mob.getHealthMax())
+            //mob has enemies and this player race is not it
-                    mob.setHealth(mob.getHealthMax());
+            if (mob.enemy != null && mob.enemy.size() > 0 && !mob.enemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()))
+                continue;
+
+            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);
     }
 }

src/engine/mobileAI/MobHandlers/MobHandler.java

@@ -0,0 +1,282 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,449 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,26 @@
+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,6 +3,7 @@ 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;
@@ -27,18 +28,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)
+                                    if (mob != null) {
-                            MobAI.DetermineAction(mob);
+                                        //MobAI.DetermineAction(mob);
+                                        SuperSimpleMobAI.run(mob);
+                                    }
                                 } catch (Exception e) {
-                        Logger.error("Mob: " + mob.getName() + " UUID: " + mob.getObjectUUID() + " ERROR: " + e);
+                                    Logger.error("Error processing Mob [Name: {}, UUID: {}]", mob.getName(), mob.getObjectUUID(), e);
-                        e.printStackTrace();
+                                }
+                            }
+                        }
                     }
                 }
+                Thread.sleep(100);
+            }catch(Exception e){
+                Logger.error(e.getMessage());
             }
         }
     }

src/engine/mobileAI/Threads/MobRespawnThread.java

@@ -13,6 +13,9 @@ import engine.objects.Mob;
 import engine.objects.Zone;
 import org.pmw.tinylog.Logger;
 
+import java.util.ArrayList;
+import java.util.Collection;
+
 /**
  * Thread blocks until MagicBane dispatch messages are
  * enqueued then processes them in FIFO order. The collection
@@ -25,41 +28,48 @@ import org.pmw.tinylog.Logger;
 
 public class MobRespawnThread implements Runnable {
 
+    private volatile boolean running = true;
+    private static final long RESPAWN_INTERVAL = 100; // Configurable interval
 
     public MobRespawnThread() {
-        Logger.info(" MobRespawnThread thread has started!");
+        Logger.info("MobRespawnThread initialized.");
-
     }
 
     @Override
     public void run() {
-
+        while (running) {
-        while (true) {
-
             try {
-                for (Zone zone : ZoneManager.getAllZones()) {
+                Collection<Zone> zones = ZoneManager.getAllZones();
-
+                if (zones != null) {
-                    if (zone.respawnQue.isEmpty() == false && zone.lastRespawn + 100 < System.currentTimeMillis()) {
+                    for (Zone zone : zones) {
-
+                        synchronized (zone) { // Optional: Synchronize on zone
-                        Mob respawner = zone.respawnQue.iterator().next();
+                            if (!Zone.respawnQue.isEmpty() && Zone.lastRespawn + RESPAWN_INTERVAL < System.currentTimeMillis()) {
-
-                        if (respawner == null)
-                            continue;
 
+                                Mob respawner = Zone.respawnQue.iterator().next();
+                                if (respawner != null) {
                                     respawner.respawn();
-                        zone.respawnQue.remove(respawner);
+                                    Zone.respawnQue.remove(respawner);
-                        zone.lastRespawn = System.currentTimeMillis();
+                                    Zone.lastRespawn = System.currentTimeMillis();
+                                    Thread.sleep(100);
                                 }
                             }
+                        }
+                    }
+                }
+                Thread.sleep(100); // Prevent busy-waiting
             } catch (Exception e) {
-                Logger.error(e);
+                Logger.error("Error in MobRespawnThread", e);
             }
-
         }
+        Logger.info("MobRespawnThread stopped.");
     }
+
+    public void stop() {
+        running = false;
+    }
+
     public static void startRespawnThread() {
-        Thread respawnThread;
+        Thread respawnThread = new Thread(new MobRespawnThread());
-        respawnThread = new Thread(new MobRespawnThread());
         respawnThread.setName("respawnThread");
         respawnThread.start();
     }

src/engine/mobileAI/utilities/CombatUtilities.java

@@ -22,7 +22,6 @@ import org.pmw.tinylog.Logger;
 import java.util.concurrent.ThreadLocalRandom;
 
 import static engine.math.FastMath.sqr;
-import static java.lang.Math.pow;
 
 public class CombatUtilities {
 
@@ -101,9 +100,18 @@ public class CombatUtilities {
         if (!target.isAlive())
             return;
 
-        if (AbstractWorldObject.IsAbstractCharacter(target))
+        if(agent.isPet()){
+            try{
+                damage *= agent.getOwner().ZergMultiplier;
+            }catch(Exception ignored){
+
+            }
+        }
+
+        if (AbstractWorldObject.IsAbstractCharacter(target)) {
+            //damage = Resists.handleFortitude((AbstractCharacter) target,DamageType.Crush,damage);
             trueDamage = ((AbstractCharacter) target).modifyHealth(-damage, agent, false);
-        else if (target.getObjectType() == GameObjectType.Building)
+        }else if (target.getObjectType() == GameObjectType.Building)
             trueDamage = ((Building) target).modifyHealth(-damage, agent);
 
         //Don't send 0 damage kay thanx.
@@ -139,37 +147,32 @@ public class CombatUtilities {
     }
 
     public static boolean triggerDefense(Mob agent, AbstractWorldObject target) {
-        int defenseScore = 0;
+        int defense = 0;
-        int attackScore = agent.getAtrHandOne();
+        int atr = agent.mobBase.getAtr();
+        if(agent.getBonuses() != null){
+            atr += agent.getBonuses().getFloat(ModType.OCV,SourceType.None);
+            atr *= 1 + agent.getBonuses().getFloatPercentAll(ModType.OCV,SourceType.None);
+        }
         switch (target.getObjectType()) {
             case PlayerCharacter:
-                defenseScore = ((AbstractCharacter) target).getDefenseRating();
+                PlayerCharacter pc = (PlayerCharacter)target;
+                if(pc.combatStats == null)
+                    pc.combatStats = new PlayerCombatStats(pc);
+                pc.combatStats.calculateDefense();
+                defense = pc.combatStats.defense;
                 break;
             case Mob:
 
                 Mob mob = (Mob) target;
                 if (mob.isSiege())
-                    defenseScore = attackScore;
+                    defense = atr;
+                else
+                    defense = ((Mob) target).mobBase.getDefense();
                 break;
             case Building:
                 return false;
         }
-
+        return !CombatManager.LandHit(atr,defense);
-        int hitChance;
-        if (attackScore > defenseScore || defenseScore == 0)
-            hitChance = 94;
-        else if (attackScore == defenseScore && target.getObjectType() == GameObjectType.Mob)
-            hitChance = 10;
-        else {
-            float dif = attackScore / defenseScore;
-            if (dif <= 0.8f)
-                hitChance = 4;
-            else
-                hitChance = ((int) (450 * (dif - 0.8f)) + 4);
-            if (target.getObjectType() == GameObjectType.Building)
-                hitChance = 100;
-        }
-        return ThreadLocalRandom.current().nextInt(100) > hitChance;
     }
 
     public static boolean triggerBlock(Mob agent, AbstractWorldObject ac) {
@@ -207,12 +210,10 @@ public class CombatUtilities {
                 return;
 
         int anim = 75;
-        float speed;
 
-        if (mainHand)
+        //handle the retaliate here because even if the mob misses you can still retaliate
-            speed = agent.getSpeedHandOne();
+        if (AbstractWorldObject.IsAbstractCharacter(target))
-        else
+            CombatManager.handleRetaliate((AbstractCharacter) target, agent);
-            speed = agent.getSpeedHandTwo();
 
         DamageType dt = DamageType.Crush;
 
@@ -267,12 +268,12 @@ public class CombatUtilities {
             if (agent.getEquip().get(1) != null && agent.getEquip().get(2) != null && agent.getEquip().get(2).getItemBase().isShield() == false) {
                 //mob is duel wielding and should conduct an attack for each hand
                 ItemBase weapon1 = agent.getEquip().get(1).getItemBase();
-                double range1 = getMaxDmg(weapon1.getMinDamage(), agent, weapon1) - getMinDmg(weapon1.getMinDamage(), agent, weapon1);
+                double range1 = getMaxDmg(agent) - getMinDmg(agent);
-                double damage1 = getMinDmg(weapon1.getMinDamage(), agent, weapon1) + ((ThreadLocalRandom.current().nextFloat() * range1) + (ThreadLocalRandom.current().nextFloat() * range1)) / 2;
+                double damage1 = getMinDmg(agent) + ((ThreadLocalRandom.current().nextFloat() * range1) + (ThreadLocalRandom.current().nextFloat() * range1)) / 2;
                 swingIsDamage(agent, target, (float) damage1, CombatManager.getSwingAnimation(weapon1, null, true));
                 ItemBase weapon2 = agent.getEquip().get(2).getItemBase();
-                double range2 = getMaxDmg(weapon2.getMinDamage(), agent, weapon2) - getMinDmg(weapon2.getMinDamage(), agent, weapon2);
+                double range2 = getMaxDmg(agent) - getMinDmg(agent);
-                double damage2 = getMinDmg(weapon2.getMinDamage(), agent, weapon2) + ((ThreadLocalRandom.current().nextFloat() * range2) + (ThreadLocalRandom.current().nextFloat() * range2)) / 2;
+                double damage2 = getMinDmg(agent) + ((ThreadLocalRandom.current().nextFloat() * range2) + (ThreadLocalRandom.current().nextFloat() * range2)) / 2;
                 swingIsDamage(agent, target, (float) damage2, CombatManager.getSwingAnimation(weapon1, null, false));
             } else {
                 swingIsDamage(agent, target, determineDamage(agent), anim);
@@ -294,11 +295,6 @@ public class CombatUtilities {
             if (((Mob) target).isSiege())
                 return;
 
-        //handle the retaliate
-
-        if (AbstractWorldObject.IsAbstractCharacter(target))
-            CombatManager.handleRetaliate((AbstractCharacter) target, agent);
-
         if (target.getObjectType() == GameObjectType.Mob) {
             Mob targetMob = (Mob) target;
             if (targetMob.isSiege())
@@ -322,9 +318,9 @@ public class CombatUtilities {
         float damage = 0;
 
         DamageType dt = getDamageType(agent);
-        if ((agent.agentType.equals(AIAgentType.PET)) == true || agent.isPet() == true || agent.isNecroPet() == true) {
+        if (agent.BehaviourType.equals(MobBehaviourType.Pet1)) {
-            damage = calculatePetDamage(agent);
+            damage = calculateMobDamage(agent);
-        } else if (agent.isPlayerGuard() == true) {
+        } else if (agent.isPlayerGuard()) {
             //damage = calculateGuardDamage(agent);
             damage = calculateMobDamage(agent);
         } else if (agent.getLevel() > 80) {
@@ -333,9 +329,9 @@ public class CombatUtilities {
             damage = calculateMobDamage(agent);
         }
         if (AbstractWorldObject.IsAbstractCharacter(target)) {
-            if (((AbstractCharacter) target).isSit()) {
+            //if (((AbstractCharacter) target).isSit()) {
-                damage *= 2.5f; //increase damage if sitting
+            //    damage *= 2.5f; //increase damage if sitting
-            }
+            //}
             return (int) (((AbstractCharacter) target).getResists().getResistedDamage(agent, (AbstractCharacter) target, dt, damage, 0));
         }
         if (target.getObjectType() == GameObjectType.Building) {
@@ -364,8 +360,8 @@ public class CombatUtilities {
         float min = 40;
         float max = 60;
         float dmgMultiplier = 1 + agent.getBonuses().getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
-        double minDmg = getMinDmg(min, agent, null);
+        double minDmg = getMinDmg(agent);
-        double maxDmg = getMaxDmg(max, agent, null);
+        double maxDmg = getMaxDmg(agent);
         dmgMultiplier += agent.getLevel() * 0.1f;
         range = (float) (maxDmg - minDmg);
         damage = min + ((ThreadLocalRandom.current().nextFloat() * range) + (ThreadLocalRandom.current().nextFloat() * range)) / 2;
@@ -381,8 +377,8 @@ public class CombatUtilities {
 
         double minDmg = weapon.getMinDamage();
         double maxDmg = weapon.getMaxDamage();
-        double min = getMinDmg(minDmg, agent, weapon);
+        double min = getMinDmg(agent);
-        double max = getMaxDmg(maxDmg, agent, weapon);
+        double max = getMaxDmg(agent);
 
         DamageType dt = weapon.getDamageType();
 
@@ -423,92 +419,48 @@ public class CombatUtilities {
     }
 
     public static int calculateMobDamage(Mob agent) {
-        ItemBase weapon = null;
+        double minDmg = getMinDmg(agent);
-        double minDmg;
+        double maxDmg = getMaxDmg(agent);
-        double maxDmg;
+        DamageType dt = getDamageType(agent);
-        DamageType dt;
-
-        //main hand or offhand damage
-
-        if (agent.getEquip().get(1) != null)
-            weapon = agent.getEquip().get(1).getItemBase();
-        else if (agent.getEquip().get(2) != null)
-            weapon = agent.getEquip().get(2).getItemBase();
-
-        if (weapon != null) {
-            minDmg = getMinDmg(weapon.getMinDamage(), agent, weapon);
-            maxDmg = getMaxDmg(weapon.getMaxDamage(), agent, weapon);
-            dt = weapon.getDamageType();
-        } else {
-            minDmg = agent.getMobBase().getDamageMin();
-            maxDmg = agent.getMobBase().getDamageMax();
-            dt = DamageType.Crush;
-        }
 
         AbstractWorldObject target = agent.getCombatTarget();
 
-        float dmgMultiplier = 1 + agent.getBonuses().getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
+        double damage = ThreadLocalRandom.current().nextInt((int)minDmg,(int)maxDmg + 1);
-        double range = maxDmg - minDmg;
-        double damage = minDmg + ((ThreadLocalRandom.current().nextFloat() * range) + (ThreadLocalRandom.current().nextFloat() * range)) / 2;
 
         if (AbstractWorldObject.IsAbstractCharacter(target))
             if (((AbstractCharacter) target).isSit())
                 damage *= 2.5f; //increase damage if sitting
         if (AbstractWorldObject.IsAbstractCharacter(target))
-            return (int) (((AbstractCharacter) target).getResists().getResistedDamage(agent, (AbstractCharacter) target, dt, (float) damage, 0) * dmgMultiplier);
+            return (int) (((AbstractCharacter) target).getResists().getResistedDamage(agent, (AbstractCharacter) target, dt, (float) damage, 0));
         return 0;
     }
 
-    public static double getMinDmg(double min, Mob agent, ItemBase weapon) {
+    public static double getMinDmg(Mob agent) {
-
+            if(agent.getEquip() != null){
-        int primary = agent.getStatStrCurrent();
+                if(agent.getEquip().get(ItemSlotType.RHELD) != null){
-        int secondary = agent.getStatDexCurrent();
+                    return agent.minDamageHandOne;
-        int focusLevel = 0;
+                }else if(agent.getEquip().get(ItemSlotType.LHELD) != null){
-        int masteryLevel = 0;
+                    return agent.getMinDamageHandTwo();
-
+                }else{
-        if (weapon != null) {
+                    return agent.minDamageHandOne;
-            if (weapon.isStrBased() == true) {
-                primary = agent.getStatStrCurrent();
-                secondary = agent.getStatDexCurrent();
-            } else {
-                primary = agent.getStatDexCurrent();
-                secondary = agent.getStatStrCurrent();
-                if (agent.getSkills().containsKey(weapon.getSkillRequired())) {
-                    focusLevel = (int) agent.getSkills().get(weapon.getSkillRequired()).getModifiedAmount();
                 }
-                if (agent.getSkills().containsKey(weapon.getMastery())) {
+            }else{
-                    masteryLevel = (int) agent.getSkills().get(weapon.getMastery()).getModifiedAmount();
+                return agent.minDamageHandOne;
             }
     }
-        }
-        return min * (pow(0.0048 * primary + .049 * (primary - 0.75), 0.5) + pow(0.0066 * secondary + 0.064 * (secondary - 0.75), 0.5) + +0.01 * (focusLevel + masteryLevel));
-    }
-
-    public static double getMaxDmg(double max, Mob agent, ItemBase weapon) {
-
-        int primary = agent.getStatStrCurrent();
-        int secondary = agent.getStatDexCurrent();
-        int focusLevel = 0;
-        int masteryLevel = 0;
-
-        if (weapon != null) {
 
-            if (weapon.isStrBased() == true) {
+    public static double getMaxDmg(Mob agent) {
-                primary = agent.getStatStrCurrent();
+            if(agent.getEquip() != null){
-                secondary = agent.getStatDexCurrent();
+                if(agent.getEquip().get(ItemSlotType.RHELD) != null){
-            } else {
+                    return agent.maxDamageHandOne;
-                primary = agent.getStatDexCurrent();
+                }else if(agent.getEquip().get(ItemSlotType.LHELD) != null){
-                secondary = agent.getStatStrCurrent();
+                    return agent.getMaxDamageHandTwo();
+                }else{
+                    return agent.maxDamageHandOne;
                 }
-
+            }else{
-            if (agent.getSkills().containsKey(weapon.getSkillRequired()))
+                return agent.maxDamageHandOne;
-                focusLevel = (int) agent.getSkills().get(weapon.getSkillRequired()).getModifiedAmount();
-
-            if (agent.getSkills().containsKey(weapon.getSkillRequired()))
-                masteryLevel = (int) agent.getSkills().get(weapon.getMastery()).getModifiedAmount();
-
             }
-        return max * (pow(0.0124 * primary + 0.118 * (primary - 0.75), 0.5) + pow(0.0022 * secondary + 0.028 * (secondary - 0.75), 0.5) + 0.0075 * (focusLevel + masteryLevel));
     }
 
 }

src/engine/mobileAI/utilities/MovementUtilities.java

@@ -98,20 +98,24 @@ public class MovementUtilities {
 
     }
 
-    public static boolean inRangeDropAggro(Mob agent, AbstractCharacter target) {
+    public static boolean outOfAggroRange(Mob agent, AbstractCharacter target) {
 
         Vector3fImmutable sl = agent.getLoc();
         Vector3fImmutable tl = target.getLoc();
 
-        float distanceSquaredToTarget = sl.distanceSquared2D(tl) - sqr(agent.calcHitBox() + target.calcHitBox()); //distance to center of target
+        float disSq = sl.distanceSquared(tl);
-
         float range = agent.getRange() + 150;
 
+
+        //float distanceSquaredToTarget = sl.distanceSquared2D(tl) - sqr(agent.calcHitBox() + target.calcHitBox()); //distance to center of target
+
+
+
         if (range > 200)
             range = 200;
 
 
-        return distanceSquaredToTarget < sqr(range);
+        return disSq > (range * range);
 
     }
 

src/engine/net/AbstractConnection.java

@@ -38,7 +38,7 @@ public abstract class AbstractConnection implements
     protected final AtomicBoolean execTask = new AtomicBoolean(false);
     protected final ReentrantLock writeLock = new ReentrantLock();
     protected final ReentrantLock readLock = new ReentrantLock();
-    protected long lastMsgTime = System.currentTimeMillis();
+    public long lastMsgTime = System.currentTimeMillis();
     protected long lastKeepAliveTime = System.currentTimeMillis();
     protected long lastOpcode = -1;
     protected ConcurrentLinkedQueue<ByteBuffer> outbox = new ConcurrentLinkedQueue<>();