blood mage fix

This reverts commit 685297171c.

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.ItemBase;
-import engine.objects.Shrine;
-import engine.objects.Zone;
+import engine.objects.*;
 import engine.powers.EffectsBase;
 import org.pmw.tinylog.Logger;
 
@@ -211,8 +209,7 @@ public class Enum {
         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),
-        IREKEI(6.1900001f, 13.97f, 4.2199998f, 13.97f, 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;
@@ -472,11 +469,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
-                    spawnLocation = Vector3fImmutable.getRandomPointOnCircle(ruinZone.getLoc()
-                            .add(new Vector3fImmutable(-196.016f, 2.812f, 203.621f)), 30);
+                }else {
+                    //spawnLocation = Vector3fImmutable.getRandomPointOnCircle(ruinZone.getLoc()
+                    //.add(new Vector3fImmutable(-196.016f, 2.812f, 203.621f)), 30);
+                        spawnLocation = Vector3fImmutable.getRandomPointOnCircle(BuildingManager.getBuilding(27977).loc,30f);
+
+                }
             }
 
 
@@ -779,6 +779,7 @@ public class Enum {
         Combat,
         Spires,
         Snare,
+        Snared,
         Stun,
         Blind,
         Root,
@@ -881,6 +882,7 @@ public class Enum {
         Siege,
         Slash,
         Snare,
+        Snared,
         Sorcery,
         Spear,
         SpearMastery,
@@ -1030,6 +1032,7 @@ public class Enum {
         Silence,
         Slash,
         Snare,
+        Snared,
         Stance,
         Stun,
         Summon,
@@ -1154,6 +1157,7 @@ public class Enum {
         SkillDebuff,
         SlashResistanceDebuff,
         Snare,
+        Snared,
         StackableAttrCONBuff,
         StackableAttrDEXBuff,
         StackableAttrSTRBuff,

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.LoadStructureMsg;
-import engine.net.client.msg.MoveToPointMsg;
-import engine.net.client.msg.UnloadObjectsMsg;
+import engine.net.client.msg.*;
 import engine.objects.*;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
@@ -525,11 +522,6 @@ public enum InterestManager implements Runnable {
         player.setDirtyLoad(true);
         updateStaticList(player, origin);
         updateMobileList(player, origin);
-        if(player.level < 10) {
-            player.setLevel((short) 10);
-            player.getCharItemManager().addGoldToInventory(1000,false);
-            player.getCharItemManager().addItemToInventory(new MobLoot(player,ItemBase.getItemBase(980066),1,false).promoteToItem(player));
-        }
     }
 
     public synchronized void HandleLoadForTeleport(PlayerCharacter playerCharacter) {

src/engine/db/handlers/dbBaneHandler.java

@@ -10,17 +10,13 @@
 package engine.db.handlers;
 
 import engine.gameManager.DbManager;
-import engine.objects.Bane;
-import engine.objects.Building;
-import engine.objects.City;
-import engine.objects.PlayerCharacter;
+import engine.gameManager.ZoneManager;
+import engine.math.Vector3fImmutable;
+import engine.objects.*;
 import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
 
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
+import java.sql.*;
 
 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/dbContractHandler.java

@@ -98,32 +98,54 @@ public class dbContractHandler extends dbHandlerBase {
 
     public void LOAD_SELL_LIST_FOR_CONTRACT(final Contract contract) {
 
-        try (Connection connection = DbManager.getConnection();
-             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_contract_selltype` WHERE `contractID` = ?;")) {
+        if(!contract.getName().contains("Sage")) {
+            try (Connection connection = DbManager.getConnection();
+                 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_contract_selltype` WHERE `contractID` = ?;")) {
 
-            preparedStatement.setInt(1, contract.getObjectUUID());
+                preparedStatement.setInt(1, contract.getObjectUUID());
 
-            ResultSet rs = preparedStatement.executeQuery();
+                ResultSet rs = preparedStatement.executeQuery();
 
-            while (rs.next()) {
+                while (rs.next()) {
 
-                int type = rs.getInt("type");
-                int value = rs.getInt("value");
+                    int type = rs.getInt("type");
+                    int value = rs.getInt("value");
 
-                switch (type) {
-                    case 1:
-                        contract.getBuyItemType().add(value);
-                        break;
-                    case 2:
-                        contract.getBuySkillToken().add(value);
-                        break;
-                    case 3:
-                        contract.getBuyUnknownToken().add(value);
-                        break;
+                    switch (type) {
+                        case 1:
+                            contract.getBuyItemType().add(value);
+                            break;
+                        case 2:
+                            contract.getBuySkillToken().add(value);
+                            break;
+                        case 3:
+                            contract.getBuyUnknownToken().add(value);
+                            break;
+                    }
                 }
+            } 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);
             }
-        } catch (SQLException e) {
-            Logger.error(e);
         }
     }
 

src/engine/db/handlers/dbHandlerBase.java

@@ -56,6 +56,13 @@ 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));

src/engine/db/handlers/dbItemBaseHandler.java

@@ -45,6 +45,24 @@ public class dbItemBaseHandler extends dbHandlerBase {
         }
     }
 
+    public void LOAD_DEX_REDUCTION(ItemBase itemBase) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_item_dexpenalty` WHERE `ID` = ?")) {
+
+            preparedStatement.setInt(1, itemBase.getUUID());
+            ResultSet rs = preparedStatement.executeQuery();
+
+            // Check if a result was found
+            if (rs.next()) {
+                itemBase.dexReduction = rs.getFloat("item_bulk_factor");
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+    }
+
     public void LOAD_ANIMATIONS(ItemBase itemBase) {
 
         ArrayList<Integer> tempList = new ArrayList<>();

src/engine/db/handlers/dbItemHandler.java

@@ -134,9 +134,13 @@ public class dbItemHandler extends dbHandlerBase {
 
             ResultSet rs = preparedStatement.executeQuery();
 
-            if (rs.next())
-                worked = rs.getBoolean("result");
-
+            if (rs.next()) {
+                try {
+                    worked = rs.getBoolean("result");
+                }catch(Exception e){
+                    worked = false;
+                }
+            }
         } catch (SQLException e) {
             Logger.error(e);
         }

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/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;
@@ -338,7 +342,8 @@ public class InfoCmd extends AbstractDevCmd {
                 output += newline;
                 output += "isMoving : " + targetPC.isMoving();
                 output += newline;
-                output += "Zerg Multiplier : " + targetPC.ZergMultiplier;
+                output += "Zerg Multiplier : " + targetPC.ZergMultiplier+ newline;
+                output += "Hidden : " + targetPC.getHidden();
                 break;
 
             case NPC:
@@ -493,13 +498,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){
-                    max = 321;
+
+                output += "Damage: " + targetMob.mobBase.getDamageMin() + " - " + targetMob.mobBase.getDamageMax() + newline;
+                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:
@@ -530,6 +538,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/PrintStatsCmd.java

@@ -57,27 +57,36 @@ 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;
-        out += "Stats Base (Modified)" + newline;
-        out += "  Str: " + (int) tar.statStrBase + " (" + tar.getStatStrCurrent() + ')' + ", maxStr: " + tar.getStrMax() + newline;
-        out += "  Dex: " + (int) tar.statDexBase + " (" + tar.getStatDexCurrent() + ')' + ", maxDex: " + tar.getDexMax() + newline;
-        out += "  Con: " + (int) tar.statConBase + " (" + tar.getStatConCurrent() + ')' + ", maxCon: " + tar.getConMax() + newline;
-        out += "  Int: " + (int) tar.statIntBase + " (" + tar.getStatIntCurrent() + ')' + ", maxInt: " + tar.getIntMax() + newline;
-        out += "  Spi: " + (int) tar.statSpiBase + " (" + tar.getStatSpiCurrent() + ')' + ", maxSpi: " + tar.getSpiMax() + newline;
-        throwbackInfo(pc, out);
-        out = "Health: " + tar.getHealth() + ", maxHealth: " + tar.getHealthMax() + newline;
-        out += "Mana: " + tar.getMana() + ", maxMana: " + tar.getManaMax() + newline;
-        out += "Stamina: " + tar.getStamina() + ", maxStamina: " + tar.getStaminaMax() + newline;
-        out += "Defense: " + tar.getDefenseRating() + newline;
-        out += "Main Hand: atr: " + tar.getAtrHandOne() + ", damage: " + tar.getMinDamageHandOne() + " to " + tar.getMaxDamageHandOne() + ", speed: " + tar.getSpeedHandOne() + newline;
-        out += "Off Hand:  atr: " + tar.getAtrHandTwo() + ", damage: " + tar.getMinDamageHandTwo() + " to " + tar.getMaxDamageHandTwo() + ", speed: " + tar.getSpeedHandTwo() + newline;
-        out += "isAlive: " + tar.isAlive() + ", Combat: " + tar.isCombat() + newline;
-        out += "Move Speed: " + tar.getSpeed() + newline;
-        out += "Health Regen: " + tar.getRegenModifier(Enum.ModType.HealthRecoverRate) + newline;
-        out += "Mana Regen: " + tar.getRegenModifier(Enum.ModType.ManaRecoverRate) + newline;
-        out += "Stamina Regen: " + tar.getRegenModifier(Enum.ModType.StaminaRecoverRate) + newline;
-        throwbackInfo(pc, out);
+
+        String newOut = "Server stats for Player " + tar.getFirstName() + newline;
+        newOut += "HEALTH: " + tar.getHealth() + " / " + tar.getHealthMax() + newline;
+        newOut += "MANA: " + tar.getMana() + " / " + tar.getManaMax() + newline;
+        newOut += "STAMINA: " + tar.getStamina() + " / " + tar.getStaminaMax() + newline;
+        newOut += "Unused Stats: " + tar.getUnusedStatPoints() + newline;
+        newOut += "Stats Base (Modified)" + newline;
+        newOut += "  Str: " + (int) tar.statStrBase + " (" + tar.getStatStrCurrent() + ')' + ", maxStr: " + tar.getStrMax() + newline;
+        newOut += "  Dex: " + (int) tar.statDexBase + " (" + tar.getStatDexCurrent() + ')' + ", maxDex: " + tar.getDexMax() + newline;
+        newOut += "  Con: " + (int) tar.statConBase + " (" + tar.getStatConCurrent() + ')' + ", maxCon: " + tar.getConMax() + newline;
+        newOut += "  Int: " + (int) tar.statIntBase + " (" + tar.getStatIntCurrent() + ')' + ", maxInt: " + tar.getIntMax() + newline;
+        newOut += "  Spi: " + (int) tar.statSpiBase + " (" + tar.getStatSpiCurrent() + ')' + ", maxSpi: " + tar.getSpiMax() + newline;
+        newOut += "Move Speed: " + tar.getSpeed() + newline;
+        newOut += "Health Regen: " + tar.combatStats.healthRegen + newline;
+        newOut += "Mana Regen: " + tar.combatStats.manaRegen + newline;
+        newOut += "Stamina Regen: " + tar.combatStats.staminaRegen + newline;
+        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;
+        throwbackInfo(pc, newOut);
     }
 
     public void printStatsMob(PlayerCharacter pc, Mob tar) {

src/engine/devcmd/cmds/SimulateBootyCmd.java

@@ -54,6 +54,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>();
@@ -68,7 +69,10 @@ public class SimulateBootyCmd extends AbstractDevCmd {
                 for (Item lootItem : mob.getCharItemManager().getInventory()) {
                     switch (lootItem.getItemBase().getType()) {
                         case CONTRACT: //CONTRACT
-                            Contracts.add(lootItem);
+                            if(lootItem.getName().contains("Captain"))
+                                GuardContracts.add(lootItem);
+                            else
+                                Contracts.add(lootItem);
                             break;
                         case OFFERING: //OFFERING
                             Offerings.add(lootItem);
@@ -140,9 +144,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,168 @@
+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 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
+            //ItemBase specialLoot = ItemBase.getItemBase(866);
+            //Item promoted = new MobLoot(winner, specialLoot, 1, false).promoteToItem(winner);
+            //promoted.setNumOfItems(21235);
+            //promoted.setName("Special Banker(21235)");
+            //DbManager.ItemQueries.UPDATE_NUM_ITEMS(promoted,21235);
+            //winner.getCharItemManager().addItemToInventory(promoted);
+            //winner.getCharItemManager().updateInventory();
+        }
+    }
+
+    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,500f, 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/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)

src/engine/gameManager/CombatManager.java

@@ -483,16 +483,24 @@ 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));
+                        if (weapon != null && weapon.getBonusPercent(ModType.WeaponSpeed, SourceType.None) != 0f) //add weapon speed bonus
+                            wepSpeed *= (1 + weapon.getBonus(ModType.WeaponSpeed, SourceType.None));
 
-                    if (abstractCharacter.getBonuses() != null && abstractCharacter.getBonuses().getFloatPercentAll(ModType.AttackDelay, SourceType.None) != 0f) //add effects speed bonus
-                        wepSpeed *= (1 + abstractCharacter.getBonuses().getFloatPercentAll(ModType.AttackDelay, SourceType.None));
-
-                    if (wepSpeed < 10)
-                        wepSpeed = 10; //Old was 10, but it can be reached lower with legit buffs,effects.
+                        if (abstractCharacter.getBonuses() != null && abstractCharacter.getBonuses().getFloatPercentAll(ModType.AttackDelay, SourceType.None) != 0f) //add effects speed bonus
+                            wepSpeed *= (1 + abstractCharacter.getBonuses().getFloatPercentAll(ModType.AttackDelay, SourceType.None));
 
+                        if (wepSpeed < 10)
+                            wepSpeed = 10; //Old was 10, but it can be reached lower with legit buffs,effects.
+                    }
                     createTimer(abstractCharacter, slot, wepSpeed, true);
                 }
 
@@ -536,15 +544,27 @@ public enum CombatManager {
 
             if (target == null)
                 return;
-
-            if (mainHand) {
-                atr = ac.getAtrHandOne();
-                minDamage = ac.getMinDamageHandOne();
-                maxDamage = ac.getMaxDamageHandOne();
-            } else {
-                atr = ac.getAtrHandTwo();
-                minDamage = ac.getMinDamageHandTwo();
-                maxDamage = ac.getMaxDamageHandTwo();
+            if(ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                PlayerCharacter pc = (PlayerCharacter) ac;
+                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();
+                    maxDamage = ac.getMaxDamageHandOne();
+                } else {
+                    atr = ac.getAtrHandTwo();
+                    minDamage = ac.getMinDamageHandTwo();
+                    maxDamage = ac.getMaxDamageHandTwo();
+                }
             }
 
             boolean tarIsRat = false;
@@ -638,7 +658,11 @@ public enum CombatManager {
                 }
             } else {
                 AbstractCharacter tar = (AbstractCharacter) target;
-                defense = tar.getDefenseRating();
+                if(tar.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                    defense = ((PlayerCharacter)tar).combatStats.defense;
+                }else {
+                    defense = tar.getDefenseRating();
+                }
                 handleRetaliate(tar, ac);   //Handle target attacking back if in combat and has no other target
             }
 
@@ -662,9 +686,8 @@ public enum CombatManager {
 
             DeferredPowerJob dpj = null;
 
-
-
-            if (LandHit((int)atr,(int)defense)) {
+            boolean hitLanded = LandHit((int)atr,(int)defense);
+            if (hitLanded) {
 
                 if (ac.getObjectType().equals(GameObjectType.PlayerCharacter))
                     updateAttackTimers((PlayerCharacter) ac, target, true);
@@ -693,7 +716,13 @@ public enum CombatManager {
 
                         PlayerBonuses bonus = ac.getBonuses();
                         float attackRange = getWeaponRange(wb, bonus);
-                        dpj.attack(target, attackRange);
+                        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);
@@ -708,7 +737,13 @@ public enum CombatManager {
 
                     if (dpj != null && dpj.getPower() != null && (dpj.getPowerToken() == -1851459567 || dpj.getPowerToken() == -1851489518)) {
                         float attackRange = getWeaponRange(wb, bonuses);
-                        dpj.attack(target, attackRange);
+                        if(specialCaseHitRoll(dpj.getPowerToken())) {
+                            if(hitLanded) {
+                                dpj.attack(target, attackRange);
+                            }
+                        }else{
+                            dpj.attack(target, attackRange);
+                        }
                     }
                 }
 
@@ -867,27 +902,18 @@ public enum CombatManager {
 
                 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) {
-
+                    if(weapon.effects != null){
+                        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)
-                                        ((WeaponProcEffectModifier) aem).applyProc(ac, target);
-
+                                    if (procChance < MBServerStatics.PROC_CHANCE) {
+                                        try {
+                                            ((WeaponProcEffectModifier) mod).applyProc(ac, target);
+                                        }catch(Exception e){
+                                            Logger.error(eff.getName() + " Failed To Cast Proc");
+                                        }
+                                    }
                                 }
                             }
                         }
@@ -916,7 +942,13 @@ public enum CombatManager {
                         if (wp.requiresHitRoll() == false) {
                             PlayerBonuses bonus = ac.getBonuses();
                             float attackRange = getWeaponRange(wb, bonus);
-                            dpj.attack(target, attackRange);
+                            if(specialCaseHitRoll(dpj.getPowerToken())) {
+                                if(hitLanded) {
+                                    dpj.attack(target, attackRange);
+                                }
+                            }else{
+                                dpj.attack(target, attackRange);
+                            }
                         } else
                             ((PlayerCharacter) ac).setWeaponPower(null);
                     }
@@ -1242,14 +1274,17 @@ 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;
 
-        pc.setSit(toggle);
+        if(pc.isFlying())
+            pc.setSit(false);
+        else
+            pc.setSit(toggle);
 
         UpdateStateMsg rwss = new UpdateStateMsg();
         rwss.setPlayer(pc);
@@ -1327,6 +1362,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);
+                    }
+                }
+            }
 
         }
     }
@@ -1443,19 +1485,30 @@ public enum CombatManager {
             ((AbstractCharacter) awo).getCharItemManager().damageRandomArmor(1);
     }
 
-    public static boolean LandHit(int atr, int defense){
+    public static boolean LandHit(int C5, int D5){
+
+        float chance = (C5-((C5+D5) * 0.315f)) / ((D5-((C5+D5) * 0.315f)) + (C5-((C5+D5) * 0.315f)));
+        float convertedChance = chance * 100;
 
         int roll = ThreadLocalRandom.current().nextInt(101);
-        float chance = (float)((atr-((atr+defense)*0.315))/((defense-((atr+defense)*0.315))+(atr-((atr+defense)*0.315))));
 
-        int connvertedChance = (int)(chance * 100);
+        if(roll <= 5)//always 5% chance to miss
+            return false;
 
-        if(connvertedChance < 5)
-            connvertedChance = 5;
+        if(roll >= 95)//always 5% chance to hit
+            return true;
 
-        if(connvertedChance > 95)
-            connvertedChance = 95;
+        return roll <= convertedChance;
+    }
 
-        return connvertedChance > 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

src/engine/gameManager/DevCmdManager.java

@@ -180,16 +180,34 @@ public enum DevCmdManager {
         //kill any commands not available to everyone on production server
         //only admin level can run dev commands on production
         boolean playerAllowed = false;
-        switch(adc.getMainCmdString()){
-            case "printresists":
-            case "printstats":
-            case "printskills":
-            case "printpowers":
-            case "gimme":
-                playerAllowed = true;
-                if(!a.status.equals(Enum.AccountStatus.ADMIN))
-                    target = pcSender;
-                break;
+        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);

src/engine/gameManager/LootManager.java

@@ -40,6 +40,7 @@ public enum LootManager {
     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));
 
     // Drop Rates
 
@@ -74,6 +75,11 @@ public enum LootManager {
     }
 
     public static void GenerateMobLoot(Mob mob) {
+
+        if(mob == null){
+            return;
+        }
+
         //determine if mob is in hotzone
         boolean inHotzone = false;
 
@@ -125,36 +131,70 @@ public enum LootManager {
         boolean hotzoneWasRan = false;
         float dropRate;
 
-        if(!mob.getSafeZone()) {
-            int specialCaseRoll = ThreadLocalRandom.current().nextInt(1, 100000);
-            //Special Case Contract Drop
-            if(specialCaseRoll < 100){
-                SpecialCaseResourceDrop(mob,entries);
-            } else if(specialCaseRoll > 100 && specialCaseRoll < 500){
-                SpecialCaseContractDrop(mob,entries);
-            }else if(specialCaseRoll > 500 && specialCaseRoll < 900){
-                SpecialCaseRuneDrop(mob,entries);
-            } else if(specialCaseRoll > 900 && specialCaseRoll < 910){
+        if (!mob.getSafeZone()) {
+            int contractLow = 1, contractHigh = 400;
+            int runeLow = 401, runeHigh = 800;
+            int resourceLow = 801, resourceHigh = 900;
+            int glassLow = 901, glassHigh = 910;
+            int guardLow = 911, guardHigh = 920;
+
+            // Pre-compute adjusted high values
+            int contractAdjust = 0, runeAdjust = 0, resourceAdjust = 0, glassAdjust = 0, guardAdjust = 0;
+            if (mob.level < 50) {
+                int dif = 50 - mob.level;
+                contractAdjust = (int)(400 * (dif * 0.02f));
+                runeAdjust = (int)(400 * (dif * 0.02f));
+                resourceAdjust = (int)(100 * (dif * 0.02f));
+                glassAdjust = (int)(10 * (dif * 0.02f));
+                guardAdjust = (int)(10 * (dif * 0.02f));
+            }
+
+            // Generate a single random roll
+            int specialCaseRoll = ThreadLocalRandom.current().nextInt(1, 100001);
+
+            // Calculate adjusted high values once
+            int contractHighAdjusted = contractHigh - contractAdjust;
+            int runeHighAdjusted = runeHigh - runeAdjust;
+            int resourceHighAdjusted = resourceHigh - resourceAdjust;
+            int glassHighAdjusted = glassHigh - glassAdjust;
+            int guardHighAdjusted = guardHigh - guardAdjust;
+
+            // Check the roll range and handle accordingly
+            if (specialCaseRoll >= contractLow && specialCaseRoll <= contractHighAdjusted) {
+                SpecialCaseContractDrop(mob, entries);
+            } else if (specialCaseRoll >= runeLow && specialCaseRoll <= runeHighAdjusted) {
+                SpecialCaseRuneDrop(mob, entries);
+            } else if (specialCaseRoll >= resourceLow && specialCaseRoll <= resourceHighAdjusted) {
+                SpecialCaseResourceDrop(mob, entries);
+            } else if (specialCaseRoll >= glassLow && specialCaseRoll <= glassHighAdjusted) {
                 int glassID = rollRandomItem(126);
                 ItemBase glassItem = ItemBase.getItemBase(glassID);
                 if (glassItem != null) {
                     MobLoot toAddGlass = new MobLoot(mob, glassItem, false);
-
-                    if (toAddGlass != null)
-                        mob.getCharItemManager().addItemToInventory(toAddGlass);
+                    mob.getCharItemManager().addItemToInventory(toAddGlass);
+                }
+            } else if (specialCaseRoll >= guardLow && specialCaseRoll <= guardHighAdjusted) {
+                int guardContractID = racial_guard_uuids.get(new java.util.Random().nextInt(racial_guard_uuids.size()));
+                ItemBase guardContract = ItemBase.getItemBase(guardContractID);
+                if (guardContract != null) {
+                    MobLoot toAddContract = new MobLoot(mob, guardContract, false);
+                    mob.getCharItemManager().addItemToInventory(toAddContract);
                 }
             }
         }
 
+
         // 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 (mob.getSafeZone())
+                    if (zone != null && zone.getSafeZone() == (byte)1)
                         return; // no loot to drop in safezones
 
                     dropRate = LootManager.NORMAL_DROP_RATE;

src/engine/gameManager/MaintenanceManager.java

@@ -122,9 +122,9 @@ public enum MaintenanceManager {
 
 
             //no maintenance if day of week doesnt match
-            if (LocalDateTime.now().getDayOfWeek().ordinal() != building.maintDateTime.getDayOfWeek().ordinal()) {
-                continue;
-            }
+            //if (LocalDateTime.now().getDayOfWeek().ordinal() != building.maintDateTime.getDayOfWeek().ordinal()) {
+            //    continue;
+            //}
             //  Add building to maintenance queue
 
             maintList.add(building);

src/engine/gameManager/MovementManager.java

@@ -68,7 +68,7 @@ public enum MovementManager {
 
         if (toMove.getObjectType().equals(GameObjectType.PlayerCharacter)) {
             if (((PlayerCharacter) toMove).isCasting())
-                ((PlayerCharacter) toMove).update();
+                ((PlayerCharacter) toMove).update(false);
         }
 
 
@@ -96,7 +96,7 @@ public enum MovementManager {
         if (!toMove.isMoving())
             toMove.resetLastSetLocUpdate();
         else
-            toMove.update();
+            toMove.update(false);
 
         // Update movement for the player
 
@@ -351,7 +351,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 +408,7 @@ public enum MovementManager {
             if (bonus.getBool(ModType.Stunned, SourceType.None) || bonus.getBool(ModType.CannotMove, SourceType.None))
                 continue;
 
-            member.update();
+            member.update(false);
 
 
             // All checks passed, let's move the player

src/engine/gameManager/PowersManager.java

@@ -8,9 +8,9 @@
 
 package engine.gameManager;
 
-import com.sun.corba.se.spi.orbutil.fsm.ActionBase;
 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;
@@ -28,7 +28,6 @@ import engine.net.client.ClientConnection;
 import engine.net.client.msg.*;
 import engine.objects.*;
 import engine.powers.*;
-import engine.powers.effectmodifiers.AbstractEffectModifier;
 import engine.powers.poweractions.AbstractPowerAction;
 import engine.powers.poweractions.TrackPowerAction;
 import engine.server.MBServerStatics;
@@ -165,6 +164,14 @@ public enum PowersManager {
     public static void usePower(final PerformActionMsg msg, ClientConnection origin,
                                 boolean sendCastToSelf) {
 
+        PlayerCharacter pc = SessionManager.getPlayerCharacter(origin);
+
+        if(!pc.isFlying() && powersBaseByToken.get(msg.getPowerUsedID()) != null && powersBaseByToken.get(msg.getPowerUsedID()).isSpell) //cant be sitting if flying
+            CombatManager.toggleSit(false,origin);
+
+        if(pc.isMoving())
+            pc.stopMovement(pc.getMovementLoc());
+
         if (usePowerA(msg, origin, sendCastToSelf)) {
             // Cast failed for some reason, reset timer
 
@@ -173,13 +180,10 @@ 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);
@@ -194,7 +198,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);
         }
     }
 
@@ -346,8 +351,10 @@ 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;
         }
@@ -591,7 +598,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);
@@ -599,12 +606,12 @@ public enum PowersManager {
         }
 
         // update cast (use skill) fail condition
-        if(pb.token != 429396028) {
+        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.
@@ -614,7 +621,7 @@ public enum PowersManager {
 
 
         if (time > 100) {
-            playerCharacter.update();
+            playerCharacter.update(false);
             playerCharacter.setIsCasting(true);
         }
 
@@ -745,10 +752,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
-        caster.cancelOnCast();
+        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.
@@ -784,13 +792,17 @@ public enum PowersManager {
         if (playerCharacter == null || msg == null)
             return;
 
-        if((msg.getPowerUsedID() == 429495514 || msg.getPowerUsedID() == 429407306) && playerCharacter.getRace().getName().toLowerCase().contains("shade")){
-            //msg.setPowerUsedID(407015607);
-            applyPower(playerCharacter,playerCharacter,playerCharacter.loc,429397210,msg.getNumTrains(),false);
+        if(msg.getPowerUsedID() == 429005674){ //bard sprint
+            //use sprint instead of ballad of beregund the bold
+            //applyPower(playerCharacter,playerCharacter,playerCharacter.loc,429611355,msg.getNumTrains(),false);
+            msg.setPowerUsedID(429611355);
+        }
+        if(msg.getPowerUsedID() == 429494441) {//wildkins chase
+            playerCharacter.removeEffectBySource(EffectSourceType.Root,40,true);
+            playerCharacter.removeEffectBySource(EffectSourceType.Snare,40,true);
         }
-
         if (playerCharacter.isCasting()) {
-            playerCharacter.update();
+            playerCharacter.update(false);
             playerCharacter.updateStamRegen(-100);
         }
 
@@ -2316,7 +2328,7 @@ public enum PowersManager {
 
         // set player is not casting for regens
         if (pc.isCasting()) {
-            pc.update();
+            pc.update(false);
         }
         pc.setIsCasting(false);
 
@@ -2688,7 +2700,7 @@ public enum PowersManager {
 
     public static void cancelOnStun(AbstractCharacter ac) {
         if(ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
-            PlayerCharacter.GroundPlayer((PlayerCharacter)ac);
+            //PlayerCharacter.GroundPlayer((PlayerCharacter)ac);
         }
     }
 
@@ -2835,6 +2847,125 @@ 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:
+                return false;
+        }
+        return true;
+    }
 }
 
 

src/engine/gameManager/SimulationManager.java

@@ -113,9 +113,18 @@ public enum SimulationManager {
         }
 
         try {
-            if ((_cityPulseTime != 0)
-                    && (System.currentTimeMillis() > _cityPulseTime))
-                pulseCities();
+            if ((_cityPulseTime != 0) && (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 : "
@@ -151,7 +160,7 @@ public enum SimulationManager {
 
             if (player == null)
                 continue;
-            player.update();
+            player.update(false);
         }
 
         _updatePulseTime = System.currentTimeMillis() + 500;

src/engine/gameManager/ZergManager.java

@@ -4,14 +4,13 @@ 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);
-            default:
-                return getMultiplier20Man(count);
+            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) {
@@ -22,15 +21,11 @@ public class ZergManager {
             return 0.0f;
 
         switch(count){
-            case 4:
-                return 0.75f;
-            case 5:
-                return 0.60f;
-            case 6:
-                return 0.37f;
-
+            case 4: return 0.63f;
+            case 5: return 0.40f;
+            case 6: return 0.25f;
+            default: return 1.0f;
         }
-        return 1.0f;
     }
     public static float getMultiplier5Man(int count) {
         if(count < 6)
@@ -40,19 +35,13 @@ public class ZergManager {
             return 0.0f;
 
         switch(count){
-            case 6:
-                return 0.75f;
-            case 7:
-                return 0.67f;
-            case 8:
-                return 0.56f;
-            case 9:
-                return 0.43f;
-            case 10:
-                return 0.25f;
-
+            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;
         }
-        return 1.0f;
     }
     public static float getMultiplier10Man(int count) {
         if(count < 11)
@@ -62,31 +51,145 @@ public class ZergManager {
             return 0.0f;
 
         switch(count){
-            case 11:
-                return 0.75f;
-            case 12:
-                return 0.71f;
-            case 13:
-                return 0.67f;
-            case 14:
-                return 0.62f;
-            case 15:
-                return 0.56f;
-            case 16:
-                return 0.50f;
-            case 17:
-                return 0.43f;
-            case 18:
-                return 0.35f;
-            case 19:
-                return 0.25f;
-            case 20:
-                return 0.14f;
-
+            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;
         }
-        return 1.0f;
     }
     public static float getMultiplier20Man(int count) {
-        return getMultiplier10Man(count * 2);
+        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/jobs/AbstractEffectJob.java

@@ -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/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;
 
 /*
@@ -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/loot/ItemTableEntry.java

@@ -52,7 +52,7 @@ public class ItemTableEntry {
         itemTableEntryList = LootManager._itemTables.get(itemTable);
 
         if(itemTableEntryList != null && itemTableEntryList.size() > 1){
-            id =  itemTableEntryList.get(ThreadLocalRandom.current().nextInt(0,itemTableEntryList.size() - 1)).cacheID;
+            id =  itemTableEntryList.get(ThreadLocalRandom.current().nextInt(0, itemTableEntryList.size())).cacheID;
         }
         return id;
     }

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,7 +9,6 @@
 package engine.mobileAI;
 
 import engine.Enum;
-import engine.Enum.DispatchChannel;
 import engine.InterestManagement.WorldGrid;
 import engine.gameManager.*;
 import engine.math.Vector3f;
@@ -19,7 +18,7 @@ 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;
@@ -109,7 +108,7 @@ public class MobAI {
             if (mob.BehaviourType.callsForHelp)
                 MobCallForHelp(mob);
 
-            if (!MovementUtilities.inRangeDropAggro(mob, target)) {
+            if (MovementUtilities.outOfAggroRange(mob, target)) {
                 mob.setCombatTarget(null);
                 return;
             }
@@ -166,9 +165,12 @@ 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;
+            return;
             }
 
             City playercity = ZoneManager.getCityAtLocation(mob.getLoc());
@@ -176,7 +178,7 @@ 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.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())
@@ -205,11 +207,11 @@ public class MobAI {
                 mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
             }
 
-            if (mob.isSiege()) {
-                PowerProjectileMsg ppm = new PowerProjectileMsg(mob, target);
-                ppm.setRange(50);
-                DispatchMessage.dispatchMsgToInterestArea(mob, ppm, DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
-            }
+            //if (mob.isSiege()) {
+            //    PowerProjectileMsg ppm = new PowerProjectileMsg(mob, target);
+            //    ppm.setRange(50);
+            //    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());
@@ -318,20 +320,20 @@ public class MobAI {
             if (mob == null)
                 return false;
 
-            if(mob.isPlayerGuard == true){
+            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())) {
@@ -598,6 +600,9 @@ public class MobAI {
 
             if (mob == null)
                 return;
+            if(mob.isAlive())
+                if(!mob.getMovementLoc().equals(Vector3fImmutable.ZERO))
+                    mob.setLoc(mob.getMovementLoc());
 
             if (mob.getTimestamps().containsKey("lastExecution") == false)
                 mob.getTimestamps().put("lastExecution", System.currentTimeMillis());
@@ -878,6 +883,7 @@ public class MobAI {
                             return;
                         }
                     }
+                return;
                 }
 
             if(Mob.discDroppers.contains(aiAgent))
@@ -886,7 +892,7 @@ public class MobAI {
             if(aiAgent.StrongholdGuardian || aiAgent.StrongholdEpic || aiAgent.StrongholdCommander)
                 return;
 
-            if (System.currentTimeMillis() > (aiAgent.deathTime + (aiAgent.spawnTime * 1000L))) {
+            if (aiAgent.despawned && System.currentTimeMillis() > (aiAgent.deathTime + (aiAgent.spawnTime * 1000L))) {
                 if (!Zone.respawnQue.contains(aiAgent)) {
                     Zone.respawnQue.add(aiAgent);
                 }
@@ -907,8 +913,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;
             }
@@ -922,7 +930,15 @@ public class MobAI {
 
     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);
@@ -948,7 +964,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
@@ -978,6 +993,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());
 
@@ -1044,9 +1064,22 @@ public class MobAI {
         }
     }
 
+    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);
 
@@ -1071,6 +1104,8 @@ public class MobAI {
     public static void GuardMinionLogic(Mob mob) {
 
         try {
+            checkToDropGuardAggro(mob);
+
             boolean isComanded = mob.npcOwner.isAlive();
             if (!isComanded) {
                 GuardCaptainLogic(mob);
@@ -1091,6 +1126,8 @@ public class MobAI {
     public static void GuardWallArcherLogic(Mob mob) {
 
         try {
+            checkToDropGuardAggro(mob);
+
             if (mob.getCombatTarget() == null)
                 CheckForPlayerGuardAggro(mob);
             else
@@ -1386,4 +1423,11 @@ public class MobAI {
             Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: RecoverHealth" + " " + e.getMessage());
         }
     }
+
+    public static void enterCombat(Mob mob){
+        mob.setCombat(true);
+        UpdateStateMsg rwss = new UpdateStateMsg();
+        rwss.setPlayer(mob);
+        DispatchMessage.sendToAllInRange(mob, rwss);
+    }
 }

src/engine/mobileAI/Threads/MobAIThread.java

@@ -28,18 +28,26 @@ public class MobAIThread implements Runnable{
         AI_BASE_AGGRO_RANGE = (int)(60 * Float.parseFloat(ConfigManager.MB_AI_AGGRO_RANGE.getValue()));
         while (true) {
             for (Zone zone : ZoneManager.getAllZones()) {
-
-                for (Mob mob : zone.zoneMobSet) {
-
-                    try {
-                        if (mob != null)
-                            MobAI.DetermineAction(mob);
-                    } catch (Exception e) {
-                        Logger.error("Mob: " + mob.getName() + " UUID: " + mob.getObjectUUID() + " ERROR: " + e);
-                        e.printStackTrace();
+                if (zone != null && zone.zoneMobSet != null) {
+                    synchronized (zone.zoneMobSet) {
+                        for (Mob mob : zone.zoneMobSet) {
+                            try {
+                                if (mob != null) {
+                                    MobAI.DetermineAction(mob);
+                                }
+                            } catch (Exception e) {
+                                Logger.error("Error processing Mob [Name: {}, UUID: {}]", mob.getName(), mob.getObjectUUID(), e);
+                            }
+                        }
                     }
                 }
             }
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                Logger.error("AI Thread interrupted", e);
+                Thread.currentThread().interrupt();
+            }
         }
     }
     public static void startAIThread() {

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,49 @@ 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 (true) {
-
+        while (running) {
             try {
-                for (Zone zone : ZoneManager.getAllZones()) {
+                Collection<Zone> zones = ZoneManager.getAllZones();
+                if (zones != null) {
+                    for (Zone zone : zones) {
+                        synchronized (zone) { // Optional: Synchronize on zone
+                            if (!zone.respawnQue.isEmpty() &&
+                                    zone.lastRespawn + RESPAWN_INTERVAL < System.currentTimeMillis()) {
 
-                    if (zone.respawnQue.isEmpty() == false && zone.lastRespawn + 100 < System.currentTimeMillis()) {
-
-                        Mob respawner = zone.respawnQue.iterator().next();
-
-                        if (respawner == null)
-                            continue;
-
-                        respawner.respawn();
-                        zone.respawnQue.remove(respawner);
-                        zone.lastRespawn = System.currentTimeMillis();
+                                Mob respawner = zone.respawnQue.iterator().next();
+                                if (respawner != null) {
+                                    respawner.respawn();
+                                    zone.respawnQue.remove(respawner);
+                                    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;
-        respawnThread = new Thread(new MobRespawnThread());
+        Thread respawnThread = new Thread(new MobRespawnThread());
         respawnThread.setName("respawnThread");
         respawnThread.start();
     }

src/engine/mobileAI/utilities/CombatUtilities.java

@@ -140,7 +140,11 @@ public class CombatUtilities {
 
     public static boolean triggerDefense(Mob agent, AbstractWorldObject target) {
         int defense = 0;
-        int atr = 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:
                 defense = ((AbstractCharacter) target).getDefenseRating();
@@ -154,7 +158,7 @@ public class CombatUtilities {
             case Building:
                 return false;
         }
-        return CombatManager.LandHit(atr,defense);
+        return !CombatManager.LandHit(atr,defense);
     }
 
     public static boolean triggerBlock(Mob agent, AbstractWorldObject ac) {
@@ -252,12 +256,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 damage1 = getMinDmg(weapon1.getMinDamage(), agent, weapon1) + ((ThreadLocalRandom.current().nextFloat() * range1) + (ThreadLocalRandom.current().nextFloat() * range1)) / 2;
+                double range1 = getMaxDmg(agent) - getMinDmg(agent);
+                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 damage2 = getMinDmg(weapon2.getMinDamage(), agent, weapon2) + ((ThreadLocalRandom.current().nextFloat() * range2) + (ThreadLocalRandom.current().nextFloat() * range2)) / 2;
+                double range2 = getMaxDmg(agent) - getMinDmg(agent);
+                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);
@@ -307,9 +311,9 @@ public class CombatUtilities {
         float damage = 0;
 
         DamageType dt = getDamageType(agent);
-        if ((agent.agentType.equals(AIAgentType.PET)) == true || agent.isPet() == true || agent.isNecroPet() == true) {
-            damage = calculatePetDamage(agent);
-        } else if (agent.isPlayerGuard() == true) {
+        if (agent.BehaviourType.equals(MobBehaviourType.Pet1)) {
+            damage = calculateMobDamage(agent);
+        } else if (agent.isPlayerGuard()) {
             //damage = calculateGuardDamage(agent);
             damage = calculateMobDamage(agent);
         } else if (agent.getLevel() > 80) {
@@ -349,8 +353,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 maxDmg = getMaxDmg(max, agent, null);
+        double minDmg = getMinDmg(agent);
+        double maxDmg = getMaxDmg(agent);
         dmgMultiplier += agent.getLevel() * 0.1f;
         range = (float) (maxDmg - minDmg);
         damage = min + ((ThreadLocalRandom.current().nextFloat() * range) + (ThreadLocalRandom.current().nextFloat() * range)) / 2;
@@ -366,8 +370,8 @@ public class CombatUtilities {
 
         double minDmg = weapon.getMinDamage();
         double maxDmg = weapon.getMaxDamage();
-        double min = getMinDmg(minDmg, agent, weapon);
-        double max = getMaxDmg(maxDmg, agent, weapon);
+        double min = getMinDmg(agent);
+        double max = getMaxDmg(agent);
 
         DamageType dt = weapon.getDamageType();
 
@@ -408,92 +412,48 @@ public class CombatUtilities {
     }
 
     public static int calculateMobDamage(Mob agent) {
-        ItemBase weapon = null;
-        double minDmg;
-        double maxDmg;
-        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;
-        }
+        double minDmg = getMinDmg(agent);
+        double maxDmg = getMaxDmg(agent);
+        DamageType dt = getDamageType(agent);
 
         AbstractWorldObject target = agent.getCombatTarget();
 
-        float dmgMultiplier = 1 + agent.getBonuses().getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
-        double range = maxDmg - minDmg;
-        double damage = minDmg + ((ThreadLocalRandom.current().nextFloat() * range) + (ThreadLocalRandom.current().nextFloat() * range)) / 2;
+        double damage = ThreadLocalRandom.current().nextInt((int)minDmg,(int)maxDmg + 1);
 
         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) {
-
-        int primary = agent.getStatStrCurrent();
-        int secondary = agent.getStatDexCurrent();
-        int focusLevel = 0;
-        int masteryLevel = 0;
-
-        if (weapon != null) {
-            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())) {
-                    masteryLevel = (int) agent.getSkills().get(weapon.getMastery()).getModifiedAmount();
+    public static double getMinDmg(Mob agent) {
+            if(agent.getEquip() != null){
+                if(agent.getEquip().get(ItemSlotType.RHELD) != null){
+                    return agent.minDamageHandOne;
+                }else if(agent.getEquip().get(ItemSlotType.LHELD) != null){
+                    return agent.getMinDamageHandTwo();
+                }else{
+                    return agent.minDamageHandOne;
                 }
+            }else{
+                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) {
-                primary = agent.getStatStrCurrent();
-                secondary = agent.getStatDexCurrent();
-            } else {
-                primary = agent.getStatDexCurrent();
-                secondary = agent.getStatStrCurrent();
+    public static double getMaxDmg(Mob agent) {
+            if(agent.getEquip() != null){
+                if(agent.getEquip().get(ItemSlotType.RHELD) != null){
+                    return agent.maxDamageHandOne;
+                }else if(agent.getEquip().get(ItemSlotType.LHELD) != null){
+                    return agent.getMaxDamageHandTwo();
+                }else{
+                    return agent.maxDamageHandOne;
+                }
+            }else{
+                return agent.maxDamageHandOne;
             }
-
-            if (agent.getSkills().containsKey(weapon.getSkillRequired()))
-                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/NetMsgFactory.java

@@ -13,6 +13,8 @@ import engine.exception.FactoryBuildException;
 import engine.gameManager.ChatManager;
 import engine.net.client.ClientConnection;
 import engine.net.client.Protocol;
+import engine.net.client.msg.ErrorPopupMsg;
+import engine.net.client.msg.PlaceAssetMsg;
 import engine.objects.PlayerCharacter;
 import engine.server.MBServerStatics;
 import org.joda.time.DateTime;
@@ -94,11 +96,9 @@ public class NetMsgFactory {
                 if (origin instanceof ClientConnection) {
                     PlayerCharacter player = ((ClientConnection) origin).getPlayerCharacter();
                     if (player != null) {
-//						if (MBServerStatics.worldServerName.equals("Grief"))
                         Logger.error("Invalid protocol msg for player " + player.getFirstName() + " : " + opcode + " lastopcode: " + origin.lastProtocol.name() + " Error Code : " + errorCode);
-                    } else
-                        Logger.error("Invalid protocol msg  : " + opcode + " lastopcode: " + origin.lastProtocol.name() + " Error Code : " + errorCode);
-
+                        PlaceAssetMsg.sendPlaceAssetError(player.getClientConnection(), 1, "Please Report What You Just Did. Ref Code: " + opcode);
+                    }
                 }
 
                 return null;

src/engine/net/client/ClientConnection.java

@@ -227,10 +227,10 @@ public class ClientConnection extends AbstractConnection {
             SessionManager.remSession(
                     SessionManager.getSession(sessionID));
         } catch (NullPointerException e) {
-            Logger
-                    .error(
-                            "Tried to remove improperly initialized session. Skipping." +
-                                    e);
+            //Logger
+                    //.error(
+                            //"Tried to remove improperly initialized session. Skipping." +
+                                    //e);
         }
     }
 

src/engine/net/client/ClientMessagePump.java

@@ -85,7 +85,7 @@ public class ClientMessagePump implements NetMsgHandler {
         if (pc == null)
             return;
 
-        pc.update();
+        pc.update(false);
         if (msg.getSpeed() == 2)
             pc.setWalkMode(false);
         else
@@ -114,7 +114,7 @@ public class ClientMessagePump implements NetMsgHandler {
         if (pc == null)
             return;
 
-        pc.update();
+        pc.update(false);
 
         pc.setSit(msg.toggleSitStand());
 
@@ -1402,12 +1402,12 @@ public class ClientMessagePump implements NetMsgHandler {
                 Item buy = null;
                 if (msg.getItemType() == GameObjectType.MobEquipment.ordinal()) {
                     ArrayList<MobEquipment> sellInventory = npc.getContract().getSellInventory();
-                    if(npc.contract.getObjectUUID() == 890){ // default steward
-                        sellInventory = npc.getSellInventorySteward();
-                    }
-                    if(npc.contract.getObjectUUID() == 889){ // default builder
-                        sellInventory = npc.getSellInventoryBuilder();
-                    }
+                    //if(npc.contract.getObjectUUID() == 890){ // default steward
+                    //    sellInventory = npc.getSellInventorySteward();
+                    //}
+                    //if(npc.contract.getObjectUUID() == 889){ // default builder
+                    //    sellInventory = npc.getSellInventoryBuilder();
+                    //}
                     if (sellInventory == null) {
                         return;
                     }
@@ -1681,8 +1681,12 @@ public class ClientMessagePump implements NetMsgHandler {
                 return;
             }
 
-            int cost = (int)((toRepair.getMagicValue()/max*(max - dur)) + (npc.getRepairCost() * npc.buyPercent));
-
+            int pointsToRepair = max - dur;
+            double damageRatio = (double)1.0d - (toRepair.getDurabilityMax() - toRepair.getDurabilityCurrent()) / toRepair.getDurabilityMax();
+            int modifiedValue = (int)(damageRatio * toRepair.getMagicValue());
+            int costPerPoint = modifiedValue / toRepair.getDurabilityMax();
+            int modifiedRepairCost = (int)(pointsToRepair * costPerPoint)+ npc.getSpecialPrice();
+            int cost = (int)(modifiedRepairCost * 1 + npc.buyPercent) + npc.getSpecialPrice();
             Building b = (!npc.isStatic()) ? npc.getBuilding() : null;
 
             if (b != null)

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

@@ -78,7 +78,7 @@ public class ActivateNPCMsgHandler extends AbstractClientMsgHandler {
                 return false;
             }
 
-            if (building.getBlueprint().getMaxSlots() == building.getHirelings().size())
+            if (building.getBlueprint().getMaxSlots() == building.getHirelings().size() && building.getRank() != 8)
                 return false;
 
             Item contractItem = Item.getFromCache(msg.getContractItem());

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

@@ -9,6 +9,7 @@
 
 package engine.net.client.handlers;
 
+import engine.Enum;
 import engine.Enum.DispatchChannel;
 import engine.exception.MsgSendException;
 import engine.net.DispatchMessage;
@@ -42,18 +43,24 @@ public class ChangeAltitudeHandler extends AbstractClientMsgHandler {
         if (!AbstractCharacter.CanFly(pc))
             return false;
 
+        if(pc.getBonuses().getBool(Enum.ModType.Stunned, Enum.SourceType.None))
+            return false;
+
         if (pc.isSwimming())
             return false;
         if (pc.region != null && !pc.region.isOutside())
             return false;
 
-
         // Find out if we already have an altitude timer running and if so
         // do not process more alt change requests
 
+        pc.updateFlight();
+
         if (pc.getTakeOffTime() != 0)
             return false;
 
+        pc.setTakeOffTime(System.currentTimeMillis());
+
 
         // remove all movement timers and jobs
         //TODO: test if they can fly
@@ -67,7 +74,7 @@ public class ChangeAltitudeHandler extends AbstractClientMsgHandler {
         if (pc.getAltitude() == 0 && !msg.up())
             return true;
 
-        pc.update();
+        pc.update(false);
         pc.stopMovement(pc.getLoc());
         msg.setStartAlt(pc.getAltitude());
         if (msg.up()) {
@@ -132,7 +139,7 @@ public class ChangeAltitudeHandler extends AbstractClientMsgHandler {
         }
 
         if (msg.up()) {
-            pc.update();
+            pc.update(false);
             pc.setDesiredAltitude(targetAlt);
             pc.setTakeOffTime(System.currentTimeMillis());
         } else {
@@ -158,7 +165,7 @@ public class ChangeAltitudeHandler extends AbstractClientMsgHandler {
             } else
                 pc.setDesiredAltitude(targetAlt);
 
-            pc.update();
+            pc.update(false);
 
 
             pc.setTakeOffTime(System.currentTimeMillis());

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

@@ -61,7 +61,7 @@ public class HirelingServiceMsgHandler extends AbstractClientMsgHandler {
                     return true;
 
 
-                npc.setRepairCost(msg.repairCost);
+                npc.setSpecialPrice(msg.repairCost);
                 ManageNPCMsg outMsg = new ManageNPCMsg(npc);
                 Dispatch dispatch = Dispatch.borrow(player, msg);
 

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

@@ -274,60 +274,85 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
             }
         }
 
-        if (targetCity == null)
-            return;
-
-        //verify level required to teleport or repledge
-
-        Guild toGuild = targetCity.getGuild();
-
-        if (toGuild != null)
-            if (isTeleport) {
-                if (player.getLevel() < toGuild.getTeleportMin() || player.getLevel() > toGuild.getTeleportMax())
-                    return;
-            } else if (player.getLevel() < toGuild.getRepledgeMin() || player.getLevel() > toGuild.getRepledgeMax())
+        if (targetCity == null){
+            Mine mineTele = null;
+            for(Mine mine : Mine.getMinesToTeleportTo(player)){
+                if(mine.getObjectUUID() == msg.getCityID()){
+                    mineTele = mine;
+                }
+            }
+            if(mineTele == null){
                 return;
+            }else {
+                int time = MBServerStatics.TELEPORT_TIME_IN_SECONDS;
+                msg.setTeleportTime(time);
+                Building tower = Mine.getTower(mineTele);
+                if (tower == null)
+                    return;
+                Vector3fImmutable teleportLoc = Vector3fImmutable.getRandomPointOnCircle(tower.getLoc(), 10);
+                ChatManager.chatSystemInfo(player, "You Will Teleport To " + mineTele.getParentZone().getParent().getName() + "'s Mine In " + time +  " Seconds.");
+                if (time > 0) {
+                    //TODO add timer to teleport
+                    TeleportJob tj = new TeleportJob(player, npc, teleportLoc, origin, true);
+                    JobScheduler.getInstance().scheduleJob(tj, time * 1000);
+                }
+            }
+        }else{
+            //finish porting to a city
+            //verify level required to teleport or repledge
 
-        boolean joinedGuild = false;
+            Guild toGuild = targetCity.getGuild();
 
-        //if repledge, reguild the player
+            if (toGuild != null)
+                if (isTeleport) {
+                    if (player.getLevel() < toGuild.getTeleportMin() || player.getLevel() > toGuild.getTeleportMax())
+                        return;
+                } else if (player.getLevel() < toGuild.getRepledgeMin() || player.getLevel() > toGuild.getRepledgeMax())
+                    return;
 
-        if (!isTeleport)
-            joinedGuild = GuildManager.joinGuild(player, targetCity.getGuild(), targetCity.getObjectUUID(), GuildHistoryType.JOIN);
+            boolean joinedGuild = false;
 
-        int time;
+            //if repledge, reguild the player
 
-        if (!isTeleport) //repledge
-            time = MBServerStatics.REPLEDGE_TIME_IN_SECONDS;
-        else
-            time = MBServerStatics.TELEPORT_TIME_IN_SECONDS;
+            if (!isTeleport)
+                joinedGuild = GuildManager.joinGuild(player, targetCity.getGuild(), targetCity.getObjectUUID(), GuildHistoryType.JOIN);
 
-        //resend message
-        msg.setTeleportTime(time);
+            int time;
 
-        if ((!isTeleport && joinedGuild) || (isTeleport)) {
+            if (!isTeleport) //repledge
+                time = MBServerStatics.REPLEDGE_TIME_IN_SECONDS;
+            else
+                time = MBServerStatics.TELEPORT_TIME_IN_SECONDS;
 
-            dispatch = Dispatch.borrow(player, msg);
-            DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
+            //resend message
+            msg.setTeleportTime(time);
+
+            if ((!isTeleport && joinedGuild) || (isTeleport)) {
+
+                dispatch = Dispatch.borrow(player, msg);
+                DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
+            }
+
+            //teleport player to city
+
+            Vector3fImmutable teleportLoc;
+
+            if (targetCity.getTOL().getRank() == 8)
+                teleportLoc = targetCity.getTOL().getStuckLocation();
+            else
+                teleportLoc = Vector3fImmutable.getRandomPointOnCircle(targetCity.getTOL().getLoc(), MBServerStatics.TREE_TELEPORT_RADIUS);
+
+            if (time > 0) {
+                //TODO add timer to teleport
+                TeleportJob tj = new TeleportJob(player, npc, teleportLoc, origin, true);
+                JobScheduler.getInstance().scheduleJob(tj, time * 1000);
+            } else if (joinedGuild) {
+                player.teleport(teleportLoc);
+                player.setSafeMode();
+            }
         }
 
-        //teleport player to city
 
-        Vector3fImmutable teleportLoc;
-
-        if (targetCity.getTOL().getRank() == 8)
-            teleportLoc = targetCity.getTOL().getStuckLocation();
-        else
-            teleportLoc = Vector3fImmutable.getRandomPointOnCircle(targetCity.getTOL().getLoc(), MBServerStatics.TREE_TELEPORT_RADIUS);
-
-        if (time > 0) {
-            //TODO add timer to teleport
-            TeleportJob tj = new TeleportJob(player, npc, teleportLoc, origin, true);
-            JobScheduler.getInstance().scheduleJob(tj, time * 1000);
-        } else if (joinedGuild) {
-            player.teleport(teleportLoc);
-            player.setSafeMode();
-        }
     }
 
     private static PowersBase getPowerforHermit(NPC npc) {

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

@@ -1148,6 +1148,15 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
             wallPiece.setProtectionState(ProtectionState.PROTECTED);
             PlaceAssetMsg.sendPlaceAssetConfirmWall(origin, serverZone);
 
+            //walls in R8 city are immediately granted extra HP by 10%
+            if(cityObject.getTOL().getRank() == 8) {
+                if (wallPiece.getBlueprint() != null && wallPiece.getBlueprint().getBuildingGroup() != null && wallPiece.getBlueprint().isWallPiece()) {
+                    float currentHealthRatio = wallPiece.getCurrentHitpoints() / wallPiece.healthMax;
+                    float newMax = wallPiece.healthMax * 1.1f;
+                    wallPiece.setMaxHitPoints(newMax);
+                    wallPiece.setHealth(wallPiece.healthMax * currentHealthRatio);
+                }
+            }
         }
 
         // Deduct gold from character's inventory

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

@@ -146,6 +146,8 @@ public class ApplyRuneMsg extends ClientNetMsg {
                     valid = true;
                 if(runeID == 3035 && baseClassID == 2501)
                     valid = true;
+                if(runeID == 3028 && baseClassID == 2501 && playerCharacter.getRace().getName().contains("Irekei"))
+                    valid = true;
                 if (!valid) {
                     return false;
                 }
@@ -154,6 +156,7 @@ public class ApplyRuneMsg extends ClientNetMsg {
             ConcurrentHashMap<Integer, Boolean> promotionClasses = rb.getPromotionClass();
             if (promotionClasses.size() > 0) {
                 int promotionClassID = playerCharacter.getPromotionClassID();
+                int baseClassID = playerCharacter.getBaseClassID();
                 boolean valid = false;
                 for (int validID : promotionClasses.keySet()) {
                     if (validID == promotionClassID) {
@@ -169,6 +172,10 @@ public class ApplyRuneMsg extends ClientNetMsg {
                     valid = true;
                 if(runeID == 3033 && raceID == 1999)
                     valid = true;
+                if(runeID == 3028 && (raceID == 2013 || raceID == 2014) && playerCharacter.getBaseClassID() == 2501)
+                    valid = true;
+                if(runeID == 3035 && baseClassID == 2501)
+                    valid = true;
                 if (!valid) {
                     return false;
                 }
@@ -195,7 +202,7 @@ public class ApplyRuneMsg extends ClientNetMsg {
         for (CharacterRune cr : runes) {
             int runeBaseID = cr.getRuneBaseID();
             //count number of discipline runes
-            if (runeBaseID > 3000 && runeBaseID < 3049) {
+            if(isDiscipline(runeBaseID)){
                 discCount++;
             }
             //see if rune is already applied
@@ -324,23 +331,27 @@ public class ApplyRuneMsg extends ClientNetMsg {
                 break;
         }
         //if discipline, check number applied
+        int discAllowed = 0;
         if (isDiscipline(runeID)) {
             switch(playerCharacter.getRank()){
                 case 1:
+                    discAllowed = 0;
+                    break;
                 case 2:
                 case 3:
                 case 4:
                 case 5:
                 case 6:
-                    if(discCount > 3)
-                        return false;
+                    discAllowed = 3;
                     break;
                 case 7:
                 case 8:
-                    if(discCount > 5)
-                        return false;
+                    discAllowed = 5;
                     break;
             }
+
+            if(discCount >= discAllowed)
+                return false;
         }
         //Everything succeeded. Let's apply the rune
         //Attempt add rune to database

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

@@ -112,12 +112,12 @@ public class BuyFromNPCWindowMsg extends ClientNetMsg {
 
             if (contract != null)
                 sellInventory = contract.getSellInventory();
-            if(npc.contract.getObjectUUID() == 890){ // default steward
-                sellInventory = npc.getSellInventorySteward();
-            }
-            if(npc.contract.getObjectUUID() == 889){ // default builder
-                sellInventory = npc.getSellInventoryBuilder();
-            }
+            //if(npc.contract.getObjectUUID() == 890){ // default steward
+            //    sellInventory = npc.getSellInventorySteward();
+           // }
+            //if(npc.contract.getObjectUUID() == 889){ // default builder
+           //     sellInventory = npc.getSellInventoryBuilder();
+           // }
         }
 
         if (man != null)

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

@@ -392,9 +392,9 @@ public class ManageCityAssetsMsg extends ClientNetMsg {
             writer.putInt(bane.getSiegePhase().ordinal()); //1 challenge //2 standoff //3 war
             writer.put((byte) 0);
 
-            if (!bane.isAccepted() && this.assetManager.getGuild() == banedCity.getGuild() && GuildStatusController.isInnerCouncil(this.assetManager.getGuildStatus()))
-                writer.put((byte) 1); //canSetTime
-            else
+            //if (!bane.isAccepted() && this.assetManager.getGuild() == banedCity.getGuild() && GuildStatusController.isInnerCouncil(this.assetManager.getGuildStatus()))
+            //    writer.put((byte) 1); //canSetTime
+            //else
                 writer.put((byte) 0);
 
             DateTime placedOn = bane.getLiveDate();

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

@@ -503,7 +503,7 @@ public class ManageNPCMsg extends ClientNetMsg {
                         writer.putInt(0);
                         writer.putString("Repair items");
                         writer.putString("percent");
-                        writer.putInt(npc.getRepairCost()); //cost for repair
+                        writer.putInt(npc.getSpecialPrice()); //cost for repair
                         writer.putInt(0);
 
                         ArrayList<Integer> modPrefixList = npc.getModTypeTable();

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

@@ -16,7 +16,9 @@ import engine.net.ByteBufferReader;
 import engine.net.ByteBufferWriter;
 import engine.net.client.Protocol;
 import engine.objects.City;
+import engine.objects.Mine;
 import engine.objects.PlayerCharacter;
+import org.pmw.tinylog.Logger;
 
 import java.util.ArrayList;
 
@@ -24,6 +26,7 @@ import java.util.ArrayList;
 public class TeleportRepledgeListMsg extends ClientNetMsg {
 
     ArrayList<City> cities;
+    ArrayList<Mine> mines;
     private PlayerCharacter player;
     private boolean isTeleport;
 
@@ -77,10 +80,19 @@ public class TeleportRepledgeListMsg extends ClientNetMsg {
 
     public void configure() {
 
-        if (isTeleport)
+        if (isTeleport) {
             cities = City.getCitiesToTeleportTo(player);
-        else
+            try {
+                mines = Mine.getMinesToTeleportTo(player);
+                if(mines == null)
+                    mines = new ArrayList<>();
+            }catch(Exception e){
+                Logger.error("Unable To Load Mines For Teleport: " + e.getMessage());
+            }
+        }else {
             cities = City.getCitiesToRepledgeTo(player);
+            mines = new ArrayList<>();
+        }
     }
 
     /**
@@ -96,10 +108,14 @@ public class TeleportRepledgeListMsg extends ClientNetMsg {
         for (int i = 0; i < 3; i++)
             writer.putInt(0);
 
-        writer.putInt(cities.size());
+        writer.putInt(cities.size() + mines.size());
 
         for (City city : cities)
             City.serializeForClientMsg(city, writer);
+
+        for(Mine mine : mines)
+            Mine.serializeForClientMsgTeleport(mine, writer);
+
     }
 
     public PlayerCharacter getPlayer() {

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

@@ -96,11 +96,6 @@ public class VendorDialogMsg extends ClientNetMsg {
             return;
         }
 
-
-        if(npc.contractUUID == 1502040){ //enrollment officer
-            PlayerCharacter.unboxPlayer(playerCharacter);
-        }
-
         // Restrict disc trainers to only characters who have
         // tht disc applied.
 
@@ -119,26 +114,36 @@ public class VendorDialogMsg extends ClientNetMsg {
 
         VendorDialog vd = null;
         Contract contract = npc.getContract();
+        if(npc.contractUUID == 1502043){
+            vd = Contract.HandleArenaMaster(msg.unknown03,npc,playerCharacter);
+            msg.updateMessage(3, vd);
+        }else if(npc.contractUUID == 1502040){ //enrollment officer
+            //PlayerCharacter.unboxPlayer(playerCharacter);
+            vd = Contract.HandleEnrollmentOfficer(msg.unknown03,npc,playerCharacter);
+            msg.updateMessage(3, vd);
+        }else if(contract.getContractID() == 1502042){
+           vd = Contract.HandleBaneCommanderOptions(msg.unknown03, npc, playerCharacter);
+           msg.updateMessage(3, vd);
+        }else {
 
-        if (contract == null)
-            vd = VendorDialog.getHostileVendorDialog();
-        else if (npc.getBuilding() != null) {
-            if (BuildingManager.IsPlayerHostile(npc.getBuilding(), playerCharacter))
+            if (contract == null)
                 vd = VendorDialog.getHostileVendorDialog();
-            else
+            else if (npc.getBuilding() != null) {
+                if (npc.getBuilding() != null && BuildingManager.IsPlayerHostile(npc.getBuilding(), playerCharacter))
+                    vd = VendorDialog.getHostileVendorDialog();
+                else
+                    vd = contract.getVendorDialog();
+            } else
                 vd = contract.getVendorDialog();
-        } else
-            vd = contract.getVendorDialog();
-        if (vd == null)
-            vd = VendorDialog.getHostileVendorDialog();
-
+            if (vd == null)
+                vd = VendorDialog.getHostileVendorDialog();
         if (msg.messageType == 1 || msg.unknown03 == vd.getObjectUUID()) {
             msg.updateMessage(3, vd);
         } else {
             if (VendorDialogMsg.handleSpecialCase(msg, npc, playerCharacter, vd, origin))
                 return;
-
-            vd = VendorDialog.getVendorDialog(msg.unknown03);
+        }
+            //vd = VendorDialog.getVendorDialog(msg.unknown03);
             msg.updateMessage(3, vd);
         }
 
@@ -570,6 +575,7 @@ public class VendorDialogMsg extends ClientNetMsg {
             case 2519:
             case 2520:
             case 2521:
+            case 2523:
                 valid = true;
                 break;
         }
@@ -625,6 +631,11 @@ public class VendorDialogMsg extends ClientNetMsg {
                 .getObjectUUID(), true);
         DispatchMessage.dispatchMsgToInterestArea(pc, arm, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
 
+        if(pc.getCharItemManager() != null && pc.getCharItemManager().getGoldInventory() != null && pc.getCharItemManager().getGoldInventory().getNumOfItems() < 1000) {
+            pc.getCharItemManager().addGoldToInventory(1000, false);
+            pc.getCharItemManager().addItemToInventory(new MobLoot(pc, ItemBase.getItemBase(980066), 1, false).promoteToItem(pc));
+            pc.getCharItemManager().updateInventory();
+        }
 
     }
 

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

@@ -63,6 +63,9 @@ public class WhoResponseMsg extends ClientNetMsg {
 
     public static void HandleResponse(int set, int filterType, String filter, ClientConnection origin) {
 
+        if (filter.equals("")) {
+            filter = "Saetor";
+        }
         WhoResponseMsg msg = new WhoResponseMsg();
         WhoResponseMsg.setWorldPop(SessionManager.getAllActivePlayerCharacters().size());
 

src/engine/objects/AbstractCharacter.java

@@ -14,10 +14,7 @@ import engine.Enum.*;
 import engine.InterestManagement.InterestManager;
 import engine.InterestManagement.WorldGrid;
 import engine.exception.SerializationException;
-import engine.gameManager.CombatManager;
-import engine.gameManager.ConfigManager;
-import engine.gameManager.MovementManager;
-import engine.gameManager.PowersManager;
+import engine.gameManager.*;
 import engine.job.AbstractJob;
 import engine.job.JobContainer;
 import engine.job.JobScheduler;
@@ -31,7 +28,6 @@ import engine.net.ByteBufferWriter;
 import engine.net.DispatchMessage;
 import engine.net.client.msg.UpdateStateMsg;
 import engine.powers.EffectsBase;
-import engine.powers.effectmodifiers.AbstractEffectModifier;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
@@ -504,7 +500,6 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
             canFly = false;
         }
 
-
         return canFly;
 
     }
@@ -765,7 +760,11 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
     public abstract Vector3fImmutable getBindLoc();
 
     public final void setBindLoc(final Vector3fImmutable value) {
-        this.bindLoc = value;
+        if(this.getObjectType().equals(GameObjectType.PlayerCharacter) && this.guild.getNation().equals(Guild.getErrantGuild())){
+            this.bindLoc = Vector3fImmutable.getRandomPointOnCircle(BuildingManager.getBuilding(27977).loc,20f);
+        }else {
+            this.bindLoc = value;
+        }
     }
 
     public final Vector3fImmutable getFaceDir() {
@@ -1102,7 +1101,7 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
     }
 
     public final void setCombatTarget(final AbstractWorldObject value) {
-        if(this.getObjectTypeMask() == 2050) {//MOB?
+        if (this.getObjectTypeMask() == 2050) {//MOB?
             if (value == null) {
                 if (this.isCombat()) {
                     this.setCombat(false);
@@ -1110,13 +1109,6 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
                     rwss.setPlayer(this);
                     DispatchMessage.sendToAllInRange(this, rwss);
                 }
-                }else {
-                if (!this.isCombat()) {
-                    this.setCombat(true);
-                    UpdateStateMsg rwss = new UpdateStateMsg();
-                    rwss.setPlayer(this);
-                    DispatchMessage.sendToAllInRange(this, rwss);
-                }
             }
         }
         this.combatTarget = value;
@@ -1559,7 +1551,15 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
             Effect eff = this.effects.get(s);
             if (eff == null)
                 continue;
-            if (eff.cancelOnMove() && eff.cancel()) {
+
+            Boolean override = false;
+            if(this.getObjectType().equals(GameObjectType.PlayerCharacter)) {
+                PlayerCharacter pc = (PlayerCharacter) this;
+                if (eff.getEffectsBase().getIDString().equals("INVIS-B") && s.equals("Invisible") && pc.getRace().getName().contains("Shade"))
+                    override = true;
+            }
+
+            if (!override && eff.cancelOnMove() && eff.cancel()) {
                 //System.out.println("canceling on Move");
                 eff.cancelJob();
                 this.effects.remove(s);
@@ -1841,7 +1841,7 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
     }
 
     //updates
-    public void update() {
+    public void update(Boolean newSystem) {
     }
 
     public void updateRegen() {
@@ -1861,16 +1861,16 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
             try {
                 switch (updateType) {
                     case ALL:
-                        update();
+                        update(false);
                         break;
                     case REGEN:
                         updateRegen();
                         break;
                     case LOCATION:
-                        update();
+                        update(false);
                         break;
                     case MOVEMENTSTATE:
-                        update();
+                        update(false);
                         break;
                     case FLIGHT:
                         updateFlight();

src/engine/objects/AbstractWorldObject.java

@@ -270,7 +270,7 @@ public abstract class AbstractWorldObject extends AbstractGameObject {
             this.effects.remove(name);
             if (this.getObjectType().equals(GameObjectType.PlayerCharacter))
                 if (name.equals("Flight")) {
-                    ((PlayerCharacter) this).update();
+                    ((PlayerCharacter) this).update(false);
                     PlayerCharacter.GroundPlayer((PlayerCharacter) this);
                 }
         }
@@ -385,7 +385,7 @@ public abstract class AbstractWorldObject extends AbstractGameObject {
                     if (source.equals("Flight")) {
                         //ground player
                         if (this.getObjectType().equals(GameObjectType.PlayerCharacter)) {
-                            ((PlayerCharacter) this).update();
+                            ((PlayerCharacter) this).update(false);
                             PlayerCharacter.GroundPlayer((PlayerCharacter) this);
                         }
                     }
@@ -414,7 +414,7 @@ public abstract class AbstractWorldObject extends AbstractGameObject {
                 if (source.equals("Flight")) {
                     //ground player
                     if (this.getObjectType().equals(GameObjectType.PlayerCharacter)) {
-                        ((PlayerCharacter) this).update();
+                        ((PlayerCharacter) this).update(false);
                         PlayerCharacter.GroundPlayer((PlayerCharacter) this);
                     }
                 }

src/engine/objects/Arena.java

@@ -0,0 +1,82 @@
+package engine.objects;
+
+import engine.InterestManagement.WorldGrid;
+import engine.gameManager.ArenaManager;
+import engine.gameManager.ChatManager;
+import engine.gameManager.MovementManager;
+import engine.math.Vector3fImmutable;
+import engine.server.MBServerStatics;
+
+import java.util.HashSet;
+
+public class Arena {
+    public PlayerCharacter player1;
+    public PlayerCharacter player2;
+    public Long startTime;
+    public Vector3fImmutable loc;
+
+    public Arena(){
+
+    }
+    public Boolean disqualify() {
+        HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(this.loc, 250f, MBServerStatics.MASK_PLAYER);
+        HashSet<AbstractWorldObject> warningRange = WorldGrid.getObjectsInRangePartial(this.loc, 500f, MBServerStatics.MASK_PLAYER);
+        for(AbstractWorldObject obj : warningRange){
+            PlayerCharacter pc = (PlayerCharacter)obj;
+            if(pc.equals(this.player1) || pc.equals(this.player2))
+                continue;
+
+            ChatManager.chatSystemInfo(pc, "WARNING!! You are entering an arena zone!");
+        }
+        //boot out all non competitors
+        for(AbstractWorldObject obj : inRange){
+            if(obj.equals(this.player1))
+                continue;
+
+            if(obj.equals(this.player2))
+                continue;
+
+            PlayerCharacter intruder = (PlayerCharacter)obj;
+            MovementManager.translocate(intruder,new Vector3fImmutable(88853,32,45079),Regions.GetRegionForTeleport(new Vector3fImmutable(88853,32,45079)));
+        }
+
+        if (!inRange.contains(this.player1) && inRange.contains(this.player2)) {
+            ArenaManager.endArena(this,this.player2,this.player1,"Player Has Left Arena");
+            return true;
+        } else if (!inRange.contains(this.player2) && inRange.contains(this.player1)) {
+            ArenaManager.endArena(this,this.player1,this.player2,"Player Has Left Arena");
+            return true;
+        }else if (!inRange.contains(this.player2) && !inRange.contains(this.player1)) {
+            ArenaManager.endArena(this,null,null,"Both Parties Have Left The Arena");
+            return true;
+        }
+        return false;
+    }
+
+    public Boolean checkToComplete(){
+
+        if(this.startTime == null)
+            this.startTime = System.currentTimeMillis();
+
+        if(System.currentTimeMillis() - this.startTime < 10000L)
+            return false;
+
+        if(this.disqualify())
+            return true;
+
+        if(!this.player1.isAlive() && this.player2.isAlive()){
+            ArenaManager.endArena(this,this.player2,this.player1,"Player Has Died");
+            return true;
+        } else if(this.player1.isAlive() && !this.player2.isAlive()){
+            ArenaManager.endArena(this,this.player1,this.player2,"Player Has Died");
+            return true;
+        } else if(!this.player1.isAlive() && !this.player2.isAlive()){
+            ArenaManager.endArena(this,null,null,"Both Players Have Died");
+            return true;
+        } else if(this.startTime + 300000L < System.currentTimeMillis()){
+            ArenaManager.endArena(this,null,null,"Time Has Elapsed");
+            return true;
+        }
+        return false;
+    }
+}

src/engine/objects/Bane.java

@@ -14,19 +14,19 @@ import engine.Enum.ProtectionState;
 import engine.Enum.SiegePhase;
 import engine.Enum.SiegeResult;
 import engine.InterestManagement.HeightMap;
+import engine.InterestManagement.InterestManager;
 import engine.InterestManagement.WorldGrid;
 import engine.db.archive.BaneRecord;
 import engine.db.archive.DataWarehouse;
-import engine.gameManager.BuildingManager;
-import engine.gameManager.ChatManager;
-import engine.gameManager.DbManager;
-import engine.gameManager.ZoneManager;
+import engine.gameManager.*;
 import engine.job.JobScheduler;
 import engine.jobs.ActivateBaneJob;
 import engine.jobs.BaneDefaultTimeJob;
 import engine.math.Vector3fImmutable;
+import engine.net.Dispatch;
 import engine.net.DispatchMessage;
 import engine.net.client.ClientConnection;
+import engine.net.client.msg.CityDataMsg;
 import engine.net.client.msg.PlaceAssetMsg;
 import engine.net.client.msg.chat.ChatSystemMsg;
 import engine.server.MBServerStatics;
@@ -37,6 +37,7 @@ import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Date;
+import java.util.HashSet;
 import java.util.concurrent.ConcurrentHashMap;
 
 public final class Bane {
@@ -48,6 +49,10 @@ public final class Bane {
     private DateTime placementDate = null;
     private DateTime liveDate = null;
     private BaneDefaultTimeJob defaultTimeJob;
+    public boolean timeSet = false;
+    public boolean daySet = false;
+    public boolean capSet = false;
+    public int capSize = 10;
 
     // Internal cache for banes
     private ActivateBaneJob activateBaneJob;
@@ -64,6 +69,12 @@ public final class Bane {
         this.ownerUUID = rs.getInt("ownerUUID");
         this.stoneUUID = rs.getInt("stoneUUID");
 
+        this.timeSet = rs.getInt("time_set") == 1;
+        this.daySet = rs.getInt("day_set") == 1;
+        this.capSet = rs.getInt("cap_set") == 1;
+        this.capSize = rs.getInt("cap_size");
+
+
         sqlDateTime = rs.getTimestamp("placementDate");
 
         if (sqlDateTime != null)
@@ -100,12 +111,11 @@ public final class Bane {
                 abtj = new ActivateBaneJob(cityUUID);
                 JobScheduler.getInstance().scheduleJob(abtj, this.liveDate.getMillis());
                 this.activateBaneJob = abtj;
-
                 break;
         }
 
-        if (this.liveDate == null)
-            setDefaultTime();
+        //add bane commander NPC
+        //summonBaneCommander(this);
     }
 
     public static boolean summonBanestone(PlayerCharacter player, ClientConnection origin, int rank) {
@@ -266,9 +276,58 @@ public final class Bane {
         BaneRecord baneRecord = BaneRecord.borrow(bane, Enum.RecordEventType.PENDING);
         DataWarehouse.pushToWarehouse(baneRecord);
 
+        //add bane commander NPC
+        summonBaneCommander(bane);
+
+        try {
+            //update map for all players online
+            for (PlayerCharacter playerCharacter : SessionManager.getAllActivePlayerCharacters()) {
+                CityDataMsg cityDataMsg = new CityDataMsg(SessionManager.getSession(playerCharacter), false);
+                cityDataMsg.updateMines(true);
+                cityDataMsg.updateCities(true);
+                Dispatch dispatch = Dispatch.borrow(playerCharacter, cityDataMsg);
+                DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
+            }
+        }catch(Exception e){
+
+        }
+
         return true;
     }
 
+    public static void summonBaneCommander(Bane bane){
+        Vector3fImmutable spawnLoc = Vector3fImmutable.getRandomPointOnCircle(bane.getStone().loc,6);
+        NPC baneCommander;
+        int commanderuuid = DbManager.NPCQueries.BANE_COMMANDER_EXISTS(bane.getStone().getObjectUUID());
+
+        if(commanderuuid == 0) {
+            //add bane commander NPC
+            int contractID = 1502042;
+            baneCommander = NPC.createNPC("Bane Commander", contractID, spawnLoc, bane.getCity().getGuild(), ZoneManager.findSmallestZone(bane.getStone().loc), (short) 70, bane.getStone());
+            try {
+                NPCManager.slotCharacterInBuilding(baneCommander);
+            }catch(Exception e){
+
+            }
+            WorldGrid.addObject(baneCommander,spawnLoc.x,spawnLoc.z);
+            WorldGrid.updateObject(baneCommander);
+        }
+        else
+        {
+            baneCommander = NPC.getNPC(commanderuuid);
+        }
+        //try {
+        //    NPCManager.slotCharacterInBuilding(baneCommander);
+        //}catch (Exception e){
+            //swallow it
+        //}
+        baneCommander.runAfterLoad();
+        //baneCommander.setLoc(spawnLoc);
+        InterestManager.setObjectDirty(baneCommander);
+
+        baneCommander.updateLocation();
+    }
+
     public static Bane getBane(int cityUUID) {
 
         Bane outBane;
@@ -369,28 +428,24 @@ public final class Bane {
 
     // Cache access
 
-    private void setDefaultTime() {
+    public void setDefaultTime() {
 
         DateTime timeToSetDefault = new DateTime(this.placementDate);
         timeToSetDefault = timeToSetDefault.plusDays(1);
 
-        DateTime currentTime = DateTime.now();
-        DateTime defaultTime = new DateTime(this.placementDate);
-        defaultTime = defaultTime.plusDays(2);
-        defaultTime = defaultTime.hourOfDay().setCopy(22);
-        defaultTime = defaultTime.minuteOfHour().setCopy(0);
-        defaultTime = defaultTime.secondOfMinute().setCopy(0);
-
-        if (currentTime.isAfter(timeToSetDefault))
-            this.setLiveDate(defaultTime);
-        else {
-
-            if (this.defaultTimeJob != null)
-                this.defaultTimeJob.cancelJob();
-
-            BaneDefaultTimeJob bdtj = new BaneDefaultTimeJob(this);
-            JobScheduler.getInstance().scheduleJob(bdtj, timeToSetDefault.getMillis());
-            this.defaultTimeJob = bdtj;
+        if (DateTime.now().isAfter(timeToSetDefault)){
+            if(!this.capSet){
+                DbManager.BaneQueries.SET_BANE_CAP_NEW(20,this.getCityUUID());
+                this.capSet = true;
+            }
+            if(!this.daySet){
+                DbManager.BaneQueries.SET_BANE_DAY_NEW(3,this.getCityUUID());
+                this.daySet = true;
+            }
+            if(!this.timeSet){
+                DbManager.BaneQueries.SET_BANE_TIME_NEW(9,this.getCityUUID());
+                this.timeSet = true;
+            }
         }
     }
 
@@ -448,6 +503,16 @@ public final class Bane {
             return false;
         }
 
+        //Remove bane commander NPC
+        if(!baneStone.getHirelings().isEmpty()) {
+            NPC npc = (NPC)baneStone.getHirelings().keySet().stream().findFirst().orElse(null);
+            if(npc != null) {
+                DbManager.NPCQueries.DELETE_NPC(npc);
+                DbManager.removeFromCache(npc);
+                WorldGrid.RemoveWorldObject(npc);
+                WorldGrid.removeObject(npc);
+            }
+        }
         // Remove object from simulation
 
         baneStone.removeFromCache();
@@ -469,6 +534,9 @@ public final class Bane {
         return liveDate;
     }
 
+    public void setLiveDate_NEW(DateTime baneTime) {
+
+    }
     public void setLiveDate(DateTime baneTime) {
 
         if (DbManager.BaneQueries.SET_BANE_TIME(baneTime, this.getCity().getObjectUUID())) {
@@ -644,4 +712,63 @@ public final class Bane {
         return cityUUID;
     }
 
+    public void applyZergBuffs(){
+        City city = this.getCity();
+        if(city == null)
+            return;
+
+        city.onEnter();
+
+        ArrayList<Integer> attackers = new ArrayList<>();
+        ArrayList<Integer> defenders = new ArrayList<>();
+        Guild attackNation = this.getOwner().getGuild().getNation();
+        Guild defendNation = this.getCity().getGuild().getNation();
+        HashSet<AbstractWorldObject> inSiegeRange = WorldGrid.getObjectsInRangePartial(city.getTOL().loc,1750f,1);
+        for(AbstractWorldObject obj : inSiegeRange){
+            int uuid = obj.getObjectUUID();
+            PlayerCharacter player = PlayerCharacter.getPlayerCharacter(uuid);
+            if(player == null)
+                continue;
+            Guild playerNation = player.guild.getNation();
+            //separate the players into categories
+            if(playerNation.equals(defendNation))
+                defenders.add(uuid);
+            else if(playerNation.equals(attackNation))
+                attackers.add(uuid);
+            else
+                MovementManager.translocate(player,Vector3fImmutable.getRandomPointOnCircle(ZoneManager.getZoneByUUID(656).getLoc(),30f),Regions.GetRegionForTeleport(ZoneManager.getZoneByUUID(656).getLoc()));
+        }
+        int attackerSize = 0;
+        int defenderSize = 0;
+        for(int uuid : city.baneAttendees.keySet()){
+            PlayerCharacter player = PlayerCharacter.getPlayerCharacter(uuid);
+            if(player == null)
+                continue;
+            if(player.guild.getNation().equals(defendNation))
+                defenderSize += 1;
+            else if(player.guild.getNation().equals(attackNation))
+                attackerSize += 1;
+        }
+
+        //apply zerg mechanic for attackers
+        float attackerMultiplier = ZergManager.getCurrentMultiplier(attackerSize,this.capSize);
+        float defenderMultiplier = ZergManager.getCurrentMultiplier(defenderSize,this.capSize);
+        for(int uuid : attackers){
+            PlayerCharacter player = PlayerCharacter.getPlayerCharacter(uuid);
+            if(inSiegeRange.contains(player)) //player is still physically here, needs updated multiplier
+                player.ZergMultiplier = attackerMultiplier;
+            else
+                player.ZergMultiplier = 1.0f;
+        }
+
+        for(int uuid : defenders){
+            PlayerCharacter player = PlayerCharacter.getPlayerCharacter(uuid);
+            if(inSiegeRange.contains(player)) //player is still physically here, needs updated multiplier
+                player.ZergMultiplier = defenderMultiplier;
+            else
+                player.ZergMultiplier = 1.0f;
+        }
+
+    }
+
 }

src/engine/objects/Blueprint.java

@@ -360,6 +360,10 @@ this.maxRank = rs.getInt("MaxRank");
                 return 3;
         }
 
+        if(bg != null && bg.equals(BuildingGroup.TOL) && currentRank == 8){
+            return 5;
+        }
+
         if (this.maxRank == 1 && currentRank == 1)
             return getMaxSlots();
 

src/engine/objects/Building.java

@@ -160,23 +160,16 @@ public class Building extends AbstractWorldObject {
             // in City resulting in a stack ovreflow.
 
             if (blueprint != null) {
-
                 // Only switch mesh for player dropped structures
-
                 if (this.blueprintUUID != 0)
                     this.meshUUID = blueprint.getMeshForRank(rank);
-
                 this.healthMax = blueprint.getMaxHealth(this.rank);
-
                 // If this object has no blueprint but is a blueprint
                 // mesh then set it's current health to max health
-
                 if (this.blueprintUUID == 0)
                     this.setHealth(healthMax);
-
                 if (blueprint.getBuildingGroup().equals(BuildingGroup.BARRACK))
                     this.patrolPoints = DbManager.BuildingQueries.LOAD_PATROL_POINTS(this);
-
             } else {
                 this.healthMax = 100000;  // Structures with no blueprint mesh
                 this.setHealth(healthMax);
@@ -419,6 +412,22 @@ public class Building extends AbstractWorldObject {
         this.healthMax = this.getBlueprint().getMaxHealth(this.rank);
         this.setCurrentHitPoints(this.healthMax);
 
+        if(!this.ownerIsNPC && this.getBlueprint() != null && this.getBlueprint().isWallPiece()){
+            //add extra HP for city walls of R8 trees
+            City city = ZoneManager.getCityAtLocation(this.loc);
+            if(city != null){
+                Building ToL = city.getTOL();
+                if(ToL != null){
+                    if(ToL.rank == 8){
+                        float currentHealth = this.health.get();
+                        float newHealth = (currentHealth/this.healthMax) * (this.healthMax * 1.1f);
+                        this.healthMax *= 1.1f;
+                        this.setHealth(newHealth);
+                    }
+                }
+            }
+        }
+
         if (this.getUpgradeDateTime() != null)
             BuildingManager.setUpgradeDateTime(this, null, 0);
 
@@ -1128,6 +1137,22 @@ public class Building extends AbstractWorldObject {
                 }
             }
 
+            if(!this.ownerIsNPC && this.getBlueprint() != null && this.getBlueprint().isWallPiece()){
+                //add extra HP for city walls of R8 trees
+                City city = ZoneManager.getCityAtLocation(this.loc);
+                if(city != null){
+                    Building ToL = city.getTOL();
+                    if(ToL != null){
+                        if(ToL.rank == 8){
+                            float currentHealth = this.health.get();
+                            float newHealth = (currentHealth/this.healthMax) * (this.healthMax * 1.1f);
+                            this.healthMax *= 1.1f;
+                            this.setHealth(newHealth);
+                        }
+                    }
+                }
+            }
+
             // Set bounds for this building
 
             Bounds buildingBounds = Bounds.borrow();

src/engine/objects/CharacterItemManager.java

@@ -1056,6 +1056,7 @@ public class CharacterItemManager {
         // add to Bank
         this.bank.add(i);
         i.addToCache();
+        i.stripCastableEnchants();
 
         calculateWeights();
 
@@ -1204,6 +1205,7 @@ public class CharacterItemManager {
 
         calculateWeights();
 
+        i.stripCastableEnchants();
         return true;
     }
 

src/engine/objects/CharacterSkill.java

@@ -68,7 +68,7 @@ public class CharacterSkill extends AbstractGameObject {
             165, 166, 166, 167, 167, //185 to 189
             168}; //190
 
-    private static final float[] baseSkillValues = {
+    static final float[] baseSkillValues = {
             0.0f, 0.0f, 0.2f, 0.4f, 0.6f,  //0 to 4
             0.8f, 1.0f, 1.1666666f, 1.3333334f, 1.5f,  //5 to 9
             1.6666667f, 1.8333334f, 2.0f, 2.2f, 2.4f,  //10 to 14

src/engine/objects/City.java

@@ -39,6 +39,7 @@ import java.sql.SQLException;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.concurrent.ConcurrentHashMap;
@@ -88,6 +89,8 @@ public class City extends AbstractWorldObject {
     private boolean reverseKOS = false;
     private String hash;
 
+    public HashMap<Integer, Long> baneAttendees = new HashMap<>();
+
     /**
      * ResultSet Constructor
      */
@@ -234,7 +237,24 @@ public class City extends AbstractWorldObject {
         writer.putInt(rulingGuild.getObjectUUID());
 
         writer.putString(rulingGuild.getName());
-        writer.putString(city.motto);
+        try {
+            if (city.getBane() != null) {
+                Bane bane = city.getBane();
+                if (bane.daySet && bane.timeSet && bane.getLiveDate() != null) {
+                    int day = bane.getLiveDate().dayOfMonth().get();
+                    int month = bane.getLiveDate().getMonthOfYear();
+                    int year = bane.getLiveDate().year().get();
+                    int hour = bane.getLiveDate().getHourOfDay();
+                    writer.putString("BANE SET: " + month + "/" + day + "/" + year + "   " + hour + ":00 CST");
+                } else {
+                    writer.putString("BANED!: Unset");
+                }
+            } else {
+                writer.putString(city.motto);
+            }
+        }catch(Exception e){
+            writer.putString(city.motto);
+        }
         writer.putString(rulingGuild.getLeadershipType());
 
         // Serialize guild ruler's name
@@ -320,8 +340,11 @@ public class City extends AbstractWorldObject {
         writer.putFloat(city.location.y);
         writer.putFloat(city.location.z);
 
-        writer.putInt(city.siegesWithstood);
-
+        if(city.getBane() != null) {
+            writer.putInt(city.getBane().capSize);
+        }else{
+            writer.putInt(0);
+        }
         writer.put((byte) 1);
         writer.put((byte) 0);
         writer.putInt(0x64);
@@ -989,7 +1012,7 @@ public class City extends AbstractWorldObject {
 
         // Gather current list of players within the zone bounds
 
-        currentPlayers = WorldGrid.getObjectsInRangePartial(this.location, CityBoundsType.ZONE.extents, MBServerStatics.MASK_PLAYER);
+        currentPlayers = WorldGrid.getObjectsInRangePartial(this.location, 1500, MBServerStatics.MASK_PLAYER);
         currentMemory = new HashSet<>();
 
         for (AbstractWorldObject playerObject : currentPlayers) {
@@ -1001,7 +1024,15 @@ public class City extends AbstractWorldObject {
             currentMemory.add(player.getObjectUUID());
 
             // Player is already in our memory
-
+            if(this.getBane() != null){
+                //handle zerg mechanics here
+                if(this.getBane().getSiegePhase().equals(SiegePhase.WAR)){
+                    //bane is live, start tallying players
+                    if(!this.baneAttendees.containsKey(player.getObjectUUID())){
+                        this.baneAttendees.put(player.getObjectUUID(),System.currentTimeMillis());
+                    }
+                }
+            }
             if (_playerMemory.contains(player.getObjectUUID()))
                 continue;
 
@@ -1028,14 +1059,29 @@ public class City extends AbstractWorldObject {
         } catch (Exception e) {
             Logger.error(e.getMessage());
         }
-
     }
 
+    private void onExitBane() {
+        ArrayList<Integer> toRemove = new ArrayList<>();
+        for (Integer uuid : this.baneAttendees.keySet()) {
+            if (!_playerMemory.contains(uuid)) {
+                long timeGone = System.currentTimeMillis() - this.baneAttendees.get(uuid).longValue();
+                if (timeGone > 180000L) { // 3 minutes
+                    toRemove.add(uuid); // Mark for removal
+                }
+            }
+        }
+        for(int uuid : toRemove){
+            this.baneAttendees.remove(uuid);
+        }
+    }
+
+
     private void onExit(HashSet<Integer> currentMemory) {
 
         PlayerCharacter player;
         int playerUUID = 0;
-        HashSet<Integer> toRemove = new HashSet<>();
+        HashSet<Integer> toRemoveStandard = new HashSet<>();
         Iterator<Integer> iter = _playerMemory.iterator();
 
         while (iter.hasNext()) {
@@ -1057,21 +1103,28 @@ public class City extends AbstractWorldObject {
 
             this.removeAllCityEffects(player, false);
 
+            player.ZergMultiplier = 1.0f;
             // We will remove this player after iteration is complete
             // so store it in a temporary collection
 
-            toRemove.add(playerUUID);
+            toRemoveStandard.add(playerUUID);
             // ***For debugging
             // Logger.info("PlayerMemory for ", this.getCityName() + ": " + _playerMemory.size());
         }
 
         // Remove players from city memory
 
-        _playerMemory.removeAll(toRemove);
-        for (Integer removalUUID : toRemove) {
+        _playerMemory.removeAll(toRemoveStandard);
+        for (Integer removalUUID : toRemoveStandard) {
             if (this.cityOutlaws.contains(removalUUID))
                 this.cityOutlaws.remove(removalUUID);
         }
+        if(this.getBane() != null){
+            //handle zerg mechanics here
+            if(this.getBane().getSiegePhase().equals(SiegePhase.WAR)){
+                this.onExitBane();
+            }
+        }
     }
 
     public int getWarehouseBuildingID() {

src/engine/objects/Contract.java

@@ -11,7 +11,12 @@ package engine.objects;
 
 import ch.claude_martin.enumbitset.EnumBitSet;
 import engine.Enum;
-import engine.gameManager.DbManager;
+import engine.gameManager.*;
+import engine.net.Dispatch;
+import engine.net.DispatchMessage;
+import engine.net.client.msg.CityDataMsg;
+import engine.net.client.msg.ErrorPopupMsg;
+import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
 
 import java.sql.ResultSet;
@@ -190,6 +195,288 @@ public class Contract extends AbstractGameObject {
         return this.vendorDialog;
     }
 
+    public static VendorDialog HandleArenaMaster(int optionId, NPC npc, PlayerCharacter pc){
+        //1502043
+        pc.setLastNPCDialog(npc);
+        VendorDialog vd = new VendorDialog(VendorDialog.getHostileVendorDialog().getDialogType(),VendorDialog.getHostileVendorDialog().getIntro(),-1);//VendorDialog.getHostileVendorDialog();
+        vd.getOptions().clear();
+
+        switch(optionId){
+            case 15020431:
+                //if(pc.isBoxed){
+                //    ChatManager.chatSystemInfo(pc, "You Cannot Join The Que, You Are Boxed");
+                //}else {
+                    if (ArenaManager.playerQueue.contains(pc)) {
+                        ChatManager.chatSystemInfo(pc, "You Are Already In The Arena Que");
+                    } else {
+                        ArenaManager.joinQueue(pc);
+                        ChatManager.chatSystemInfo(pc, "You Have Joined The Arena Que");
+                    }
+                //}
+                break;
+            case 15020432:
+                if(ArenaManager.playerQueue.contains(pc)) {
+                    ArenaManager.leaveQueue(pc);
+                    ChatManager.chatSystemInfo(pc, "You Have Left The Arena Que");
+                }else{
+                    ChatManager.chatSystemInfo(pc, "You Are Not In The Arena Que");
+                }
+                break;
+        }
+        MenuOption option1 = new MenuOption(15020431, "Join Arena Que", 15020431);
+        vd.getOptions().add(option1);
+        MenuOption option2 = new MenuOption(15020432, "Leave Arena Que", 15020432);
+        vd.getOptions().add(option2);
+        return vd;
+    }
+    public static VendorDialog HandleEnrollmentOfficer(int optionId, NPC npc, PlayerCharacter pc){
+        pc.setLastNPCDialog(npc);
+        //VendorDialog vd = new VendorDialog(npc.contract.getVendorDialog().getDialogType(),npc.contract.getVendorDialog().getIntro(),-1);//VendorDialog.getHostileVendorDialog();
+        VendorDialog vd = new VendorDialog(npc.contract.getVendorDialog().getDialogType(),npc.contract.getVendorDialog().getIntro(),-1);//VendorDialog.getHostileVendorDialog();
+        vd.getOptions().clear();
+        switch(optionId) {
+            default:
+            if (pc.isBoxed) {
+                MenuOption option1 = new MenuOption(15020401, "Unbox Character", 15020401);
+                vd.getOptions().add(option1);
+            }
+            break;
+            case 15020401:
+                PlayerCharacter.unboxPlayer(pc);
+                vd.getOptions().clear();
+                break;
+        }
+        return vd;
+    }
+    public static VendorDialog HandleBaneCommanderOptions(int optionId, NPC npc, PlayerCharacter pc){
+        pc.setLastNPCDialog(npc);
+        VendorDialog vd = new VendorDialog(VendorDialog.getHostileVendorDialog().getDialogType(),VendorDialog.getHostileVendorDialog().getIntro(),-1);//VendorDialog.getHostileVendorDialog();
+        vd.getOptions().clear();
+        Building building = npc.building;
+        Bane bane = null;
+        int updateBaneTime = 0;
+        int updateBaneDay = 0;
+        int updateBaneCap = 0;
+
+        int treesInNation = 0;
+        if(building != null)
+        {
+            City city = ZoneManager.getCityAtLocation(building.loc);
+            if(city != null){
+                bane = city.getBane();
+                if(!city.getGuild().equals(pc.guild))
+                    return vd;
+
+                if(!GuildStatusController.isInnerCouncil(pc.getGuildStatus()) && !GuildStatusController.isGuildLeader(pc.getGuildStatus())){
+                    return vd;
+                }
+                for(Guild sub : city.getGuild().getNation().getSubGuildList()){
+                    if(sub.getOwnedCity() != null){
+                        treesInNation += 1;
+                    }
+                }
+            }
+        }
+        if(bane == null){
+            return VendorDialog.getHostileVendorDialog();
+        }
+        if(bane.timeSet && bane.capSet && bane.daySet){
+            vd.getOptions().clear();
+            return vd;
+        }
+
+        DateTime placement = bane.getPlacementDate();
+        vd.getOptions().clear();
+        switch(optionId){
+            default:
+                if(!bane.daySet) {
+                    MenuOption option1 = new MenuOption(796, "Set Bane Day", 796);
+                    vd.getOptions().add(option1);
+                }
+                if(!bane.timeSet) {
+                    MenuOption option2 = new MenuOption(797, "Set Bane Time", 797);
+                    vd.getOptions().add(option2);
+                }
+                if(!bane.capSet) {
+                    MenuOption option3 = new MenuOption(797, "Set Bane Cap", 798);
+                    vd.getOptions().add(option3);
+                }
+                break;
+            case 796: // set bane day
+                DateTime dayOption1Date = placement.plusDays(3);
+                MenuOption dayOption1 = new MenuOption(7961, dayOption1Date.toString("yyyy-MM-dd"), 7961);
+                vd.getOptions().add(dayOption1);
+
+                DateTime dayOption2Date = placement.plusDays(4);
+                MenuOption dayOption2 = new MenuOption(7962, dayOption2Date.toString("yyyy-MM-dd"), 7962);
+                vd.getOptions().add(dayOption2);
+
+                DateTime dayOption3Date = placement.plusDays(5);
+                MenuOption dayOption3 = new MenuOption(7963, dayOption3Date.toString("yyyy-MM-dd"), 7963);
+                vd.getOptions().add(dayOption3);
+
+                DateTime dayOption4Date = placement.plusDays(6);
+                MenuOption dayOption4 = new MenuOption(7964, dayOption4Date.toString("yyyy-MM-dd"), 7964);
+                vd.getOptions().add(dayOption4);
+
+                DateTime dayOption5Date = placement.plusDays(7);
+                MenuOption dayOption5 = new MenuOption(7965, dayOption5Date.toString("yyyy-MM-dd"), 7965);
+                vd.getOptions().add(dayOption5);
+                break;
+            case 797: // set bane time
+                MenuOption timeOption1 = new MenuOption(7971, "6:00 pm CST", 7971);
+                vd.getOptions().add(timeOption1);
+
+                MenuOption timeOption2 = new MenuOption(7972, "7:00 pm CST", 7972);
+                vd.getOptions().add(timeOption2);
+
+                MenuOption timeOption3 = new MenuOption(7973, "8:00 pm CST", 7973);
+                vd.getOptions().add(timeOption3);
+
+                MenuOption timeOption4 = new MenuOption(7974, "9:00 pm CST", 7974);
+                vd.getOptions().add(timeOption4);
+
+                MenuOption timeOption5 = new MenuOption(7975, "10:00 pm CST", 7975);
+                vd.getOptions().add(timeOption5);
+                break;
+            case 798: // set bane cap
+                if(treesInNation < 6) {
+                    MenuOption capOption1 = new MenuOption(7981, "10 Maximum Players", 7981);
+                    vd.getOptions().add(capOption1);
+                }
+
+                if(treesInNation < 11) {
+                    MenuOption capOption2 = new MenuOption(7982, "20 Maximum Players", 7982);
+                    vd.getOptions().add(capOption2);
+                }
+
+                MenuOption capOption3 = new MenuOption(7983, "30 Maximum Players", 7983);
+                vd.getOptions().add(capOption3);
+
+                MenuOption capOption4 = new MenuOption(7984, "40 Maximum Players", 7984);
+                vd.getOptions().add(capOption4);
+
+                MenuOption capOption5 = new MenuOption(7985, "Unlimited Players", 7985);
+                vd.getOptions().add(capOption5);
+
+                break;
+
+            case 7961: //3 days after placement
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Set 3 Days From Placement Date");
+                updateBaneDay = 3;
+                break;
+            case 7962: //4 days after placement
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Set 4 Days From Placement Date");
+                updateBaneDay = 4;
+                break;
+            case 7963: //5 days after placement
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Set 5 Days From Placement Date");
+                updateBaneDay = 5;
+                break;
+            case 7964: //6 days after placement
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Set 6 Days From Placement Date");
+                updateBaneDay = 6;
+                break;
+            case 7965: //7 days after placement
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Set 7 Days From Placement Date");
+                updateBaneDay = 7;
+                break;
+            case 7971: //6:00pm CST
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Set For 6:00 pm CST");
+                updateBaneTime = 6;
+                break;
+            case 7972: //7:00pm CST
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Set For 7:00 pm CST");
+                updateBaneTime = 7;
+                break;
+            case 7973: //8:00pm CST
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Set For 8:00 pm CST");
+                updateBaneTime = 8;
+                break;
+            case 7974: //9:00pm CST
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Set For 9:00 pm CST");
+                updateBaneTime = 9;
+                break;
+            case 7975: //10:00pm CST
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Set For 10:00 pm CST");
+                updateBaneTime = 10;
+                break;
+            case 7981: //cap = 10
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Cap Set To 10 Players On Each Side");
+                updateBaneCap = 10;
+                break;
+            case 7982: //cap = 20
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Cap Set To 20 Players On Each Side");
+                updateBaneCap = 20;
+                break;
+            case 7983: //cap = 30
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Cap Set To 30 Players On Each Side");
+                updateBaneCap = 30;
+                break;
+            case 7984: //cap = 40
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Cap Set To 40 Players On Each Side");
+                updateBaneCap = 40;
+                break;
+            case 7985: //cap = Unlimited
+                ErrorPopupMsg.sendErrorMsg(pc, "Bane Cap Set To Unlimited Players On Each Side");
+                updateBaneCap = 9999;
+                break;
+        }
+        if (updateBaneDay > 0) {
+            if(DbManager.BaneQueries.SET_BANE_DAY_NEW(updateBaneDay,bane.getCityUUID())){
+                bane.daySet = true;
+                if(bane.getLiveDate() == null) {
+                    bane.setLiveDate_NEW(bane.getPlacementDate().plusDays(updateBaneDay));
+                }else{
+                    bane.setLiveDate_NEW(bane.getLiveDate().plusDays(updateBaneDay));
+                }
+            }
+        }
+        if (updateBaneTime > 0) {
+            if(DbManager.BaneQueries.SET_BANE_TIME_NEW(updateBaneTime,bane.getCityUUID())){
+                bane.timeSet = true;
+                if(bane.getLiveDate() == null) {
+                    bane.setLiveDate_NEW(bane.getPlacementDate().withHourOfDay(12 + updateBaneTime));
+                }else{
+                    bane.setLiveDate_NEW(bane.getLiveDate().withHourOfDay(12 + updateBaneTime));
+                }
+            }
+            bane.setLiveDate(DbManager.BaneQueries.getLiveDate(bane.getCityUUID()));
+        }
+        if (updateBaneCap > 0) {
+            if(DbManager.BaneQueries.SET_BANE_CAP_NEW(updateBaneCap,bane.getCityUUID())){
+                bane.capSet = true;
+                bane.capSize = updateBaneCap;
+            }
+        }
+
+        if(updateBaneCap > 0 ||  updateBaneTime > 0 || updateBaneDay > 0) {
+            bane.getSiegePhase();
+            for (PlayerCharacter playerCharacter : SessionManager.getAllActivePlayerCharacters()) {
+                CityDataMsg cityDataMsg = new CityDataMsg(SessionManager.getSession(playerCharacter), false);
+                cityDataMsg.updateMines(true);
+                cityDataMsg.updateCities(true);
+                Dispatch dispatch = Dispatch.borrow(playerCharacter, cityDataMsg);
+                DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
+            }
+            vd.getOptions().clear();
+            if(!bane.daySet) {
+                MenuOption option1 = new MenuOption(796, "Set Bane Day", 796);
+                vd.getOptions().add(option1);
+            }
+            if(!bane.timeSet) {
+                MenuOption option2 = new MenuOption(797, "Set Bane Time", 797);
+                vd.getOptions().add(option2);
+            }
+            if(!bane.capSet) {
+                MenuOption option3 = new MenuOption(797, "Set Bane Cap", 798);
+                vd.getOptions().add(option3);
+            }
+        }
+
+        return vd;
+    }
+
     public ArrayList<Integer> getNPCMenuOptions() {
         return this.npcMenuOptions;
     }

src/engine/objects/Corpse.java

@@ -43,6 +43,7 @@ public class Corpse extends AbstractWorldObject {
     private int inBuildingID = 0;
     private int inFloorID = -1;
     private int inBuilding = -1;
+    public Long spawnedTime = 0L;
 
     /**
      * No Id Constructor
@@ -74,6 +75,7 @@ public class Corpse extends AbstractWorldObject {
         }
         this.setObjectTypeMask(MBServerStatics.MASK_CORPSE);
 
+        this.spawnedTime = System.currentTimeMillis();
         if (!safeZone)
             transferInventory(belongsTo, enterWorld);
 

src/engine/objects/Experience.java

@@ -346,6 +346,12 @@ public class Experience {
         if (killer == null || mob == null)
             return;
 
+        if(killer.equals(mob))
+            return;
+
+        if(killer.pvpKills.contains(mob.getObjectUUID()))
+            return;
+
         double grantedExperience = 0.0;
 
         if (g != null) { // Do group EXP stuff
@@ -403,6 +409,7 @@ public class Experience {
 
                 grantedExperience = (double) LOOTMANAGER.NORMAL_EXP_RATE * maxXPPerKill(playerCharacter.getLevel());
 
+                grantedExperience *= (1/ giveEXPTo.size()+0.9);
                 // Adjust XP for Mob Level
 
                 grantedExperience *= getConMod(playerCharacter, mob);

src/engine/objects/Item.java

@@ -1085,6 +1085,7 @@ public class Item extends AbstractWorldObject {
         this.ownerID = pc.getObjectUUID();
         this.ownerType = OwnerType.PlayerCharacter;
         this.containerType = ItemContainerType.INVENTORY;
+        this.stripCastableEnchants();
         return true;
     }
 
@@ -1105,6 +1106,7 @@ public class Item extends AbstractWorldObject {
         this.ownerID = npc.getObjectUUID();
         this.ownerType = OwnerType.Npc;
         this.containerType = Enum.ItemContainerType.INVENTORY;
+        this.stripCastableEnchants();
         return true;
     }
 
@@ -1225,7 +1227,10 @@ public class Item extends AbstractWorldObject {
     }
 
     public final int getMagicValue() {
-        return this.magicValue;
+        int val = this.calcMagicValue();
+        if(val == 0)
+            val = 1;
+        return val + this.getItemBase().getMagicValue();
     }
 
     public int getBaseValue() {
@@ -1487,4 +1492,21 @@ public class Item extends AbstractWorldObject {
             return false;
         return true;
     }
+
+    public float getModifiedSpeed() {
+        float speed = this.getItemBase().getSpeed();
+        try {
+            for (Effect eff : this.effects.values()) {
+                for (AbstractEffectModifier mod : eff.getEffectModifiers()) {
+                    if (mod.modType.equals(ModType.WeaponSpeed)) {
+                        float modValue = 1 + mod.getPercentMod() * 0.01f;
+                        speed *= modValue;
+                    }
+                }
+            }
+        }catch(Exception e){
+
+        }
+        return speed;
+    }
 }

src/engine/objects/ItemBase.java

@@ -76,6 +76,8 @@ public class ItemBase {
     private ArrayList<Integer> animations = new ArrayList<>();
     private ArrayList<Integer> offHandAnimations = new ArrayList<>();
 
+    public float dexReduction = 0.0f;
+
     /**
      * ResultSet Constructor
      */
@@ -151,7 +153,7 @@ public class ItemBase {
         }
         initBakedInStats();
         initializeHashes();
-
+        initDexReduction();
     }
 
     public static void addToCache(ItemBase itemBase) {
@@ -319,6 +321,10 @@ public class ItemBase {
         DbManager.ItemBaseQueries.LOAD_BAKEDINSTATS(this);
     }
 
+    private void initDexReduction(){
+        DbManager.ItemBaseQueries.LOAD_DEX_REDUCTION(this);
+    }
+
     //TODO fix this later. Shouldn't be gotten from item base
     public int getMagicValue() {
         return this.value;

src/engine/objects/ItemFactory.java

@@ -215,7 +215,7 @@ public class ItemFactory {
                 pi.setAmount(itemsToRoll);
                 pi.setRandom(false);
 
-                ItemQueue produced = ItemQueue.borrow(pi, (long) (time * Float.parseFloat(ConfigManager.MB_PRODUCTION_RATE.getValue())));
+                ItemQueue produced = ItemQueue.borrow(pi, (long) time);
                 ItemProductionManager.send(produced);
 
                 return ml;
@@ -410,7 +410,7 @@ public class ItemFactory {
 
             if (overdraft > 0 && !useWarehouse) {
                 if (pc != null)
-                    ErrorPopupMsg.sendErrorMsg(pc, "Not enough gold in building strongbox." + ib.getName());
+                    ErrorPopupMsg.sendErrorMsg(pc, "Not enough gold in building strongbox. " + ib.getName());
                 return null;
             }
 
@@ -936,7 +936,7 @@ public class ItemFactory {
 
             //calculate gold costs and remove from the warehouse
             if (prefix != null || suffix != null) {
-                int costToCreate = (int) (ib.getBaseValue() + ib.getBaseValue() * .10f);
+                int costToCreate = ib.getBaseValue();
                 int buildingWithdraw = BuildingManager.GetWithdrawAmountForRolling(forge, costToCreate);
                 int overdraft = BuildingManager.GetOverdraft(forge, costToCreate);
 

src/engine/objects/MenuOption.java

@@ -31,6 +31,13 @@ public class MenuOption extends AbstractGameObject {
         this.prereq = rs.getInt("prereq");
     }
 
+    public MenuOption(int id, String msg, int option){
+        this.menuID = id;
+        this.message = msg;
+        this.optionID = option;
+        this.prereq = 0;
+    }
+
     /*
      * Getters
      */

src/engine/objects/Mine.java

@@ -72,14 +72,30 @@ public class Mine extends AbstractGameObject {
     public Mine(ResultSet rs) throws SQLException, UnknownHostException {
         super(rs);
 
+        if (rs.getInt("capSize") == 0) {
+            throw new IllegalArgumentException("Mine creation canceled: capSize cannot be 0");
+        }
+
         this.mineType = MineProduction.getByName(rs.getString("mine_type"));
 
         int ownerUID = rs.getInt("mine_ownerUID");
         this.buildingID = rs.getInt("mine_buildingUID");
         this.flags = rs.getInt("flags");
         int parent = rs.getInt("parent");
-        this.parentZone = ZoneManager.getZoneByUUID(parent);
-        this.zoneName = this.parentZone.getParent().getName();
+        if(ZoneManager.getZoneByUUID(parent) != null) {
+            this.parentZone = ZoneManager.getZoneByUUID(parent);
+            this.zoneName = this.parentZone.getParent().getName();
+        }else{
+            this.parentZone = ZoneManager.getSeaFloor();
+            if(this.parentZone.getParent() != null)
+                this.zoneName = this.parentZone.getParent().getName();
+            else
+                this.zoneName = "FAILED TO LOAD ZONE";
+            Logger.error("MINE FAILED TO LOAD PARENT: ");
+            Logger.error("MINE UID: " + rs.getInt("UID"));
+            Logger.error("MINE buildingID: " + buildingID);
+
+        }
 
         this.owningGuild = Guild.getGuild(ownerUID);
         Guild nation = null;
@@ -319,6 +335,17 @@ public class Mine extends AbstractGameObject {
         return true;
     }
 
+    public static ArrayList<Mine> getMinesToTeleportTo(PlayerCharacter player) {
+        ArrayList<Mine> mines = new ArrayList<>();
+        for(Mine mine : Mine.getMines())
+            if(!mine.isActive)
+                if(mine.getOwningGuild() != null)
+                  if(mine.getOwningGuild().getNation().equals(player.getGuild().getNation()))
+                         mines.add(mine);
+
+        return mines;
+    }
+
     public boolean changeProductionType(Resource resource) {
         if (!this.validForMine(resource))
             return false;
@@ -418,7 +445,7 @@ public class Mine extends AbstractGameObject {
         writer.putInt(this.getModifiedProductionAmount());
         writer.putInt(this.getModifiedProductionAmount()); //TODO calculate range penalty here
         writer.putInt(3600); //window in seconds
-        writer.putInt(this.isExpansion() ? this.mineType.xpacHash : this.mineType.hash);
+        writer.putInt(this.mineType.hash);
     }
 
     @Override
@@ -661,4 +688,134 @@ public class Mine extends AbstractGameObject {
 
         _playerMemory.removeAll(toRemove);
     }
+    public static Building getTower(Mine mine){
+        Building tower = BuildingManager.getBuildingFromCache(mine.buildingID);
+        if(tower != null)
+            return tower;
+        else
+            return null;
+    }
+    public static void serializeForClientMsgTeleport(Mine mine, ByteBufferWriter writer) {
+        AbstractCharacter guildRuler;
+        Guild rulingGuild;
+        Guild rulingNation;
+        java.time.LocalDateTime dateTime1900;
+
+        // Cities aren't a mine without a TOL. Time to early exit.
+        // No need to spam the log here as non-existant TOL's are indicated
+        // during bootstrap routines.
+        Building tower = Mine.getTower(mine);
+        if (tower == null) {
+
+            Logger.error("NULL TOWER FOR " + mine.zoneName + " mine");
+            return;
+        }
+
+
+        // Assign mine owner
+
+        if (tower.getOwner() != null)
+            guildRuler = tower.getOwner();
+        else
+            guildRuler = null;
+
+        // If is an errant tree, use errant guild for serialization.
+        // otherwise we serialize the soverign guild
+
+        if (guildRuler == null)
+            rulingGuild = Guild.getErrantGuild();
+        else
+            rulingGuild = guildRuler.getGuild();
+
+        rulingNation = rulingGuild.getNation();
+
+        // Begin Serialzing soverign guild data
+        writer.putInt(mine.getObjectType().ordinal());
+        writer.putInt(mine.getObjectUUID());
+        writer.putString(mine.zoneName + " Mine");
+        writer.putInt(rulingGuild.getObjectType().ordinal());
+        writer.putInt(rulingGuild.getObjectUUID());
+
+        writer.putString(rulingGuild.getName());
+        writer.putString("");
+        writer.putString(rulingGuild.getLeadershipType());
+
+        // Serialize guild ruler's name
+        // If tree is abandoned blank out the name
+        // to allow them a rename.
+
+        if (guildRuler == null)
+            writer.putString("");
+        else
+            writer.putString(guildRuler.getFirstName() + ' ' + guildRuler.getLastName());
+
+        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
+
+        if (rulingNation.isEmptyGuild())
+            writer.putString("None");
+        else
+            writer.putString(rulingNation.getName());
+
+        writer.putInt(1);
+
+        writer.putInt(0xFFFFFFFF);
+
+        writer.putInt(0);
+
+        if (rulingNation.isEmptyGuild())
+            writer.putString(" ");
+        else
+            writer.putString(Guild.GetGL(rulingNation).getFirstName() + ' ' + Guild.GetGL(rulingNation).getLastName());
+
+        writer.putLocalDateTime(LocalDateTime.now());
+
+        if(tower != null) {
+            writer.putFloat(tower.loc.x);
+            writer.putFloat(tower.loc.y);
+            writer.putFloat(tower.loc.z);
+        } else{
+            writer.putFloat(0);
+            writer.putFloat(0);
+            writer.putFloat(0);
+        }
+        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/objects/Mob.java

@@ -12,6 +12,7 @@ package engine.objects;
 import ch.claude_martin.enumbitset.EnumBitSet;
 import engine.Enum;
 import engine.Enum.*;
+import engine.InterestManagement.InterestManager;
 import engine.InterestManagement.WorldGrid;
 import engine.exception.SerializationException;
 import engine.gameManager.*;
@@ -1326,8 +1327,6 @@ public class Mob extends AbstractIntelligenceAgent {
         Dispatch dispatch;
 
         try {
-            //resync corpses
-            //this.setLoc(this.getMovementLoc());
             if (this.isSiege) {
                 this.deathTime = System.currentTimeMillis();
                 //this.state = STATE.Dead;
@@ -1407,6 +1406,8 @@ public class Mob extends AbstractIntelligenceAgent {
             Logger.error(e);
         }
         this.updateLocation();
+        //resync corpses
+        InterestManager.setObjectDirty(this);
     }
 
     public void respawn() {
@@ -1441,6 +1442,9 @@ public class Mob extends AbstractIntelligenceAgent {
             loadInventory();
 
         this.updateLocation();
+        this.stopPatrolTime = 0;
+        this.lastPatrolPointIndex = 0;
+        InterestManager.setObjectDirty(this);
     }
 
     public void despawn() {
@@ -1635,65 +1639,75 @@ public class Mob extends AbstractIntelligenceAgent {
             this.defenseRating = defense;
             this.atrHandOne = atr;
             return;
+        }else {
+            if (this.charItemManager == null || this.equip == null) {
+                Logger.error("Player " + currentID + " missing skills or equipment");
+                defaultAtrAndDamage(true);
+                defaultAtrAndDamage(false);
+                this.defenseRating = 0;
+                return;
+            }
+
+            try {
+                calculateAtrDamageForWeapon(this.equip.get(MBServerStatics.SLOT_MAINHAND), true);
+            } catch (Exception e) {
+
+                this.atrHandOne = GetAttackRating(this.mobBase.getAttackRating(), this);
+                this.minDamageHandOne = (short) this.mobBase.getDamageMin();
+                this.maxDamageHandOne = (short) this.mobBase.getDamageMax();
+                this.rangeHandOne = 6.5f;
+                this.speedHandOne = 20;
+                Logger.info("Mobbase ID " + this.getMobBaseID() + " returned an error. setting to default ATR and Damage." + e.getMessage());
+            }
+
+            try {
+                calculateAtrDamageForWeapon(this.equip.get(MBServerStatics.SLOT_OFFHAND), false);
+
+            } catch (Exception e) {
+
+                this.atrHandTwo = GetAttackRating(this.mobBase.getAttackRating(), this);
+                this.minDamageHandTwo = (short) this.mobBase.getDamageMin();
+                this.maxDamageHandTwo = (short) this.mobBase.getDamageMax();
+                this.rangeHandTwo = 6.5f;
+                this.speedHandTwo = 20;
+                Logger.info("Mobbase ID " + this.getMobBaseID() + " returned an error. setting to default ATR and Damage." + e.getMessage());
+            }
+
+            try {
+                float defense = this.mobBase.getDefenseRating();
+                defense += getShieldDefense(equip.get(MBServerStatics.SLOT_OFFHAND));
+                defense += getArmorDefense(equip.get(MBServerStatics.SLOT_HELMET));
+                defense += getArmorDefense(equip.get(MBServerStatics.SLOT_CHEST));
+                defense += getArmorDefense(equip.get(MBServerStatics.SLOT_ARMS));
+                defense += getArmorDefense(equip.get(MBServerStatics.SLOT_GLOVES));
+                defense += getArmorDefense(equip.get(MBServerStatics.SLOT_LEGGINGS));
+                defense += getArmorDefense(equip.get(MBServerStatics.SLOT_FEET));
+                defense += getWeaponDefense(equip);
+
+                // TODO add error log here
+                if (this.bonuses != null) {
+                    defense = GetDefense((int) defense, this);
+
+                } else
+                    Logger.error("Error: missing bonuses");
+
+                defense = (defense < 1) ? 1 : defense;
+                this.defenseRating = (short) (defense + 0.5f);
+            } catch (Exception e) {
+                Logger.info("Mobbase ID " + this.getMobBaseID() + " returned an error. Setting to Default Defense." + e.getMessage());
+                this.defenseRating = (short) this.mobBase.getDefense();
+            }
+            // calculate defense for equipment
         }
-        if (this.charItemManager == null || this.equip == null) {
-            Logger.error("Player " + currentID + " missing skills or equipment");
-            defaultAtrAndDamage(true);
-            defaultAtrAndDamage(false);
-            this.defenseRating = 0;
-            return;
+        if((this.isDropper || Mob.discDroppers.contains(this)) && !this.mobBase.getFirstName().contains("Blood Mage")){
+            this.defenseRating *= 2;
+            this.atrHandOne *= 2;
+            this.atrHandTwo *= 2;
+            this.minDamageHandOne *= 2;
+            this.minDamageHandTwo *= 2;
+            this.maxDamageHandOne *= 2;
+            this.maxDamageHandTwo *= 2;
         }
-
-        try {
-            calculateAtrDamageForWeapon(this.equip.get(MBServerStatics.SLOT_MAINHAND), true);
-        } catch (Exception e) {
-
-            this.atrHandOne = GetAttackRating(this.mobBase.getAttackRating(), this);
-            this.minDamageHandOne = (short) this.mobBase.getMinDmg();
-            this.maxDamageHandOne = (short) this.mobBase.getMaxDmg();
-            this.rangeHandOne = 6.5f;
-            this.speedHandOne = 20;
-            Logger.info("Mobbase ID " + this.getMobBaseID() + " returned an error. setting to default ATR and Damage." + e.getMessage());
-        }
-
-        try {
-            calculateAtrDamageForWeapon(this.equip.get(MBServerStatics.SLOT_OFFHAND), false);
-
-        } catch (Exception e) {
-
-            this.atrHandTwo = GetAttackRating(this.mobBase.getAttackRating(), this);
-            this.minDamageHandTwo = (short) this.mobBase.getMinDmg();
-            this.maxDamageHandTwo = (short) this.mobBase.getMaxDmg();
-            this.rangeHandTwo = 6.5f;
-            this.speedHandTwo = 20;
-            Logger.info("Mobbase ID " + this.getMobBaseID() + " returned an error. setting to default ATR and Damage." + e.getMessage());
-        }
-
-        try {
-            float defense = this.mobBase.getDefenseRating();
-            defense += getShieldDefense(equip.get(MBServerStatics.SLOT_OFFHAND));
-            defense += getArmorDefense(equip.get(MBServerStatics.SLOT_HELMET));
-            defense += getArmorDefense(equip.get(MBServerStatics.SLOT_CHEST));
-            defense += getArmorDefense(equip.get(MBServerStatics.SLOT_ARMS));
-            defense += getArmorDefense(equip.get(MBServerStatics.SLOT_GLOVES));
-            defense += getArmorDefense(equip.get(MBServerStatics.SLOT_LEGGINGS));
-            defense += getArmorDefense(equip.get(MBServerStatics.SLOT_FEET));
-            defense += getWeaponDefense(equip);
-
-            // TODO add error log here
-            if (this.bonuses != null) {
-                defense = GetDefense((int)defense, this);
-
-            } else
-                Logger.error("Error: missing bonuses");
-
-            defense = (defense < 1) ? 1 : defense;
-            this.defenseRating = (short) (defense + 0.5f);
-        } catch (Exception e) {
-            Logger.info("Mobbase ID " + this.getMobBaseID() + " returned an error. Setting to Default Defense." + e.getMessage());
-            this.defenseRating = (short) this.mobBase.getDefense();
-        }
-        // calculate defense for equipment
     }
 
     public static int GetDefense(int defense, Mob mob){
@@ -1829,168 +1843,46 @@ public class Mob extends AbstractIntelligenceAgent {
 
     private void calculateAtrDamageForWeapon(MobEquipment weapon, boolean mainHand) {
 
-        int baseStrength = 0;
-
-        float skillPercentage, masteryPercentage;
-        float mastDam;
-
-        // make sure weapon exists
-
-        boolean noWeapon = false;
-        ItemBase wb = null;
-
-        if (weapon == null)
-            noWeapon = true;
-
-        else {
-
-            ItemBase ib = weapon.getItemBase();
-
-            if (ib == null)
-                noWeapon = true;
-            else if (ib.getType().equals(ItemType.WEAPON) == false) {
-                defaultAtrAndDamage(mainHand);
-                return;
-            } else
-                wb = ib;
-        }
-
-        float min, max;
-        float speed;
-        boolean strBased = false;
-
-        // get skill percentages and min and max damage for weapons
-
-        if (noWeapon) {
-
-            if (mainHand)
+        if(mainHand){
+            int min = (int)this.mobBase.getDamageMin();
+            int max = (int)this.mobBase.getDamageMax();
+            int atr = this.mobBase.getAtr();
+            if(this.bonuses != null){
+                min *= 1 + this.bonuses.getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
+                max *= 1 + this.bonuses.getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
+                atr *= 1 + this.bonuses.getFloatPercentAll(ModType.OCV,SourceType.None);
+                atr += this.bonuses.getFloat(ModType.OCV,SourceType.None);
+            }
+            this.minDamageHandOne = min;
+            this.maxDamageHandOne = max;
+            this.atrHandOne = atr;
+            if(weapon == null){
                 this.rangeHandOne = this.mobBase.getAttackRange();
-            else
-                this.rangeHandTwo = -1; // set to do not attack
-
-            skillPercentage = getModifiedAmount(this.skills.get("Unarmed Combat"));
-            masteryPercentage = getModifiedAmount(this.skills.get("Unarmed Combat Mastery"));
-
-            if (masteryPercentage == 0f)
-                mastDam = CharacterSkill.getQuickMastery(this, "Unarmed Combat Mastery");
-            else
-                mastDam = masteryPercentage;
-
-            // TODO Correct these
-            min = this.mobBase.getMinDmg();
-            max = this.mobBase.getMaxDmg();
-        } else {
-
-            if (mainHand)
-                this.rangeHandOne = weapon.getItemBase().getRange() * (1 + (baseStrength / 600.0f));
-            else
-                this.rangeHandTwo = weapon.getItemBase().getRange() * (1 + (baseStrength / 600.0f));
-
-            skillPercentage = getModifiedAmount(this.skills.get(wb.getSkillRequired()));
-            masteryPercentage = getModifiedAmount(this.skills.get(wb.getMastery()));
-
-            if (masteryPercentage == 0f)
-                mastDam = 0f;
-            else
-                mastDam = masteryPercentage;
-
-            min = wb.getMinDamage();
-            max = wb.getMaxDamage();
-            strBased = wb.isStrBased();
-        }
-
-        // calculate atr
-        float atr = this.mobBase.getAttackRating();
-
-        if (this.statStrCurrent > this.statDexCurrent)
-            atr += statStrCurrent * .5;
-        else
-            atr += statDexCurrent * .5;
-
-        // add in any bonuses to atr
-
-        if (this.bonuses != null) {
-            atr += this.bonuses.getFloat(ModType.OCV, SourceType.None);
-
-            // Finally use any multipliers. DO THIS LAST!
-            float pos_Bonus = 1 + this.bonuses.getFloatPercentPositive(ModType.OCV, SourceType.None);
-
-            atr *= pos_Bonus;
-
-            //and negative percent modifiers
-            //TODO DO DEBUFFS AFTER?? wILL TEst when finished
-            float neg_Bonus = this.bonuses.getFloatPercentNegative(ModType.OCV, SourceType.None);
-
-            atr *= (1 + neg_Bonus);
-        }
-
-        atr = (atr < 1) ? 1 : atr;
-
-        // set atr
-
-        if (mainHand)
-            this.atrHandOne = (short) (atr + 0.5f);
-        else
-            this.atrHandTwo = (short) (atr + 0.5f);
-
-        //calculate speed
-
-        if (wb != null)
-            speed = wb.getSpeed();
-        else
-            speed = 20f; //unarmed attack speed
-
-        if (this.bonuses != null && this.bonuses.getFloat(ModType.AttackDelay, SourceType.None) != 0f) //add effects speed bonus
-            speed *= (1 + this.bonuses.getFloatPercentAll(ModType.AttackDelay, SourceType.None));
-
-        if (speed < 10)
-            speed = 10;
-
-        //add min/max damage bonuses for weapon  **REMOVED
-
-        //if duel wielding, cut damage by 30%
-        // calculate damage
-
-        float minDamage;
-        float maxDamage;
-        float pri = (strBased) ? (float) this.statStrCurrent : (float) this.statDexCurrent;
-        float sec = (strBased) ? (float) this.statDexCurrent : (float) this.statStrCurrent;
-
-        minDamage = (float) (min * ((0.0315f * Math.pow(pri, 0.75f)) + (0.042f * Math.pow(sec, 0.75f)) + (0.01f * ((int) skillPercentage + (int) mastDam))));
-        maxDamage = (float) (max * ((0.0785f * Math.pow(pri, 0.75f)) + (0.016f * Math.pow(sec, 0.75f)) + (0.0075f * ((int) skillPercentage + (int) mastDam))));
-
-        minDamage = (float) ((int) (minDamage + 0.5f)); //round to nearest decimal
-        maxDamage = (float) ((int) (maxDamage + 0.5f)); //round to nearest decimal
-
-        //add Base damage last.
-        float minDamageMod = this.mobBase.getDamageMin();
-        float maxDamageMod = this.mobBase.getDamageMax();
-
-        minDamage += minDamageMod;
-        maxDamage += maxDamageMod;
-
-        // add in any bonuses to damage
-
-        if (this.bonuses != null) {
-            // Add any base bonuses
-            minDamage += this.bonuses.getFloat(ModType.MinDamage, SourceType.None);
-            maxDamage += this.bonuses.getFloat(ModType.MaxDamage, SourceType.None);
-
-            // Finally use any multipliers. DO THIS LAST!
-            minDamage *= (1 + this.bonuses.getFloatPercentAll(ModType.MinDamage, SourceType.None));
-            maxDamage *= (1 + this.bonuses.getFloatPercentAll(ModType.MaxDamage, SourceType.None));
-        }
-
-        // set damages
-
-        if (mainHand) {
-            this.minDamageHandOne = (short) minDamage;
-            this.maxDamageHandOne = (short) maxDamage;
-            this.speedHandOne = 30;
-        } else {
-            this.minDamageHandTwo = (short) minDamage;
-            this.maxDamageHandTwo = (short) maxDamage;
-            this.speedHandTwo = 30;
+                this.speedHandTwo = 20.0f;
+            }else{
+                this.rangeHandOne = weapon.getItemBase().getRange();
+                this.speedHandTwo = weapon.getItemBase().getSpeed();
+            }
+        }else{
+            int min = (int)this.mobBase.getDamageMin();
+            int max = (int)this.mobBase.getDamageMax();
+            int atr = this.mobBase.getAtr();
+            if(this.bonuses != null){
+                min *= 1 + this.bonuses.getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
+                max *= 1 + this.bonuses.getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
+                atr *= 1 + this.bonuses.getFloatPercentAll(ModType.OCV,SourceType.None);
+                atr += this.bonuses.getFloat(ModType.OCV,SourceType.None);
+            }
+            this.minDamageHandTwo = min;
+            this.maxDamageHandTwo = max;
+            this.atrHandTwo = atr;
+            if(weapon == null){
+                this.rangeHandTwo = this.mobBase.getAttackRange();
+                this.speedHandTwo = 20.0f;
+            }else{
+                this.rangeHandTwo = weapon.getItemBase().getRange();
+                this.speedHandTwo = weapon.getItemBase().getSpeed();
+            }
         }
     }
 
@@ -2060,6 +1952,9 @@ public class Mob extends AbstractIntelligenceAgent {
         if(this.isDropper){
             this.setLevel((short)65);
             this.setResists(new Resists("Dropper"));
+            this.atrHandOne *= 2;
+            this.atrHandTwo *= 2;
+
         }
         try {
             if (this.equipmentSetID != 0)
@@ -2101,6 +1996,7 @@ public class Mob extends AbstractIntelligenceAgent {
 
         try {
             NPCManager.applyRuneSetEffects(this);
+            MobBase.applyMobbaseEffects(this);
             recalculateStats();
             this.setHealth(this.healthMax);
 
@@ -2152,6 +2048,7 @@ public class Mob extends AbstractIntelligenceAgent {
                 }
 
             this.deathTime = 0;
+            InterestManager.setObjectDirty(this);
         } catch (Exception e) {
             Logger.error(e.getMessage());
         }

src/engine/objects/MobBase.java

@@ -13,8 +13,11 @@ import ch.claude_martin.enumbitset.EnumBitSet;
 import engine.Enum;
 import engine.gameManager.DbManager;
 import engine.gameManager.LootManager;
+import engine.gameManager.PowersManager;
 import engine.loot.BootySetEntry;
+import engine.powers.EffectsBase;
 import engine.server.MBServerStatics;
+import org.pmw.tinylog.Logger;
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
@@ -54,6 +57,8 @@ public class MobBase extends AbstractGameObject {
     private float walkCombat = 0;
     private float runCombat = 0;
 
+    public ArrayList<MobBaseEffects> mobbaseEffects;
+
     /**
      * ResultSet Constructor
      */
@@ -108,6 +113,7 @@ public class MobBase extends AbstractGameObject {
 
         this.mobBaseStats = DbManager.MobBaseQueries.LOAD_STATS(this.loadID);
         DbManager.MobBaseQueries.LOAD_ALL_MOBBASE_SPEEDS(this);
+        this.mobbaseEffects = DbManager.MobBaseQueries.GET_RUNEBASE_EFFECTS(this.getObjectUUID());
 
     }
 
@@ -254,7 +260,7 @@ public class MobBase extends AbstractGameObject {
     }
 
     public int getAtr() {
-        return atr;
+        return attackRating;
     }
 
     public void setAtr(int atr) {
@@ -301,4 +307,19 @@ public class MobBase extends AbstractGameObject {
         return runCombat;
     }
 
+    public static void applyMobbaseEffects(Mob mob){
+        for(MobBaseEffects mbe : mob.mobBase.mobbaseEffects){
+            if(mob.level >= mbe.getReqLvl()){
+                try {
+                    //PowersManager.applyPower(mob, mob, mob.loc, mbe.getToken(), mbe.getRank(), false);
+                    EffectsBase effectsBase = PowersManager.getEffectByToken(mbe.getToken());
+                    if(effectsBase != null)
+                        mob.addEffectNoTimer(Integer.toString(effectsBase.getUUID()), effectsBase, mbe.getRank(), true);
+                }catch(Exception e){
+                    Logger.error("NULL POWER FOR MOB: " + mob.getObjectUUID() + ", POWER TOKEN: " + mbe.getToken());
+                }
+            }
+        }
+    }
+
 }

src/engine/objects/NPC.java

@@ -79,7 +79,7 @@ public class NPC extends AbstractCharacter {
     private HashSet<Integer> canRoll = null;
     public int parentZoneUUID;
     public int equipmentSetID = 0;
-    private int repairCost = 5;
+    private int specialPrice = 5;
 
     // New NPC constructor.  Fill in the blanks and then call
     // PERSIST.
@@ -153,6 +153,12 @@ public class NPC extends AbstractCharacter {
 
             this.name = rs.getString("npc_name");
 
+            try {
+                this.specialPrice = rs.getInt("specialPrice");
+            }catch(Exception e){
+                this.specialPrice = 5;
+            }
+
         } catch (Exception e) {
             Logger.error("NPC: " + this.dbID + " :" + e);
             e.printStackTrace();
@@ -798,7 +804,7 @@ public class NPC extends AbstractCharacter {
 
     @Override
     public void updateDatabase() {
-        DbManager.NPCQueries.updateDatabase(this);
+        DbManager.NPCQueries.updateSpecialPricing(this);
     }
 
     public int getSymbol() {
@@ -1290,12 +1296,13 @@ public class NPC extends AbstractCharacter {
         return name;
     }
 
-    public int getRepairCost() {
-        return repairCost;
+    public int getSpecialPrice() {
+        return specialPrice;
     }
 
-    public void setRepairCost(int repairCost) {
-        this.repairCost = repairCost;
+    public void setSpecialPrice(int specialPrice) {
+        this.specialPrice = specialPrice;
+        DbManager.NPCQueries.updateSpecialPricing(this);
     }
 
     public void processUpgradeNPC(PlayerCharacter player) {

src/engine/objects/PlayerBonuses.java

@@ -27,7 +27,7 @@ import java.util.concurrent.ConcurrentHashMap;
 public class PlayerBonuses {
 
     //First bonus set
-    private ConcurrentHashMap<AbstractEffectModifier, Float> bonusFloats = new ConcurrentHashMap<>();
+    ConcurrentHashMap<AbstractEffectModifier, Float> bonusFloats = new ConcurrentHashMap<>();
     private ConcurrentHashMap<AbstractEffectModifier, DamageShield> bonusDamageShields = new ConcurrentHashMap<>();
     private ConcurrentHashMap<AbstractEffectModifier, String> bonusStrings = new ConcurrentHashMap<>();
     private ConcurrentHashMap<ModType, HashSet<SourceType>> bonusLists = new ConcurrentHashMap<>();

src/engine/objects/PlayerCombatStats.java

@@ -0,0 +1,752 @@
+package engine.objects;
+
+import engine.Enum;
+import engine.powers.effectmodifiers.AbstractEffectModifier;
+import engine.server.MBServerStatics;
+import org.pmw.tinylog.Logger;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class PlayerCombatStats {
+
+    public PlayerCharacter owner;
+    //main hand data
+    public int minDamageHandOne;
+    public int maxDamageHandOne;
+    public float attackSpeedHandOne;
+    public float rangeHandOne;
+    public float atrHandOne;
+    //off hand data
+    public int minDamageHandTwo;
+    public int maxDamageHandTwo;
+    public float attackSpeedHandTwo;
+    public float rangeHandTwo;
+    public float atrHandTwo;
+    //defense
+    public int defense;
+    //regen rates
+    public float healthRegen;
+    public float manaRegen;
+    public float staminaRegen;
+
+    public PlayerCombatStats(PlayerCharacter pc) {
+        this.owner = pc;
+        this.update();
+    }
+
+    public void update() {
+        try {
+            this.calculateATR(true);
+        } catch (Exception e) {
+            Logger.error("FAILED TO CALCULATE ATR FOR: " + this.owner.getObjectUUID());
+        }
+        try {
+            this.calculateATR(false);
+        } catch (Exception e) {
+            Logger.error("FAILED TO CALCULATE ATR FOR: " + this.owner.getObjectUUID());
+        }
+        try {
+            this.calculateMin(true);
+        } catch (Exception e) {
+            Logger.error("FAILED TO CALCULATE Min FOR: " + this.owner.getObjectUUID());
+        }
+        try {
+            this.calculateMin(false);
+        } catch (Exception e) {
+            Logger.error("FAILED TO CALCULATE Min FOR: " + this.owner.getObjectUUID());
+        }
+        try {
+            this.calculateMax(true);
+        } catch (Exception e) {
+            Logger.error("FAILED TO CALCULATE Max FOR: " + this.owner.getObjectUUID());
+        }
+        try {
+            this.calculateMax(false);
+        } catch (Exception e) {
+            Logger.error("FAILED TO CALCULATE Max FOR: " + this.owner.getObjectUUID());
+        }
+        try {
+            this.calculateAttackSpeed(true);
+        } catch (Exception e) {
+            Logger.error("FAILED TO CALCULATE Attack Speed FOR: " + this.owner.getObjectUUID());
+        }
+        try {
+            this.calculateAttackSpeed(false);
+        } catch (Exception e) {
+            Logger.error("FAILED TO CALCULATE Attack Speed FOR: " + this.owner.getObjectUUID());
+        }
+        try {
+            this.calculateAttackRange(true);
+        } catch (Exception e) {
+            Logger.error("FAILED TO CALCULATE Attack Range FOR: " + this.owner.getObjectUUID());
+        }
+        try {
+            this.calculateAttackRange(false);
+        } catch (Exception e) {
+            Logger.error("FAILED TO CALCULATE Attack Range FOR: " + this.owner.getObjectUUID());
+        }
+        try {
+            this.calculateRegen();
+        } catch (Exception e) {
+            Logger.error("FAILED TO CALCULATE Regen FOR: " + this.owner.getObjectUUID());
+        }
+        try {
+            this.calculateDefense();
+        } catch (Exception e) {
+            Logger.error("FAILED TO CALCULATE Defense FOR: " + this.owner.getObjectUUID());
+        }
+    }
+
+    public void calculateATR(boolean mainHand) {
+        Item weapon;
+        float atr;
+
+        if(mainHand) {
+            weapon = this.owner.charItemManager.getEquipped(1);
+        }else {
+            weapon = this.owner.charItemManager.getEquipped(2);
+        }
+
+        String skill = "Unarmed Combat";
+        String mastery = "Unarmed Combat Mastery";
+        int primaryStat = getDexAfterPenalty(this.owner);
+        if(weapon != null) {
+            skill= weapon.getItemBase().getSkillRequired();
+            mastery = weapon.getItemBase().getMastery();
+            if(weapon.getItemBase().isStrBased())
+                primaryStat = this.owner.statStrCurrent;
+        }
+
+        float skillLevel = 0;
+        float masteryLevel = 0;
+
+        if(this.owner.skills.containsKey(skill)) {
+            skillLevel = this.owner.skills.get(skill).getModifiedAmount();
+        }
+        if(this.owner.skills.containsKey(mastery))
+            masteryLevel = this.owner.skills.get(mastery).getModifiedAmount();
+
+        float stanceValue = 0.0f;
+        float atrEnchants = 0;
+
+        for(String effID : this.owner.effects.keySet()) {
+            if (effID.contains("Stance")) {
+                for (AbstractEffectModifier mod : this.owner.effects.get(effID).getEffectModifiers()) {
+                    if (mod.modType.equals(Enum.ModType.OCV)) {
+                        float percent = mod.getPercentMod();
+                        int trains = this.owner.effects.get(effID).getTrains();
+                        float modValue = percent + (trains * mod.getRamp());
+                        stanceValue += modValue * 0.01f;
+                    }
+                }
+            } else {
+                for (AbstractEffectModifier mod : this.owner.effects.get(effID).getEffectModifiers()) {
+                    if (mod.modType.equals(Enum.ModType.OCV)) {
+                        float value = mod.getMinMod();
+                        int trains = this.owner.effects.get(effID).getTrains();
+                        float modValue = value + (trains * mod.getRamp());
+                        atrEnchants += modValue;
+                    }
+                }
+            }
+        }
+
+        float prefixValues = 0.0f;
+        if(weapon != null){
+            if(this.owner.charItemManager.getEquipped(1) != null){
+                for(Effect eff : this.owner.charItemManager.getEquipped(1).effects.values()){
+                    for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                        if(mod.modType.equals(Enum.ModType.OCV)){
+                            prefixValues += mod.minMod + (eff.getTrains() * mod.getRamp());
+                        }
+                    }
+                }
+            }
+        }
+        if(this.owner.charItemManager.getEquipped(2) != null){
+            for(Effect eff : this.owner.charItemManager.getEquipped(2).effects.values()){
+                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                    if(mod.modType.equals(Enum.ModType.OCV)){
+                        prefixValues += mod.minMod + (eff.getTrains() * mod.getRamp());
+                    }
+                }
+            }
+        }
+
+        float preciseRune = 1.0f;
+        for(CharacterRune rune : this.owner.runes){
+            if(rune.getRuneBase().getName().equals("Precise"))
+                preciseRune += 0.05f;
+        }
+
+        if(weapon != null && weapon.getItemBase().isStrBased()){
+            atr = (((primaryStat / 2) + (skillLevel * 4 + masteryLevel * 3) + prefixValues) * preciseRune + atrEnchants) * (1.0f + stanceValue);
+            atr = (float) Math.round(atr);
+        }else {
+            float dexterity = getDexAfterPenalty(this.owner);
+            atr = dexterity / 2;
+            atr += skillLevel * 4;
+            atr += masteryLevel * 3;
+            atr += prefixValues;
+            atr *= preciseRune;
+            atr += atrEnchants;
+            atr *= 1.0f + stanceValue;
+            atr = (float) Math.round(atr);
+        }
+
+
+
+        if(mainHand){
+            this.atrHandOne = atr;
+        }else{
+            this.atrHandTwo = atr;
+            if(this.owner.charItemManager.getEquipped(1) == null && this.owner.charItemManager.getEquipped(2) != null){
+                if(!this.owner.charItemManager.getEquipped(2).getItemBase().isShield())
+                    this.atrHandOne = 0.0f;
+            }else if(this.owner.charItemManager.getEquipped(2) == null && this.owner.charItemManager.getEquipped(1) != null){
+                this.atrHandTwo = 0.0f;
+            }
+        }
+    } //perfect DO NOT TOUCH
+
+    public void calculateMin(boolean mainHand) {
+        Item weapon;
+        float specialDex = this.owner.statDexBase;
+        specialDex += this.owner.bonuses.getFloat(Enum.ModType.Attr, Enum.SourceType.Dexterity);
+        float baseDMG = 1;
+        float primaryStat = specialDex;//getDexAfterPenalty(this.owner);
+        float secondaryStat = this.owner.statStrCurrent;
+        double weaponSkill = 5;
+        double weaponMastery = 5;
+
+        if (mainHand) {
+            weapon = this.owner.charItemManager.getEquipped(1);
+        } else {
+            weapon = this.owner.charItemManager.getEquipped(2);
+        }
+
+        String skill = "Unarmed Combat";
+        String mastery = "Unarmed Combat Mastery";
+
+        if (weapon != null) {
+            baseDMG = weapon.getItemBase().getMinDamage();
+            skill = weapon.getItemBase().getSkillRequired();
+            mastery = weapon.getItemBase().getMastery();
+            if (weapon.getItemBase().isStrBased()) {
+                primaryStat = this.owner.statStrCurrent;
+                secondaryStat = specialDex;//getDexAfterPenalty(this.owner);
+            }
+            for(Effect eff : weapon.effects.values()){
+                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                    if(mod.modType.equals(Enum.ModType.MinDamage)){
+                        baseDMG += mod.minMod + (mod.getRamp() * eff.getTrains());
+                    }
+                }
+            }
+        }
+
+        if (this.owner.skills.containsKey(skill)) {
+            weaponSkill = this.owner.skills.get(skill).getTotalSkillPercet();
+        }
+
+        if (this.owner.skills.containsKey(mastery)) {
+            weaponMastery = this.owner.skills.get(mastery).getTotalSkillPercet();
+        }
+
+        double minDMG = baseDMG * (
+                0.0048 * primaryStat +
+                        0.049 * Math.sqrt(primaryStat - 0.75) +
+                        0.0066 * secondaryStat +
+                        0.064 * Math.sqrt(secondaryStat - 0.75) +
+                        0.01 * (weaponSkill + weaponMastery)
+        );
+        if(this.owner.bonuses != null){
+            minDMG += this.owner.bonuses.getFloat(Enum.ModType.MinDamage, Enum.SourceType.None);
+            minDMG *= 1 + this.owner.bonuses.getFloatPercentAll(Enum.ModType.MeleeDamageModifier, Enum.SourceType.None);
+        }
+
+        if(this.owner.charItemManager != null){
+            if(this.owner.charItemManager.getEquipped(1) != null && this.owner.charItemManager.getEquipped(2) != null && !this.owner.charItemManager.getEquipped(2).getItemBase().isShield()){
+                minDMG *= 0.7f;
+            }
+        }
+
+        int roundedMin = (int)Math.round(minDMG);
+
+        if (mainHand) {
+            this.minDamageHandOne = roundedMin;
+        } else {
+            this.minDamageHandTwo = roundedMin;
+            if(this.owner.charItemManager.getEquipped(1) == null && this.owner.charItemManager.getEquipped(2) != null){
+                if(!this.owner.charItemManager.getEquipped(2).getItemBase().isShield())
+                    this.minDamageHandOne = 0;
+            }else if(this.owner.charItemManager.getEquipped(2) == null && this.owner.charItemManager.getEquipped(1) != null){
+                this.minDamageHandTwo = 0;
+            }
+        }
+    }
+
+    public void calculateMax(boolean mainHand) {
+        //Weapon Max DMG = BaseDMG * (0.0124*Primary Stat + 0.118*(Primary Stat -0.75)^0.5
+        // + 0.0022*Secondary Stat + 0.028*(Secondary Stat-0.75)^0.5 + 0.0075*(Weapon Skill + Weapon Mastery))
+        Item weapon;
+        float specialDex = this.owner.statDexBase;
+        specialDex += this.owner.bonuses.getFloat(Enum.ModType.Attr, Enum.SourceType.Dexterity);
+        double baseDMG = 5;
+        float primaryStat = specialDex;//getDexAfterPenalty(this.owner);
+        float secondaryStat = this.owner.statStrCurrent;
+        double weaponSkill = 5;
+        double weaponMastery = 5;
+
+
+        if (mainHand) {
+            weapon = this.owner.charItemManager.getEquipped(1);
+        } else {
+            weapon = this.owner.charItemManager.getEquipped(2);
+        }
+
+        String skill = "Unarmed Combat";
+        String mastery = "Unarmed Combat Mastery";
+        if (weapon != null) {
+            baseDMG = weapon.getItemBase().getMaxDamage();
+            skill = weapon.getItemBase().getSkillRequired();
+            mastery = weapon.getItemBase().getMastery();
+            if (weapon.getItemBase().isStrBased()) {
+                primaryStat = this.owner.statStrCurrent;
+                secondaryStat = specialDex;//getDexAfterPenalty(this.owner);
+            }
+            for(Effect eff : weapon.effects.values()){
+                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                    if(mod.modType.equals(Enum.ModType.MaxDamage)){
+                        baseDMG += mod.minMod + (mod.getRamp() * eff.getTrains());
+                    }
+                }
+            }
+        }
+
+        if (this.owner.skills.containsKey(skill)) {
+            weaponSkill = this.owner.skills.get(skill).getModifiedAmount();
+        }
+
+        if (this.owner.skills.containsKey(mastery)) {
+            weaponMastery = this.owner.skills.get(mastery).getModifiedAmount();
+        }
+
+        double maxDMG = baseDMG * (
+                0.0124 * primaryStat +
+                        0.118 * Math.sqrt(primaryStat - 0.75) +
+                        0.0022 * secondaryStat +
+                        0.028 * Math.sqrt(secondaryStat - 0.75) +
+                        0.0075 * (weaponSkill + weaponMastery)
+        );
+
+        if(this.owner.bonuses != null){
+            maxDMG += this.owner.bonuses.getFloat(Enum.ModType.MaxDamage, Enum.SourceType.None);
+            maxDMG *= 1 + this.owner.bonuses.getFloatPercentAll(Enum.ModType.MeleeDamageModifier, Enum.SourceType.None);
+        }
+
+        if(this.owner.charItemManager != null){
+            if(this.owner.charItemManager.getEquipped(1) != null && this.owner.charItemManager.getEquipped(2) != null && !this.owner.charItemManager.getEquipped(2).getItemBase().isShield()){
+                maxDMG *= 0.7f;
+            }
+        }
+
+        int roundedMax = (int)(maxDMG);
+
+        if(mainHand){
+            this.maxDamageHandOne = roundedMax;
+        }else{
+            this.maxDamageHandTwo = roundedMax;
+            if(this.owner.charItemManager.getEquipped(1) == null && this.owner.charItemManager.getEquipped(2) != null){
+                if(!this.owner.charItemManager.getEquipped(2).getItemBase().isShield())
+                    this.maxDamageHandOne = 0;
+            }else if(this.owner.charItemManager.getEquipped(2) == null && this.owner.charItemManager.getEquipped(1) != null){
+                this.maxDamageHandTwo = 0;
+            }
+        }
+    }
+
+    public void calculateAttackSpeed(boolean mainHand){
+        Item weapon;
+        float speed;
+        if(mainHand) {
+            weapon = this.owner.charItemManager.getEquipped(1);
+        }else {
+            weapon = this.owner.charItemManager.getEquipped(2);
+        }
+        float delayExtra = 0;
+        if(weapon == null) {
+            speed = 20.0f;
+        }else{
+            speed = weapon.getItemBase().getSpeed();
+            for(Effect eff : weapon.effects.values()){
+                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                    if(mod.modType.equals(Enum.ModType.WeaponSpeed) || mod.modType.equals(Enum.ModType.AttackDelay)){
+                        float percent = mod.getPercentMod();
+                        int trains = eff.getTrains();
+                        float modValue = percent + (trains * mod.getRamp());
+                        speed *= 1 + (modValue * 0.01f);
+                        if(mod.modType.equals(Enum.ModType.AttackDelay)){
+                            delayExtra += modValue * 0.01f;
+                        }
+                    }
+                }
+            }
+        }
+
+        float stanceValue = 0.0f;
+        for(String effID : this.owner.effects.keySet()){
+            if(effID.contains("Stance")){
+                if(this.owner.effects != null) {
+                    for (AbstractEffectModifier mod : this.owner.effects.get(effID).getEffectModifiers()) {
+                        if (mod.modType.equals(Enum.ModType.AttackDelay)) {
+                            float percent = mod.getPercentMod();
+                            int trains = this.owner.effects.get(effID).getTrains();
+                            float modValue = percent + (trains * mod.getRamp());
+                            stanceValue += modValue * 0.01f;
+                        }
+                    }
+                }
+            }
+        }
+
+        float bonusValues = 1 + this.owner.bonuses.getFloatPercentAll(Enum.ModType.AttackDelay,Enum.SourceType.None);//1.0f;
+        bonusValues -= stanceValue + delayExtra; // take away stance modifier from alac bonus values
+        speed *= 1 + stanceValue; // apply stance bonus
+        speed *= bonusValues; // apply alac bonuses without stance mod
+
+        if(speed < 10.0f)
+            speed = 10.0f;
+
+        if(mainHand){
+            this.attackSpeedHandOne = speed;
+        }else{
+            this.attackSpeedHandTwo = speed;
+            if(this.owner.charItemManager.getEquipped(1) == null && this.owner.charItemManager.getEquipped(2) != null){
+                if(!this.owner.charItemManager.getEquipped(2).getItemBase().isShield())
+                    this.attackSpeedHandOne = 0.0f;
+            }else if(this.owner.charItemManager.getEquipped(2) == null && this.owner.charItemManager.getEquipped(1) != null){
+                this.attackSpeedHandTwo = 0.0f;
+            }
+        }
+    }
+
+    public void calculateAttackRange(boolean mainHand){
+        Item weapon;
+        float range;
+        if(mainHand) {
+            weapon = this.owner.charItemManager.getEquipped(1);
+        }else {
+            weapon = this.owner.charItemManager.getEquipped(2);
+        }
+
+        if(weapon == null) {
+            range = 6.0f;
+        }else{
+            range = weapon.getItemBase().getRange();
+        }
+        if(owner.bonuses != null){
+            range *= 1 + this.owner.bonuses.getFloatPercentAll(Enum.ModType.WeaponRange, Enum.SourceType.None);
+        }
+        if(mainHand){
+            this.rangeHandOne = range;
+        }else{
+            this.rangeHandTwo = range;
+            if(this.owner.charItemManager.getEquipped(1) == null && this.owner.charItemManager.getEquipped(2) != null){
+                if(!this.owner.charItemManager.getEquipped(2).getItemBase().isShield())
+                    this.rangeHandOne = 0.0f;
+            }else if(this.owner.charItemManager.getEquipped(2) == null && this.owner.charItemManager.getEquipped(1) != null){
+                this.rangeHandTwo = 0.0f;
+            }
+        }
+    }
+
+    public void calculateRegen(){
+        if(owner.bonuses != null){
+            this.healthRegen = 1.0f + this.owner.bonuses.getFloatPercentAll(Enum.ModType.HealthRecoverRate, Enum.SourceType.None);
+            this.manaRegen = 1.0f + this.owner.bonuses.getFloatPercentAll(Enum.ModType.ManaRecoverRate, Enum.SourceType.None);
+            this.staminaRegen = 1.0f + this.owner.bonuses.getFloatPercentAll(Enum.ModType.StaminaRecoverRate, Enum.SourceType.None);
+
+        }else{
+            this.healthRegen = 1.0f;
+            this.manaRegen = 1.0f;
+            this.staminaRegen = 1.0f;
+        }
+    }
+
+    public void calculateDefense() {
+        //Defense = (1+Armor skill / 50) * Armor defense + (1 + Block skill / 100) * Shield defense + (Primary weapon skill / 2)
+        // + (Weapon mastery skill/ 2) + Dexterity * 2 + Flat bonuses from rings or cloth
+        float armorSkill = 0.0f;
+        float armorDefense = 0.0f;
+        ArrayList<String> armorsUsed = new ArrayList<>();
+        for(Item equipped : this.owner.charItemManager.getEquipped().values()){
+            ItemBase ib = equipped.getItemBase();
+            if(ib.isHeavyArmor() || ib.isMediumArmor() || ib.isLightArmor() || ib.isClothArmor()){
+                armorDefense += ib.getDefense();
+                for(Effect eff : equipped.effects.values()){
+                    for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                        if(mod.modType.equals(Enum.ModType.DR)){
+                            armorDefense += mod.minMod + (mod.getRamp() * eff.getTrains());
+                        }
+                    }
+                }
+                if(!ib.isClothArmor() && !armorsUsed.contains(ib.getSkillRequired())) {
+                    armorsUsed.add(ib.getSkillRequired());
+                }
+            }
+        }
+        for(String armorUsed : armorsUsed){
+            if(this.owner.skills.containsKey(armorUsed)) {
+                armorSkill += calculateModifiedSkill(armorUsed,this.owner);
+            }
+        }
+        if(armorsUsed.size() > 0)
+            armorSkill = armorSkill / armorsUsed.size();
+
+        float blockSkill = 0.0f;
+        if(this.owner.skills.containsKey("Block"))
+            blockSkill = calculateModifiedSkill("Block",this.owner);
+
+        float shieldDefense = 0.0f;
+        if(this.owner.charItemManager.getEquipped(2) != null && this.owner.charItemManager.getEquipped(2).getItemBase().isShield()){
+            Item shield = this.owner.charItemManager.getEquipped(2);
+            shieldDefense += shield.getItemBase().getDefense();
+            for(Effect eff : shield.effects.values()){
+                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                    if(mod.modType.equals(Enum.ModType.DR)){
+                        shieldDefense += mod.minMod + (mod.getRamp() * eff.getTrains());
+                    }
+                }
+            }
+        }
+
+        float weaponSkill = 0.0f;
+        float masterySkill = 0.0f;
+        Item weapon = this.owner.charItemManager.getEquipped(1);
+        if(weapon == null){
+            weapon = this.owner.charItemManager.getEquipped(2);
+        }
+        if(weapon != null && weapon.getItemBase().isShield())
+            weapon = null;
+
+        String skillName = "Unarmed Combat";
+        String masteryName = "Unarmed Combat Mastery";
+
+        if(weapon != null){
+            skillName = weapon.getItemBase().getSkillRequired();
+            masteryName = weapon.getItemBase().getMastery();
+        }
+        if(this.owner.skills.containsKey(skillName))
+            weaponSkill = this.owner.skills.get(skillName).getModifiedAmount();//calculateModifiedSkill(skillName,this.owner);//this.owner.skills.get(skillName).getModifiedAmount();
+
+        if(this.owner.skills.containsKey(masteryName))
+            masterySkill = this.owner.skills.get(masteryName).getModifiedAmount();//calculateModifiedSkill(masteryName,this.owner);//this.owner.skills.get(masteryName).getModifiedAmount();
+
+        float dexterity = getDexAfterPenalty(this.owner);
+
+        float luckyRune = 1.0f;
+        for(CharacterRune rune : this.owner.runes){
+            if(rune.getRuneBase().getName().equals("Lucky"))
+                luckyRune += 0.05f;
+        }
+
+        float flatBonuses = 0.0f;
+        float stanceMod = 1.0f;
+        for(String effID : this.owner.effects.keySet()) {
+            if (effID.contains("Stance")) {
+                for (AbstractEffectModifier mod : this.owner.effects.get(effID).getEffectModifiers()) {
+                    if (mod.modType.equals(Enum.ModType.DCV)) {
+                        float percent = mod.getPercentMod();
+                        int trains = this.owner.effects.get(effID).getTrains();
+                        float modValue = percent + (trains * mod.getRamp());
+                        stanceMod += modValue * 0.01f;
+                    }
+                }
+            } else {
+                for (AbstractEffectModifier mod : this.owner.effects.get(effID).getEffectModifiers()) {
+                    if (mod.modType.equals(Enum.ModType.DCV)) {
+                        float value = mod.getMinMod();
+                        int trains = this.owner.effects.get(effID).getTrains();
+                        float modValue = value + (trains * mod.getRamp());
+                        flatBonuses += modValue;
+                    }
+                }
+            }
+        }
+        if(this.owner.charItemManager.getEquipped(2) == null)
+            blockSkill = 0;
+        else if(this.owner.charItemManager != null && this.owner.charItemManager.getEquipped(2) != null && !this.owner.charItemManager.getEquipped(2).getItemBase().isShield())
+            blockSkill = 0;
+
+        //Defense = (1+Armor skill / 50) * Armor defense + (1 + Block skill / 100) * Shield defense
+        // + (Primary weapon skill / 2) + (Weapon mastery skill/ 2) + ROUND((Dexterity-Dex penalty),0) * 2 + Flat bonuses from rings or cloth
+        float defense = 0;
+        for(Item equipped : this.owner.charItemManager.getEquippedList()){
+            ItemBase ib = equipped.getItemBase();
+            if(ib.getType().equals(Enum.ItemType.ARMOR) && !ib.isShield()){
+                defense += getArmorDefense(equipped,this.owner);
+            }
+        }
+        //float defense = (1 + armorSkill / 50) * armorDefense;
+        defense += (1 + blockSkill / 100) * shieldDefense;
+        defense += (weaponSkill / 2);
+        defense += (masterySkill / 2);
+        defense += dexterity * 2;
+        defense += flatBonuses;
+        defense *= luckyRune;
+        defense *= stanceMod;
+
+        defense = Math.round(defense);
+
+        this.defense = (int) defense;
+    }
+
+    public static float calculateModifiedSkill(String skillName, PlayerCharacter pc) {
+
+        CharacterSkill skill = null;
+        if (pc.skills.containsKey(skillName)) {
+            skill = pc.skills.get(skillName);
+        }
+        SkillsBase skillBase = skill.getSkillsBase();
+        if(skillBase == null)
+            return 0;
+
+        //Get any rune bonus
+        float bonus = 0f;
+        if (pc.getBonuses() != null) {
+            //Get bonuses from runes
+            bonus = pc.getBonuses().getSkillBonus(skillBase.sourceType);
+        }
+
+        //Get Base skill for modified stats
+        float base = 7f;
+        if(skillBase.getToken() == -660435875){
+            base = 0;
+        }
+        float statMod = 0.5f;
+        if (skillBase.getStrMod() > 0)
+            statMod += (float) skillBase.getStrMod() * (float) pc.getStatStrCurrent() / 100f;
+        if (skillBase.getDexMod() > 0)
+            statMod += (float) skillBase.getDexMod() * (float) getDexAfterPenalty(pc) / 100f;
+        if (skillBase.getConMod() > 0)
+            statMod += (float) skillBase.getConMod() * (float) pc.getStatConCurrent() / 100f;
+        if (skillBase.getIntMod() > 0)
+            statMod += (float) skillBase.getIntMod() * (float) pc.getStatIntCurrent() / 100f;
+        if (skillBase.getSpiMod() > 0)
+            statMod += (float) skillBase.getSpiMod() * (float) pc.getStatSpiCurrent() / 100f;
+
+        if (statMod < 1)
+            statMod = 1f;
+
+        if(skillBase.getToken() == -660435875){
+            statMod = 0;
+        }
+        base += CharacterSkill.baseSkillValues[(int) statMod];
+        Enum.SourceType sourceType = Enum.SourceType.GetSourceType(skillBase.getNameNoSpace());
+
+        //Get any rune, effect and item bonus
+
+        if (pc.getBonuses() != null) {
+            //add bonuses from effects/items and runes
+            base += bonus + pc.getBonuses().getFloat(Enum.ModType.Skill, sourceType);
+        }
+        float baseAmount;
+        if (base < 1f && skillBase.getToken() != -660435875)
+            baseAmount = 1f;
+        else
+            baseAmount = base;
+
+        int amount;
+
+        int trains = skill.getNumTrains();
+        if (trains < 10)
+            amount = (trains * 2);
+        else if (trains < 90)
+            amount = 10 + trains;
+        else if (trains < 134)
+            amount = 100 + ((trains - 90) / 2);
+        else
+            amount = 122 + ((trains - 134) / 3);
+
+        float modAmount = baseAmount + amount;
+
+        if (pc.getBonuses() != null) {
+            //Multiply any percent bonuses
+            modAmount *= (1 + pc.getBonuses().getFloatPercentAll(Enum.ModType.Skill, sourceType));
+        }
+
+        float modifiedAmount = (float) Math.round(modAmount);
+
+        return modifiedAmount;
+    }
+
+    public static int getDexAfterPenalty(PlayerCharacter pc){
+        if(pc.charItemManager == null)
+            return pc.statDexCurrent;
+
+        float dex = pc.statDexBase;
+        if(pc.bonuses != null)
+            dex += pc.bonuses.getFloat(Enum.ModType.Attr, Enum.SourceType.Dexterity);
+
+        float penaltyFactor = 0.0f;
+        for(Item equipped : pc.charItemManager.getEquipped().values()){
+            ItemBase ib = equipped.getItemBase();
+            if(ib.isHeavyArmor() || ib.isLightArmor() || ib.isMediumArmor()){
+                penaltyFactor += ib.dexReduction;
+            }
+        }
+
+        if(penaltyFactor > 0)
+            penaltyFactor *= 0.01f;
+
+        float totalPenalty = dex *  penaltyFactor;
+        float returnedDex = Math.round(dex - totalPenalty);
+        return (int) returnedDex;
+
+    }
+
+    private static float getArmorDefense(Item armor, PlayerCharacter pc) {
+
+        if (armor == null)
+            return 0;
+
+        ItemBase ib = armor.getItemBase();
+
+        if (ib == null)
+            return 0;
+
+        if (!ib.getType().equals(Enum.ItemType.ARMOR))
+            return 0;
+
+        if (ib.getSkillRequired().isEmpty())
+            return ib.getDefense();
+
+        CharacterSkill armorSkill = pc.skills.get(ib.getSkillRequired());
+        if (armorSkill == null) {
+            Logger.error("Player " + pc.getObjectUUID()
+                    + " has armor equipped without the nescessary skill to equip it");
+            return ib.getDefense();
+        }
+
+        float def = ib.getDefense();
+        //apply item defense bonuses
+        if (armor != null) {
+
+            for(Effect eff : armor.effects.values()){
+                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                    if(mod.modType.equals(Enum.ModType.DR)){
+                        def += mod.minMod * (1+(eff.getTrains() * mod.getRamp()));
+                    }
+                }
+            }
+
+
+            //def += armor.getBonus(ModType.DR, SourceType.None);
+            //def *= (1 + armor.getBonusPercent(ModType.DR, SourceType.None));
+        }
+        return (def * (1 + ((int) armorSkill.getModifiedAmount() / 50f)));
+    }
+}

src/engine/objects/Realm.java

@@ -10,10 +10,14 @@
 package engine.objects;
 
 import engine.Enum;
+import engine.InterestManagement.InterestManager;
 import engine.InterestManagement.RealmMap;
+import engine.InterestManagement.WorldGrid;
 import engine.db.archive.DataWarehouse;
 import engine.db.archive.RealmRecord;
+import engine.gameManager.BuildingManager;
 import engine.gameManager.DbManager;
+import engine.gameManager.NPCManager;
 import engine.gameManager.PowersManager;
 import engine.net.ByteBufferWriter;
 import engine.powers.PowersBase;
@@ -379,6 +383,16 @@ public class Realm {
 
     public void abandonRealm() {
 
+        for(AbstractWorldObject awo : WorldGrid.getObjectsInRangePartial(this.getRulingCity().loc,1750,MBServerStatics.MASK_BUILDING)){
+            Building wall = (Building)awo;
+            if(wall.getBlueprint() != null && wall.getBlueprint().getBuildingGroup() != null && wall.getBlueprint().isWallPiece()){
+                float currentHealthRatio = wall.getCurrentHitpoints()/wall.healthMax;
+                float newMax = wall.getBlueprint().getMaxHealth(1);
+                wall.setMaxHitPoints(newMax);
+                wall.setHealth(wall.healthMax * currentHealthRatio);
+            }
+        }
+
         // Push event to warehouse
 
         RealmRecord realmRecord = RealmRecord.borrow(this, Enum.RecordEventType.LOST);
@@ -406,6 +420,17 @@ public class Realm {
         this.configure();
         this.updateDatabase();
 
+        for(AbstractWorldObject awo : WorldGrid.getObjectsInRangePartial(city.loc,1750,MBServerStatics.MASK_BUILDING)){
+            Building wall = (Building)awo;
+            if(wall.getBlueprint() != null && wall.getBlueprint().getBuildingGroup() != null && wall.getBlueprint().isWallPiece()){
+                float currentHealthRatio = wall.getCurrentHitpoints()/wall.healthMax;
+                float newMax = wall.healthMax * 1.1f;
+                wall.setMaxHitPoints(newMax);
+                wall.setHealth(wall.healthMax * currentHealthRatio);
+            }
+        }
+
+
         // Push event to warehouse
 
         RealmRecord realmRecord = RealmRecord.borrow(this, Enum.RecordEventType.CAPTURE);

src/engine/objects/Resists.java

@@ -457,7 +457,9 @@ public class Resists {
         //damage = handleFortitude(target, type, damage);
         //calculate armor piercing
         float ap = source.getBonuses().getFloatPercentAll(ModType.ArmorPiercing, SourceType.None);
-        float damageAfterResists = damage * (1 - (this.getResist(type, trains) * 0.01f) + ap);
+        float damageAfterResists = damage;
+        if(type.equals(DamageType.Pierce) || type.equals(DamageType.Crush) || type.equals(DamageType.Slash))
+            damageAfterResists = damage * (1 - (this.getResist(type, trains) * 0.01f) + ap);
         //check to see if any damage absorbers should cancel
         if (target != null) {
             //debug damage shields if any found

src/engine/powers/PowersBase.java

@@ -11,6 +11,7 @@ package engine.powers;
 
 import engine.Enum.PowerCategoryType;
 import engine.Enum.PowerTargetType;
+import engine.gameManager.PowersManager;
 import org.pmw.tinylog.Logger;
 
 import java.sql.ResultSet;
@@ -109,6 +110,8 @@ public class PowersBase {
     public PowerCategoryType powerCategory;
     public String description;
 
+    public boolean breaksForm = true;
+
     /**
      * No Table ID Constructor
      */
@@ -325,6 +328,8 @@ public class PowersBase {
         ct = rs.getString("monsterTypeRestrict3").trim();
         if (!ct.isEmpty())
             this.monsterTypeRestrictions.add(ct);
+
+        this.breaksForm = PowersManager.breakForm(this.token);
     }
 
 

src/engine/powers/effectmodifiers/AttributeEffectModifier.java

@@ -30,7 +30,7 @@ public class AttributeEffectModifier extends AbstractEffectModifier {
     @Override
     public void applyBonus(AbstractCharacter ac, int trains) {
 
-        ac.update();
+        ac.update(false);
         Float amount = 0f;
         PlayerBonuses bonus = ac.getBonuses();
         if (this.percentMod != 0f) { //Stat Percent Modifiers

src/engine/powers/effectmodifiers/HealthRecoverRateEffectModifier.java

@@ -29,7 +29,7 @@ public class HealthRecoverRateEffectModifier extends AbstractEffectModifier {
     @Override
     public void applyBonus(AbstractCharacter ac, int trains) {
 
-        ac.update();
+        ac.update(false);
         Float amount = 0f;
         PlayerBonuses bonus = ac.getBonuses();
         if (this.useRampAdd)

src/engine/powers/effectmodifiers/NoModEffectModifier.java

@@ -39,7 +39,7 @@ public class NoModEffectModifier extends AbstractEffectModifier {
                 PlayerCharacter flyer = (PlayerCharacter) ac;
 
                 if (flyer.getAltitude() > 0)
-                    flyer.update();
+                    flyer.update(false);
                 PlayerCharacter.GroundPlayer(flyer);
                 break;
 

src/engine/powers/poweractions/ApplyEffectPowerAction.java

@@ -130,7 +130,7 @@ public class ApplyEffectPowerAction extends AbstractPowerAction {
                     ((Mob) awo).setCombatTarget(source);
                     ChatSystemMsg msg = ChatManager.CombatInfo(source, awo);
                     DispatchMessage.sendToAllInRange(source, msg);
-                    ((Mob)awo).refresh();
+                    //((Mob)awo).refresh();
                 }
             }
             if (awo != null && awo.getObjectType() == GameObjectType.Mob) {

src/engine/powers/poweractions/PeekPowerAction.java

@@ -106,7 +106,7 @@ public class PeekPowerAction extends AbstractPowerAction {
             if (!tar.isAlive())
                 return;
 
-            lwrm = new LootWindowResponseMsg(tar.getObjectType().ordinal(), tar.getObjectUUID(), tar.getInventory(true));
+            lwrm = new LootWindowResponseMsg(tar.getObjectType().ordinal(), tar.getObjectUUID(), tar.getInventory(false));
         } else if (awo.getObjectType().equals(Enum.GameObjectType.Mob)) {
 
             Mob tar = (Mob) awo;

src/engine/powers/poweractions/StealPowerAction.java

@@ -89,6 +89,8 @@ public class StealPowerAction extends AbstractPowerAction {
         if (!sourcePlayer.isAlive())
             return;
 
+        sourcePlayer.cancelOnAttackSwing();
+
         //prevent stealing no steal mob loot
         if (awo instanceof MobLoot && ((MobLoot) awo).noSteal())
             return;
@@ -173,8 +175,21 @@ public class StealPowerAction extends AbstractPowerAction {
 
         if (tar.getItemBase().getType().equals(ItemType.GOLD)) {
             //stealing gold
-            if (!myCIM.transferGoldToMyInventory((AbstractCharacter) owner, amount))
+            //if (!myCIM.transferGoldToMyInventory((AbstractCharacter) owner, amount))
+            //    return;
+
+            int targetGold = ownerCIM.getGoldInventory().getNumOfItems();
+            int myGold = myCIM.getGoldInventory().getNumOfItems();
+            if(myGold + amount > 10000000)
                 return;
+
+            ownerCIM.getGoldInventory().setNumOfItems(targetGold - amount);
+            ownerCIM.updateInventory();
+
+            myCIM.addGoldToInventory(amount,false);
+            myCIM.updateInventory();
+
+
         } else {
             //stealing items
             if (ownerCIM.lootItemFromMe(tar, sourcePlayer, origin, true, amount) == null)
@@ -187,8 +202,9 @@ public class StealPowerAction extends AbstractPowerAction {
         DispatchMessage.dispatchMsgDispatch(dispatch, engine.Enum.DispatchChannel.SECONDARY);
 
         //update thief's inventory
-        if (sourcePlayer.getCharItemManager() != null)
+        if (sourcePlayer.getCharItemManager() != null) {
             sourcePlayer.getCharItemManager().updateInventory();
+        }
 
         //update victims inventory
         if (owner.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {

src/engine/server/MBServerStatics.java

@@ -312,10 +312,10 @@ public class MBServerStatics {
     public static final float HEALTH_REGEN_SWIM_NOSTAMINA_STATIC = 0f; // 100%
     // weapon
     public static final float MANA_REGEN_STATIC = 0.16666666666666666666666666666667f;
-    public static final float MANA_REGEN_SIT = 0.008333333f; // 100% in 2
-    public static final float MANA_REGEN_IDLE = 0.00166667f; // 100% in 10
-    public static final float MANA_REGEN_WALK = 0.00125f; // 100% in 13.333
-    public static final float MANA_REGEN_RUN = 0f;
+    public static final float MANA_REGEN_SIT = 0.8333333f; // 1% every 1.2 seconds
+    public static final float MANA_REGEN_IDLE = 0.1666667f; // 1% every 6 seconds
+    public static final float MANA_REGEN_WALK = 0.125f; // 1% every 8 seconds
+    public static final float MANA_REGEN_RUN = 0.0f; // No regeneration while running
     public static final float STAMINA_REGEN_SIT = 2f; // 2 per second
     public static final float STAMINA_REGEN_IDLE = 0.2f; // 1 per 5 seconds
     public static final float STAMINA_REGEN_WALK = 0f;
@@ -326,7 +326,7 @@ public class MBServerStatics {
     public static final int REGEN_SENSITIVITY_MOB = 1000; // calc regen ever X
     public static final int TOMBSTONE = 2024;
     public static final int LOGOUT_TIMER_MS = 1000; // logout delay applied
-    public static final int CORPSE_CLEANUP_TIMER_MS = 15 * 60 * 1000; // Cleanup
+    public static final int CORPSE_CLEANUP_TIMER_MS = 10 * 60 * 1000; // Cleanup
     public static final int DEFAULT_SPAWN_TIME_MS = 3 * 60 * 1000; // 3 minute
     public static final int SESSION_CLEANUP_TIMER_MS = 30 * 1000; // cleanup
     public static final int MOVEMENT_FREQUENCY_MS = 1000; // Update movement

src/engine/server/login/LoginServer.java

@@ -450,7 +450,7 @@ public class LoginServer {
                 objectUUID = rs.getInt("UID");
                 objectType = rs.getString("type");
 
-                Logger.info("INVALIDATED : " + objectType + " UUID: " + objectUUID);
+                //Logger.info("INVALIDATED : " + objectType + " UUID: " + objectUUID);
 
                 switch (objectType) {
 
@@ -462,7 +462,7 @@ public class LoginServer {
                         PlayerCharacter player = (PlayerCharacter) DbManager.getObject(Enum.GameObjectType.PlayerCharacter, objectUUID);
                         PlayerCharacter.initializePlayer(player);
                         player.getAccount().characterMap.replace(player.getObjectUUID(), player);
-                        Logger.info("Player active state is : " + player.isActive());
+                        //Logger.info("Player active state is : " + player.isActive());
                         break;
                 }
 

src/engine/server/world/WorldServer.java

@@ -513,9 +513,53 @@ public class WorldServer {
 
 		Logger.info("Running garbage collection...");
 		System.gc();
+
+		Logger.info("Starting Bane Thread");
+		BaneThread.startBaneThread();
+
+		Logger.info("Starting Player Regen Thread");
+		UpdateThread.startUpdateThread();
+
+
+		printThreads();
+		Logger.info("Threads Running:");
+
 		return true;
 	}
 
+	public static void printThreads() {
+		// Get the root thread group
+		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
+		Logger.info("Total threads in application: " + threads.length + " / " + availableThreads + " Total Threads On Machine");
+		if(threads.length > (int)(availableThreads * 0.75f)){
+			Logger.error("WARNING! Too many threads are being used, hardware update recommended");
+		}
+
+		// Optionally, list the thread names
+		Logger.info("Active threads:");
+		for (Thread thread : threads) {
+			if (thread != null) {
+				Logger.info(thread.getName());
+			}
+		}
+	}
+
 	protected boolean initDatabaselayer() {
 
 		// Try starting a GOM <-> DB connection.

src/engine/workthreads/BaneThread.java

@@ -0,0 +1,79 @@
+// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
+// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
+// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
+// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
+// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
+//      Magicbane Emulator Project © 2013 - 2022
+//                www.magicbane.com
+
+
+package engine.workthreads;
+
+import engine.Enum;
+import engine.InterestManagement.WorldGrid;
+import engine.db.archive.DataWarehouse;
+import engine.db.archive.MineRecord;
+import engine.gameManager.BuildingManager;
+import engine.gameManager.ChatManager;
+import engine.gameManager.StrongholdManager;
+import engine.mobileAI.Threads.MobAIThread;
+import engine.net.DispatchMessage;
+import engine.net.client.msg.chat.ChatSystemMsg;
+import engine.objects.*;
+import org.pmw.tinylog.Logger;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+
+public class BaneThread implements Runnable {
+
+    private volatile Long lastRun;
+    public static final Long instancedelay = 1000L;
+    public BaneThread() {
+        Logger.info(" BaneThread thread has started!");
+    }
+
+
+    public void processBanesWindow() {
+
+        try {
+            synchronized (Bane.banes) {
+                for (int baneId : Bane.banes.keySet()) {
+                    Bane bane = Bane.banes.get(baneId);
+                    if (bane != null && bane.getSiegePhase().equals(Enum.SiegePhase.WAR)) {
+                        bane.applyZergBuffs();
+                    }
+                }
+            }
+        } catch (Exception e) {
+            Logger.error("BANE ERROR",e);
+        }
+
+
+    }
+
+    public void run() {
+        lastRun = System.currentTimeMillis();
+        while (true) {
+            if (System.currentTimeMillis() >= lastRun + instancedelay) { // Correct condition
+                this.processBanesWindow();
+                lastRun = System.currentTimeMillis(); // Update lastRun after processing
+            }else {
+                try {
+                    Thread.sleep(100); // Pause for 100ms to reduce CPU usage
+                } catch (InterruptedException e) {
+                    Logger.error("Thread interrupted", e);
+                    Thread.currentThread().interrupt();
+                }
+            }
+        }
+    }
+
+
+    public static void startBaneThread() {
+        Thread baneThread;
+        baneThread = new Thread(new BaneThread());
+        baneThread.setName("baneThread");
+        baneThread.start();
+    }
+}

src/engine/workthreads/HourlyJobThread.java

@@ -88,5 +88,11 @@ public class HourlyJobThread implements Runnable {
         Logger.info(SimulationManager.getPopulationString());
         Logger.info(MessageDispatcher.getNetstatString());
         Logger.info(PurgeOprhans.recordsDeleted.toString() + "orphaned items deleted");
+
+        for (Bane bane : Bane.banes.values()){
+            if(bane.getSiegePhase().equals(Enum.SiegePhase.CHALLENGE)){
+                bane.setDefaultTime();
+            }
+        }
     }
 }

src/engine/workthreads/UpdateThread.java

@@ -0,0 +1,80 @@
+// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
+// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
+// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
+// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
+// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
+//      Magicbane Emulator Project © 2013 - 2022
+//                www.magicbane.com
+
+
+package engine.workthreads;
+
+import engine.Enum;
+import engine.gameManager.SessionManager;
+import engine.gameManager.SimulationManager;
+import engine.objects.Bane;
+import engine.objects.PlayerCharacter;
+import engine.objects.PlayerCombatStats;
+import org.pmw.tinylog.Logger;
+
+public class UpdateThread implements Runnable {
+
+    private volatile Long lastRun;
+
+    public static final Long instancedelay = 1000L;
+    public UpdateThread() {
+        Logger.info(" UpdateThread thread has started!");
+    }
+
+
+    public void processPlayerUpdate() {
+
+        try {
+            for(PlayerCharacter player : SessionManager.getAllActivePlayerCharacters()){
+                if (player != null) {
+                    player.doRegen();
+                    try {
+                        if (player.isAlive() && player.isActive() && player.isEnteredWorld()) {
+                            if (player.combatStats == null) {
+                                player.combatStats = new PlayerCombatStats(player);
+                            }
+                            PlayerCombatStats cStats = player.combatStats;
+                            cStats.update();
+                        }
+                    }catch(Exception e){
+
+                    }
+                }
+            }
+        } catch (Exception e) {
+            Logger.error("UPDATE ERROR",e);
+        }
+
+
+    }
+
+    public void run() {
+        lastRun = System.currentTimeMillis();
+        while (true) {
+            if (System.currentTimeMillis() >= lastRun + instancedelay) { // Correct condition
+                this.processPlayerUpdate();
+                lastRun = System.currentTimeMillis(); // Update lastRun after processing
+            }else {
+                try {
+                    Thread.sleep(100); // Pause for 10ms to reduce CPU usage
+                } catch (InterruptedException e) {
+                    Logger.error("Thread interrupted", e);
+                    Thread.currentThread().interrupt();
+                }
+            }
+        }
+    }
+
+
+    public static void startUpdateThread() {
+        Thread updateThread;
+        updateThread = new Thread(new UpdateThread());
+        updateThread.setName("updateThread");
+        updateThread.start();
+    }
+}