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.*;
-import engine.objects.ItemBase;
-import engine.objects.Shrine;
-import engine.objects.Zone;
 import engine.powers.EffectsBase;
 import org.pmw.tinylog.Logger;
 
@@ -139,8 +137,8 @@ public class Enum {
         HALFGIANTMALE(2010, MonsterType.HalfGiant, RunSpeed.STANDARD, CharacterSex.MALE, 1.15f),
         HUMANMALE(2011, MonsterType.Human, RunSpeed.STANDARD, CharacterSex.MALE, 1),
         HUMANFEMALE(2012, MonsterType.Human, RunSpeed.STANDARD, CharacterSex.FEMALE, 1),
-        IREKEIMALE(2013, MonsterType.Irekei, RunSpeed.STANDARD, CharacterSex.MALE, 1.1f),
+        IREKEIMALE(2013, MonsterType.Irekei, RunSpeed.IREKEI, CharacterSex.MALE, 1.1f),
-        IREKEIFEMALE(2014, MonsterType.Irekei, RunSpeed.STANDARD, CharacterSex.FEMALE, 1.1f),
+        IREKEIFEMALE(2014, MonsterType.Irekei, RunSpeed.IREKEI, CharacterSex.FEMALE, 1.1f),
         SHADEMALE(2015, MonsterType.Shade, RunSpeed.STANDARD, CharacterSex.MALE, 1),
         SHADEFEMALE(2016, MonsterType.Shade, RunSpeed.STANDARD, CharacterSex.FEMALE, 1),
         MINOMALE(2017, MonsterType.Minotaur, RunSpeed.MINOTAUR, CharacterSex.MALE, 1.3f),
@@ -172,6 +170,8 @@ public class Enum {
         }
 
         public static RaceType getRaceTypebyRuneID(int runeID) {
+            if(runeID == 1999)
+                return _raceTypeByID.get(2017);
             return _raceTypeByID.get(runeID);
         }
 
@@ -208,8 +208,8 @@ public class Enum {
         SENTINEL(0, 0, 0, 0, 0, 0, 0),
         STANDARD(6.1900001f, 13.97f, 4.2199998f, 13.97f, 6.3299999f, 18.379999f, 6.5f),
         CENTAUR(6.1900001f, 16.940001f, 5.5500002f, 16.940001f, 6.3299999f, 18.379999f, 6.5f),
-        MINOTAUR(6.6300001f, 15.95f, 4.2199998f, 15.95f, 6.3299999f, 18.379999f, 6.5f);
+        MINOTAUR(6.6300001f, 15.95f, 4.2199998f, 15.95f, 6.3299999f, 18.379999f, 6.5f),
-
+        IREKEI(6.499500105f, 14.6685f, 4.2199998f, 14.6685f, 6.3299999f, 18.379999f, 6.5f);
         private float walkStandard;
         private float walkCombat;
         private float runStandard;
@@ -469,11 +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
+                }else {
-                    spawnLocation = Vector3fImmutable.getRandomPointOnCircle(ruinZone.getLoc()
+                    //spawnLocation = Vector3fImmutable.getRandomPointOnCircle(ruinZone.getLoc()
-                            .add(new Vector3fImmutable(-196.016f, 2.812f, 203.621f)), 30);
+                    //.add(new Vector3fImmutable(-196.016f, 2.812f, 203.621f)), 30);
+                        spawnLocation = Vector3fImmutable.getRandomPointOnCircle(BuildingManager.getBuilding(27977).loc,30f);
+
+                }
             }
 
 
@@ -776,6 +779,7 @@ public class Enum {
         Combat,
         Spires,
         Snare,
+        Snared,
         Stun,
         Blind,
         Root,
@@ -878,6 +882,7 @@ public class Enum {
         Siege,
         Slash,
         Snare,
+        Snared,
         Sorcery,
         Spear,
         SpearMastery,
@@ -957,6 +962,17 @@ public class Enum {
         Wizardry;
 
         public static SourceType GetSourceType(String modName) {
+            switch(modName){
+                case "Slashing":
+                    modName = "Slash";
+                    break;
+                case "Crushing":
+                    modName = "Crush";
+                    break;
+                case "Piercing":
+                    modName = "Pierce";
+                    break;
+            }
             SourceType returnMod;
             if (modName.isEmpty())
                 return SourceType.None;
@@ -1016,6 +1032,7 @@ public class Enum {
         Silence,
         Slash,
         Snare,
+        Snared,
         Stance,
         Stun,
         Summon,
@@ -1140,6 +1157,7 @@ public class Enum {
         SkillDebuff,
         SlashResistanceDebuff,
         Snare,
+        Snared,
         StackableAttrCONBuff,
         StackableAttrDEXBuff,
         StackableAttrSTRBuff,
@@ -2306,9 +2324,9 @@ public class Enum {
 
     public enum CityBoundsType {
 
-        GRID(640),
+        GRID(544),
-        ZONE(875),
+        ZONE(672),
-        PLACEMENT(876);
+        PLACEMENT(673);
 
         public final float extents;
 

src/engine/InterestManagement/InterestManager.java

@@ -19,10 +19,7 @@ import engine.net.AbstractNetMsg;
 import engine.net.Dispatch;
 import engine.net.DispatchMessage;
 import engine.net.client.ClientConnection;
-import engine.net.client.msg.LoadCharacterMsg;
+import engine.net.client.msg.*;
-import engine.net.client.msg.LoadStructureMsg;
-import engine.net.client.msg.MoveToPointMsg;
-import engine.net.client.msg.UnloadObjectsMsg;
 import engine.objects.*;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
@@ -521,10 +518,10 @@ public enum InterestManager implements Runnable {
 
         // Update loaded upbjects lists
 
+        player.isBoxed = PlayerCharacter.checkIfBoxed(player);
         player.setDirtyLoad(true);
         updateStaticList(player, origin);
         updateMobileList(player, origin);
-
     }
 
     public synchronized void HandleLoadForTeleport(PlayerCharacter playerCharacter) {

src/engine/db/handlers/dbBaneHandler.java

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

src/engine/db/handlers/dbCityHandler.java

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

src/engine/db/handlers/dbContractHandler.java

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

src/engine/db/handlers/dbHandlerBase.java

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

src/engine/db/handlers/dbItemBaseHandler.java

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

src/engine/db/handlers/dbNPCHandler.java

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

src/engine/devcmd/cmds/AddNPCCmd.java

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

src/engine/devcmd/cmds/GimmeCmd.java

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

src/engine/devcmd/cmds/HotzoneCmd.java

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

src/engine/devcmd/cmds/InfoCmd.java

@@ -15,9 +15,13 @@ import engine.Enum.GameObjectType;
 import engine.Enum.TargetColor;
 import engine.devcmd.AbstractDevCmd;
 import engine.gameManager.BuildingManager;
+import engine.gameManager.PowersManager;
 import engine.gameManager.SessionManager;
 import engine.math.Vector3fImmutable;
 import engine.objects.*;
+import engine.powers.EffectsBase;
+import engine.powers.PowersBase;
+import engine.server.MBServerStatics;
 import engine.util.StringUtils;
 
 import java.text.DecimalFormat;
@@ -337,7 +341,9 @@ public class InfoCmd extends AbstractDevCmd {
                 output += "Swimming : " + targetPC.isSwimming();
                 output += newline;
                 output += "isMoving : " + targetPC.isMoving();
-
+                output += newline;
+                output += "Zerg Multiplier : " + targetPC.ZergMultiplier+ newline;
+                output += "Hidden : " + targetPC.getHidden();
                 break;
 
             case NPC:
@@ -492,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){
+                output += "Damage: " + targetMob.mobBase.getDamageMin() + " - " + targetMob.mobBase.getDamageMax() + newline;
-                    max = 321;
+                output += "ATR: " + targetMob.mobBase.getAttackRating() + newline;
+                output += "DEF: " + targetMob.defenseRating + newline;
+                output += "RANGE: " + targetMob.getRange() + newline;
+                output += "Effects:" + newline;
+                for(MobBaseEffects mbe : targetMob.mobBase.mobbaseEffects){
+                    EffectsBase eb = PowersManager.getEffectByToken(mbe.getToken());
+                    output += eb.getName() + newline;
                 }
-                int min = (int)(4.469 * targetMob.level - 3.469);
-                output += "Min Loot Roll = " + min;
-                output += "Max Loot Roll = " + max;
                 break;
             case Item:  //intentional passthrough
             case MobLoot:
@@ -529,6 +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/MineActiveCmd.java

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

src/engine/devcmd/cmds/PrintStatsCmd.java

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

src/engine/devcmd/cmds/SetLevelCmd.java

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

src/engine/devcmd/cmds/SimulateBootyCmd.java

@@ -10,6 +10,8 @@ import java.util.ArrayList;
 import java.util.concurrent.ThreadLocalRandom;
 
 public class SimulateBootyCmd extends AbstractDevCmd {
+
+    public int simCount = 250;
     public SimulateBootyCmd() {
         super("bootysim");
     }
@@ -25,7 +27,15 @@ public class SimulateBootyCmd extends AbstractDevCmd {
 
         String output;
 
-        output = "Booty Simulation:" + newline;
+        try
+        {
+            simCount = Integer.parseInt(words[0]);
+        }catch(Exception e)
+        {
+
+        }
+
+        output = "Booty Simulation: Rolls:" + simCount + newline;
 
         Mob mob = (Mob) target;
         output += "Name: " + mob.getName() + newline;
@@ -44,6 +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>();
@@ -51,14 +62,17 @@ public class SimulateBootyCmd extends AbstractDevCmd {
         int failures = 0;
         int goldAmount = 0;
 
-        for (int i = 0; i < 100; ++i) {
+        for (int i = 0; i < simCount; ++i) {
 
             try {
                 mob.loadInventory();
                 for (Item lootItem : mob.getCharItemManager().getInventory()) {
                     switch (lootItem.getItemBase().getType()) {
                         case CONTRACT: //CONTRACT
-                            Contracts.add(lootItem);
+                            if(lootItem.getName().contains("Captain"))
+                                GuardContracts.add(lootItem);
+                            else
+                                Contracts.add(lootItem);
                             break;
                         case OFFERING: //OFFERING
                             Offerings.add(lootItem);
@@ -130,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)
@@ -520,7 +532,30 @@ public enum BuildingManager {
         if (building.getBlueprintUUID() == 0)
             return false;
 
-        if (building.getBlueprint().getMaxSlots() == building.getHirelings().size())
+        if(building.getBlueprint().getBuildingGroup().equals(BuildingGroup.TOL)){
+            if(contract.getContractID() == 850) {
+                boolean hasRunemaster = false;
+                for (AbstractCharacter npc : building.getHirelings().keySet()) {
+
+                    if (npc.getObjectType() != GameObjectType.NPC)
+                        continue;
+
+                    if(npc.contractUUID == 850)
+                        hasRunemaster = true;
+                }
+
+                if(hasRunemaster)
+                    return false;
+            }
+        }
+
+
+        int maxSlots = building.getBlueprint().getMaxSlots();
+        if(building.getBlueprint().getBuildingGroup() != null) {
+            maxSlots = building.getBlueprint().getSlotsForRank(building.getRank());
+        }
+
+        if (maxSlots == building.getHirelings().size())
             return false;
 
         String pirateName = NPCManager.getPirateName(contract.getMobbaseID());

src/engine/gameManager/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
+                        if (weapon != null && weapon.getBonusPercent(ModType.WeaponSpeed, SourceType.None) != 0f) //add weapon speed bonus
-                        wepSpeed *= (1 + weapon.getBonus(ModType.WeaponSpeed, SourceType.None));
+                            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)
+                        if (abstractCharacter.getBonuses() != null && abstractCharacter.getBonuses().getFloatPercentAll(ModType.AttackDelay, SourceType.None) != 0f) //add effects speed bonus
-                        wepSpeed = 10; //Old was 10, but it can be reached lower with legit buffs,effects.
+                            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(ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
-            if (mainHand) {
+                PlayerCharacter pc = (PlayerCharacter) ac;
-                atr = ac.getAtrHandOne();
+                if (mainHand) {
-                minDamage = ac.getMinDamageHandOne();
+                    atr = pc.combatStats.atrHandOne;
-                maxDamage = ac.getMaxDamageHandOne();
+                    minDamage = pc.combatStats.minDamageHandOne;
-            } else {
+                    maxDamage = pc.combatStats.maxDamageHandOne;
-                atr = ac.getAtrHandTwo();
+                } else {
-                minDamage = ac.getMinDamageHandTwo();
+                    atr = pc.combatStats.atrHandTwo;
-                maxDamage = ac.getMaxDamageHandTwo();
+                    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
             }
 
@@ -646,24 +670,24 @@ public enum CombatManager {
 
             //Get hit chance
 
-            int chance;
+            //int chance;
             float dif = atr - defense;
 
-            if (dif > 100)
+            //if (dif > 100)
-                chance = 94;
+            //    chance = 94;
-            else if (dif < -100)
+            //else if (dif < -100)
-                chance = 4;
+            //    chance = 4;
-            else
+            //else
-                chance = (int) ((0.45 * dif) + 49);
+            //    chance = (int) ((0.45 * dif) + 49);
 
             errorTrack = 5;
 
             //calculate hit/miss
 
-            int roll = ThreadLocalRandom.current().nextInt(100);
             DeferredPowerJob dpj = null;
 
-            if (roll < chance) {
+            boolean hitLanded = LandHit((int)atr,(int)defense);
+            if (hitLanded) {
 
                 if (ac.getObjectType().equals(GameObjectType.PlayerCharacter))
                     updateAttackTimers((PlayerCharacter) ac, target, true);
@@ -692,7 +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);
@@ -707,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);
+                        }
                     }
                 }
 
@@ -866,27 +902,18 @@ public enum CombatManager {
 
                 if (weapon != null && tarAc != null && tarAc.isAlive()) {
 
-                    ConcurrentHashMap<String, Effect> effects = weapon.getEffects();
+                    if(weapon.effects != null){
-
+                        for (Effect eff : weapon.effects.values()){
-                    for (Effect eff : effects.values()) {
+                            for(AbstractEffectModifier mod : eff.getEffectModifiers()){
-                        if (eff == null)
+                                if(mod.modType.equals(ModType.WeaponProc)){
-                            continue;
-
-                        HashSet<AbstractEffectModifier> aems = eff.getEffectModifiers();
-
-                        if (aems != null) {
-                            for (AbstractEffectModifier aem : aems) {
-
-                                if (!tarAc.isAlive())
-                                    break;
-
-                                if (aem instanceof WeaponProcEffectModifier) {
-
                                     int procChance = ThreadLocalRandom.current().nextInt(100);
-
+                                    if (procChance < MBServerStatics.PROC_CHANCE) {
-                                    if (procChance < MBServerStatics.PROC_CHANCE)
+                                        try {
-                                        ((WeaponProcEffectModifier) aem).applyProc(ac, target);
+                                            ((WeaponProcEffectModifier) mod).applyProc(ac, target);
-
+                                        }catch(Exception e){
+                                            Logger.error(eff.getName() + " Failed To Cast Proc");
+                                        }
+                                    }
                                 }
                             }
                         }
@@ -915,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);
                     }
@@ -1054,6 +1087,10 @@ public enum CombatManager {
                 if (eff.getPower() != null && (eff.getPower().getToken() == 429506943 || eff.getPower().getToken() == 429408639 || eff.getPower().getToken() == 429513599 || eff.getPower().getToken() == 429415295))
                     swingAnimation = 0;
 
+        if(source != null && source.getObjectType().equals(GameObjectType.PlayerCharacter)){
+            damage *= ((PlayerCharacter)source).ZergMultiplier;
+        } // Health modifications are modified by the ZergMechanic
+
         TargetedActionMsg cmm = new TargetedActionMsg(source, target, damage, swingAnimation);
         DispatchMessage.sendToAllInRange(target, cmm);
     }
@@ -1237,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);
@@ -1322,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);
+                    }
+                }
+            }
 
         }
     }
@@ -1438,4 +1485,30 @@ public enum CombatManager {
             ((AbstractCharacter) awo).getCharItemManager().damageRandomArmor(1);
     }
 
+    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);
+
+        if(roll <= 5)//always 5% chance to miss
+            return false;
+
+        if(roll >= 95)//always 5% chance to hit
+            return true;
+
+        return roll <= convertedChance;
+    }
+
+    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

@@ -79,7 +79,6 @@ public enum DevCmdManager {
         DevCmdManager.registerDevCmd(new AddGoldCmd());
         DevCmdManager.registerDevCmd(new ZoneInfoCmd());
         DevCmdManager.registerDevCmd(new DebugMeleeSyncCmd());
-        DevCmdManager.registerDevCmd(new HotzoneCmd());
         DevCmdManager.registerDevCmd(new MineActiveCmd());
         // Dev
         DevCmdManager.registerDevCmd(new ApplyStatModCmd());
@@ -103,6 +102,7 @@ public enum DevCmdManager {
         DevCmdManager.registerDevCmd(new SetAdminRuneCmd());
         DevCmdManager.registerDevCmd(new SetInvulCmd());
         DevCmdManager.registerDevCmd(new MakeItemCmd());
+        DevCmdManager.registerDevCmd(new GimmeCmd());
         DevCmdManager.registerDevCmd(new EnchantCmd());
         DevCmdManager.registerDevCmd(new SetSubRaceCmd());
         // Admin
@@ -179,8 +179,37 @@ 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;
-        if (a.status.equals(Enum.AccountStatus.ADMIN) == false) {
+        if(ConfigManager.MB_WORLD_TESTMODE.getValue().equals("true")) {
+            switch (adc.getMainCmdString()) {
+                case "printresists":
+                case "printstats":
+                case "printskills":
+                case "printpowers":
+                case "gimme":
+                case "goto":
+                case "teleportmode":
+                case "printbonuses":
+                    playerAllowed = true;
+                    if (!a.status.equals(Enum.AccountStatus.ADMIN))
+                        target = pcSender;
+                    break;
+            }
+        }else{
+            switch (adc.getMainCmdString()) {
+                case "printresists":
+                case "printstats":
+                case "printskills":
+                case "printpowers":
+                case "printbonuses":
+                case "gimme":
+                    playerAllowed = true;
+                    if (!a.status.equals(Enum.AccountStatus.ADMIN))
+                        target = pcSender;
+                    break;
+            }
+        }
+        if (!playerAllowed && !a.status.equals(Enum.AccountStatus.ADMIN)) {
             Logger.info("Account " + a.getUname() + "attempted to use dev command " + cmd);
             return false;
         }

src/engine/gameManager/LootManager.java

@@ -17,7 +17,9 @@ import engine.objects.*;
 import org.pmw.tinylog.Logger;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 import java.util.concurrent.ThreadLocalRandom;
 
 /**
@@ -34,6 +36,12 @@ public enum LootManager {
     public static HashMap<Integer, ArrayList<ModTableEntry>> _modTables = new HashMap<>();
     public static HashMap<Integer, ArrayList<ModTypeTableEntry>> _modTypeTables = new HashMap<>();
 
+    public static final ArrayList<Integer> vorg_ha_uuids = new ArrayList<>(Arrays.asList(27580, 27590, 188500, 188510, 188520, 188530, 188540, 188550, 189510));
+    public static final ArrayList<Integer> vorg_ma_uuids = new ArrayList<>(Arrays.asList(27570,188900,188910,188920,188930,188940,188950,189500));
+    public static final ArrayList<Integer> vorg_la_uuids = new ArrayList<>(Arrays.asList(27550,27560,189100,189110,189120,189130,189140,189150));
+    public static final ArrayList<Integer> vorg_cloth_uuids = new ArrayList<>(Arrays.asList(27600,188700,188720,189550,189560));
+    public static final ArrayList<Integer> racial_guard_uuids = new ArrayList<>(Arrays.asList(841,951,952,1050,1052,1180,1182,1250,1252,1350,1352,1450,1452,1500,1502,1525,1527,1550,1552,1575,1577,1600,1602,1650,1652,1700,980100,980102));
+
     // Drop Rates
 
     public static float NORMAL_DROP_RATE;
@@ -68,49 +76,128 @@ public enum LootManager {
 
     public static void GenerateMobLoot(Mob mob) {
 
+        if(mob == null){
+            return;
+        }
+
         //determine if mob is in hotzone
-        boolean inHotzone = ZoneManager.inHotZone(mob.getLoc());
+        boolean inHotzone = false;
 
         //iterate the booty sets
 
-        if (mob.getMobBase().bootySet != 0 && _bootySetMap.containsKey(mob.getMobBase().bootySet) == true)
+        if(mob.mobBase == null || mob.getMobBaseID() == 253003){
+            int i = 0;
+        }
+
+        if (mob.getMobBase().bootySet != 0 && _bootySetMap.containsKey(mob.getMobBase().bootySet))
             RunBootySet(_bootySetMap.get(mob.getMobBase().bootySet), mob, inHotzone);
 
-        if (mob.bootySet != 0 && _bootySetMap.containsKey(mob.bootySet) == true)
+        if (mob.bootySet != 0 && _bootySetMap.containsKey(mob.bootySet)) {
             RunBootySet(_bootySetMap.get(mob.bootySet), mob, inHotzone);
+        }else if(mob.bootySet != 0 && ItemBase.getItemBase(mob.bootySet) != null){
+            MobLoot specialDrop = null;
+            specialDrop = new MobLoot(mob,ItemBase.getItemBase(mob.bootySet),true);
+            if(specialDrop != null) {
+                ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + mob.getParentZone().getName() + " has found the " + specialDrop.getName() + ". Are you tough enough to take it?");
+                chatMsg.setMessageType(10);
+                chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+                DispatchMessage.dispatchMsgToAll(chatMsg);
+                mob.getCharItemManager().addItemToInventory(specialDrop);
+                mob.setResists(new Resists("Dropper"));
+                if(!Mob.discDroppers.contains(mob))
+                    Mob.AddDiscDropper(mob);
+            }
 
-        //lastly, check mobs inventory for godly or disc runes to send a server announcement
+        }
-            for (Item it : mob.getInventory()) {
 
-                ItemBase ib = it.getItemBase();
+        //lastly, check mobs inventory for godly or disc runes to send a server announcement
-                if(ib == null)
+        for (Item it : mob.getInventory()) {
-                    break;
+
-                if (ib.isDiscRune() || ib.getName().toLowerCase().contains("of the gods")) {
+            ItemBase ib = it.getItemBase();
-                    ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + mob.getParentZone().getName() + " has found the " + ib.getName() + ". Are you tough enough to take it?");
+            if (ib == null)
-                    chatMsg.setMessageType(10);
+                break;
-                    chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+            if (ib.isDiscRune() || ib.getName().toLowerCase().contains("of the gods")) {
-                    DispatchMessage.dispatchMsgToAll(chatMsg);
+                ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + mob.getParentZone().getName() + " has found the " + ib.getName() + ". Are you tough enough to take it?");
-                }
+                chatMsg.setMessageType(10);
+                chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+                DispatchMessage.dispatchMsgToAll(chatMsg);
             }
+        }
 
     }
 
     private static void RunBootySet(ArrayList<BootySetEntry> entries, Mob mob, boolean inHotzone) {
 
         boolean hotzoneWasRan = false;
-        float dropRate = 1.0f;
+        float dropRate;
+
+        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));
+            }
 
-        // Iterate all entries in this bootySet and process accordingly
+            // 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);
+                    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 (zone != null && zone.getSafeZone() == (byte)1)
+                        return; // no loot to drop in safezones
 
-                    if (mob.getSafeZone() == false)
+                    dropRate = LootManager.NORMAL_DROP_RATE;
-                        dropRate = LootManager.NORMAL_DROP_RATE;
 
                     if (inHotzone == true)
                         dropRate = LootManager.HOTZONE_DROP_RATE;
@@ -135,6 +222,109 @@ public enum LootManager {
         }
     }
 
+    public static void SpecialCaseContractDrop(Mob mob,ArrayList<BootySetEntry> entries){
+
+        int lootTableID = 0;
+        for(BootySetEntry entry : entries){
+            if(entry.bootyType.equals("LOOT")){
+                lootTableID = entry.genTable;
+                break;
+            }
+        }
+
+        if(lootTableID == 0)
+            return;
+
+        int ContractTableID = 0;
+        for(GenTableEntry entry : _genTables.get(lootTableID)){
+            try {
+                if (ItemBase.getItemBase(_itemTables.get(entry.itemTableID).get(0).cacheID).getType().equals(Enum.ItemType.CONTRACT)) {
+                    ContractTableID = entry.itemTableID;
+                    break;
+                }
+            }catch(Exception e){
+
+            }
+        }
+
+        if(ContractTableID == 0)
+            return;
+
+        ItemBase ib = ItemBase.getItemBase(rollRandomItem(ContractTableID));
+        if(ib != null){
+            MobLoot toAdd = new MobLoot(mob,ib,false);
+            mob.getCharItemManager().addItemToInventory(toAdd);
+        }
+    }
+
+    public static void SpecialCaseRuneDrop(Mob mob,ArrayList<BootySetEntry> entries){
+        int lootTableID = 0;
+        for(BootySetEntry entry : entries){
+            if(entry.bootyType.equals("LOOT")){
+                lootTableID = entry.genTable;
+                break;
+            }
+        }
+
+        if(lootTableID == 0)
+            return;
+
+        int RuneTableID = 0;
+        for(GenTableEntry entry : _genTables.get(lootTableID)){
+            try {
+                if (ItemBase.getItemBase(_itemTables.get(entry.itemTableID).get(0).cacheID).getType().equals(Enum.ItemType.RUNE)) {
+                    RuneTableID = entry.itemTableID;
+                    break;
+                }
+            }catch(Exception e){
+
+            }
+        }
+
+        if(RuneTableID == 0)
+            return;
+
+        ItemBase ib = ItemBase.getItemBase(rollRandomItem(RuneTableID));
+        if(ib != null){
+            MobLoot toAdd = new MobLoot(mob,ib,false);
+            mob.getCharItemManager().addItemToInventory(toAdd);
+        }
+    }
+
+    public static void SpecialCaseResourceDrop(Mob mob,ArrayList<BootySetEntry> entries){
+        int lootTableID = 0;
+        for(BootySetEntry entry : entries){
+            if(entry.bootyType.equals("LOOT")){
+                lootTableID = entry.genTable;
+                break;
+            }
+        }
+
+        if(lootTableID == 0)
+            return;
+
+        int ResourceTableID = 0;
+        for(GenTableEntry entry : _genTables.get(lootTableID)){
+            try {
+                if (ItemBase.getItemBase(_itemTables.get(entry.itemTableID).get(0).cacheID).getType().equals(Enum.ItemType.RESOURCE)) {
+                    ResourceTableID = entry.itemTableID;
+                    break;
+                }
+            }catch(Exception e){
+
+            }
+        }
+
+        if(ResourceTableID == 0)
+            return;
+
+        ItemBase ib = ItemBase.getItemBase(rollRandomItem(ResourceTableID));
+        if(ib != null){
+            MobLoot toAdd = new MobLoot(mob,ib,false);
+            mob.getCharItemManager().addItemToInventory(toAdd);
+        }
+    }
+
     public static MobLoot getGenTableItem(int genTableID, AbstractCharacter mob, Boolean inHotzone) {
 
         if (mob == null || _genTables.containsKey(genTableID) == false)
@@ -156,11 +346,10 @@ public enum LootManager {
 
         //gets the 1-320 roll for this mob
         int itemTableRoll = 0;
-        int objectType = mob.getObjectType().ordinal();
         if(mob.getObjectType().ordinal() == 52) { //52 = player character
             itemTableRoll = ThreadLocalRandom.current().nextInt(1,320 + 1);
         } else{
-            itemTableRoll = TableRoll(mob.level, inHotzone);
+            itemTableRoll = TableRoll(mob.level);
         }
         ItemTableEntry tableRow = ItemTableEntry.rollTable(itemTableId, itemTableRoll);
         if (tableRow == null)
@@ -172,13 +361,23 @@ public enum LootManager {
             return null;
 
         if (ItemBase.getItemBase(itemUUID).getType().ordinal() == Enum.ItemType.RESOURCE.ordinal()) {
+            if(ThreadLocalRandom.current().nextInt(1,101) < 91)
+                return null; // cut down world drops rates of resources by 90%
             int amount = ThreadLocalRandom.current().nextInt(tableRow.minSpawn, tableRow.maxSpawn + 1);
             return new MobLoot(mob, ItemBase.getItemBase(itemUUID), amount, false);
         }
-
+        if(ItemBase.getItemBase(itemUUID).getType().equals(Enum.ItemType.RUNE)){
+            int randomRune = rollRandomItem(itemTableId);
+            if(randomRune != 0) {
+                itemUUID = randomRune;
+            }
+        } else if(ItemBase.getItemBase(itemUUID).getType().equals(Enum.ItemType.CONTRACT)){
+            int randomContract = rollRandomItem(itemTableId);
+            if(randomContract != 0) {
+                itemUUID = randomContract;
+            }
+        }
         outItem = new MobLoot(mob, ItemBase.getItemBase(itemUUID), false);
-        Enum.ItemType outType = outItem.getItemBase().getType();
-
 
         if(selectedRow.pModTable != 0){
             try {
@@ -196,6 +395,12 @@ public enum LootManager {
                 Logger.error("Failed to GenerateSuffix for item: " + outItem.getName());
             }
         }
+
+        if(outItem.getItemBase().getType().equals(Enum.ItemType.CONTRACT) || outItem.getItemBase().getType().equals(Enum.ItemType.RUNE)){
+            if(ThreadLocalRandom.current().nextInt(1,101) < 66)
+                return null; // cut down world drops rates of resources by 65%
+        }
+
         return outItem;
     }
 
@@ -216,7 +421,7 @@ public enum LootManager {
         if(mob.getObjectType().ordinal() == 52) {
             prefixTableRoll = ThreadLocalRandom.current().nextInt(1,320 + 1);
         } else{
-            prefixTableRoll = TableRoll(mob.level, inHotzone);
+            prefixTableRoll = TableRoll(mob.level);
         }
         ModTableEntry prefixMod = ModTableEntry.rollTable(prefixTable.modTableID, prefixTableRoll);
 
@@ -248,7 +453,7 @@ public enum LootManager {
         if(mob.getObjectType().ordinal() == 52) {
             suffixTableRoll = ThreadLocalRandom.current().nextInt(1,320 + 1);
         } else{
-            suffixTableRoll = TableRoll(mob.level, inHotzone);
+            suffixTableRoll = TableRoll(mob.level);
         }
         ModTableEntry suffixMod = ModTableEntry.rollTable(suffixTable.modTableID, suffixTableRoll);
 
@@ -263,23 +468,36 @@ public enum LootManager {
         return inItem;
     }
 
-    public static int TableRoll(int mobLevel, Boolean inHotzone) {
+    public static int TableRoll(int mobLevel) {
-
+
-        if (mobLevel > 65)
+        int rank = (int)(mobLevel * 0.1f);
-            mobLevel = 65;
+        int min = 50;
-
+        int max = 100;
-        int max = (int) (4.882 * mobLevel + 127.0);
+        switch(rank){
-
+            case 1:
-        if (max > 319)
+                min = 200;
-            max = 319;
+                max = 250;
-
+                break;
-        int min = (int) (4.469 * mobLevel - 3.469);
+            case 2:
-
+                min = 210;
-        if (min < 70)
+                max = 275;
-            min = 70;
+                break;
-
+            case 3:
-        if (inHotzone)
+                min = 220;
-            min += mobLevel;
+                max = 300;
+                break;
+            case 4:
+                min = 230;
+                max = 320;
+                break;
+            case 5:
+            case 6:
+            case 7:
+            case 8:
+                min = 240;
+                max = 320;
+                break;
+        }
 
         int roll = ThreadLocalRandom.current().nextInt(min, max + 1);
 
@@ -299,12 +517,7 @@ public enum LootManager {
 
         int high = bse.highGold;
         int low = bse.lowGold;
-        int gold = ThreadLocalRandom.current().nextInt(low, high + 1);
+        int gold = (int) (ThreadLocalRandom.current().nextInt(low, high + 1) * NORMAL_GOLD_RATE);
-
-        if (inHotzone == true)
-            gold = (int) (gold * HOTZONE_GOLD_RATE);
-        else
-            gold = (int) (gold * NORMAL_GOLD_RATE);
 
         if (gold > 0) {
             MobLoot goldAmount = new MobLoot(mob, gold);
@@ -315,45 +528,63 @@ public enum LootManager {
 
     public static void GenerateLootDrop(Mob mob, int tableID, Boolean inHotzone) {
 
-        try {
+        MobLoot toAdd = getGenTableItem(tableID, mob, inHotzone);
-
+        if(toAdd != null){
-            MobLoot toAdd = getGenTableItem(tableID, mob, inHotzone);
+            ItemBase ib = toAdd.getItemBase();
-
+            switch(ib.getType()){
-            if (toAdd != null)
+                case CONTRACT:
-                mob.getCharItemManager().addItemToInventory(toAdd);
+                case RUNE:
-
+                case RESOURCE:
-        } catch (Exception e) {
+                    return;
-            //TODO chase down loot generation error, affects roughly 2% of drops
+            }
-            int i = 0;
+            toAdd.setIsID(true);
+            mob.getCharItemManager().addItemToInventory(toAdd);
         }
     }
 
+
     public static void GenerateEquipmentDrop(Mob mob) {
 
+        if (mob == null || mob.getSafeZone())
+            return; // no equipment to drop in safezones
+
+        if(mob.StrongholdGuardian || mob.StrongholdCommander || mob.StrongholdEpic)
+            return; // stronghold mobs don't drop equipment
+
         //do equipment here
-        int dropCount = 0;
+        if (mob.getEquip() != null) {
-        if (mob.getEquip() != null)
+            boolean isVorg = false;
             for (MobEquipment me : mob.getEquip().values()) {
 
                 if (me.getDropChance() == 0)
                     continue;
 
+                String name = me.getItemBase().getName().toLowerCase();
+                if (name.contains("vorgrim legionnaire's") || name.contains("vorgrim auxiliary's") ||name.contains("bellugh nuathal") || name.contains("crimson circle"))
+                    isVorg = true;
+
+                if(isVorg && !mob.isDropper){
+                    continue;
+                }
+
                 float equipmentRoll = ThreadLocalRandom.current().nextInt(1, 100 + 1);
                 float dropChance = me.getDropChance() * 100;
-
+                ItemBase itemBase = me.getItemBase();
+                if(isVorg) {
+                    mob.spawnTime = ThreadLocalRandom.current().nextInt(300, 2700);
+                    dropChance = 10;
+                    itemBase = getRandomVorg(itemBase);
+                }
                 if (equipmentRoll > dropChance)
                     continue;
 
-                MobLoot ml = new MobLoot(mob, me.getItemBase(), false);
+                MobLoot ml = new MobLoot(mob, itemBase, false);
 
-                if (ml != null && dropCount < 1) {
+                ml.setIsID(true);
-                    ml.setIsID(true);
+                ml.setDurabilityCurrent((short) (ml.getDurabilityCurrent() - ThreadLocalRandom.current().nextInt(5) + 1));
-                    ml.setDurabilityCurrent((short) (ml.getDurabilityCurrent() - ThreadLocalRandom.current().nextInt(5) + 1));
+                mob.getCharItemManager().addItemToInventory(ml);
-                    mob.getCharItemManager().addItemToInventory(ml);
-                    dropCount = 1;
-                    //break; // Exit on first successful roll.
-                }
             }
+        }
     }
 
     public static void GenerateInventoryDrop(Mob mob, BootySetEntry bse) {
@@ -367,8 +598,11 @@ public enum LootManager {
 
         MobLoot lootItem = new MobLoot(mob, ItemBase.getItemBase(bse.itemBase), true);
 
-        if (lootItem != null)
+        if (lootItem != null) {
             mob.getCharItemManager().addItemToInventory(lootItem);
+            if(lootItem.getItemBase().isDiscRune() && !Mob.discDroppers.contains(mob))
+                Mob.AddDiscDropper(mob);
+        }
     }
 
     public static void peddleFate(PlayerCharacter playerCharacter, Item gift) {
@@ -392,12 +626,12 @@ public enum LootManager {
 
         //check if player owns the gift he is trying to open
 
-        if (itemMan.doesCharOwnThisItem(gift.getObjectUUID()) == false)
+        if (!itemMan.doesCharOwnThisItem(gift.getObjectUUID()))
             return;
 
         //roll 1-100 for the gen table selection
 
-        int genRoll = ThreadLocalRandom.current().nextInt(1, 100 + 1);
+        int genRoll = ThreadLocalRandom.current().nextInt(94, 100) + 1;
         GenTableEntry selectedRow = GenTableEntry.rollTable(tableID, genRoll, LootManager.NORMAL_DROP_RATE);
 
         if(selectedRow == null)
@@ -413,45 +647,276 @@ public enum LootManager {
 
         //create the item from the table, quantity is always 1
 
-        MobLoot winnings = new MobLoot(playerCharacter, ItemBase.getItemBase(selectedItem.cacheID), 1, false);
+        ItemBase ib = ItemBase.getItemBase(selectedItem.cacheID);
+        if(ib.getUUID() == Warehouse.coalIB.getUUID()){
+            //no more coal, give gold instead
+            if (itemMan.getGoldInventory().getNumOfItems() + 250000 > 10000000) {
+                ErrorPopupMsg.sendErrorPopup(playerCharacter, 21);
+                return;
+            }
+            itemMan.addGoldToInventory(250000,false);
+            itemMan.updateInventory();
+        }else {
+            MobLoot winnings = new MobLoot(playerCharacter, ib, 1, false);
 
-        if (winnings == null)
+            if (winnings == null)
-            return;
+                return;
 
-        //early exit if the inventory of the player will not old the item
+            //early exit if the inventory of the player will not hold the item
 
-        if (itemMan.hasRoomInventory(winnings.getItemBase().getWeight()) == false) {
+            if (itemMan.hasRoomInventory(winnings.getItemBase().getWeight()) == false) {
-            ErrorPopupMsg.sendErrorPopup(playerCharacter, 21);
+                ErrorPopupMsg.sendErrorPopup(playerCharacter, 21);
-            return;
+                return;
+            }
+
+            //determine if the winning item needs a prefix
+
+            if (selectedRow.pModTable != 0) {
+                int prefixRoll = ThreadLocalRandom.current().nextInt(220, 320 + 1);
+                ModTableEntry prefix = ModTableEntry.rollTable(selectedRow.pModTable, prefixRoll);
+                if (prefix != null)
+                    winnings.addPermanentEnchantment(prefix.action, 0, prefix.level, true);
+            }
+
+            //determine if the winning item needs a suffix
+
+            if (selectedRow.sModTable != 0) {
+                int suffixRoll = ThreadLocalRandom.current().nextInt(220, 320 + 1);
+                ModTableEntry suffix = ModTableEntry.rollTable(selectedRow.sModTable, suffixRoll);
+                if (suffix != null)
+                    winnings.addPermanentEnchantment(suffix.action, 0, suffix.level, true);
+            }
+            winnings.setIsID(true);
+
+            //remove gift from inventory
+
+            itemMan.consume(gift);
+
+            //add winnings to player inventory
+
+            Item playerWinnings = winnings.promoteToItem(playerCharacter);
+            itemMan.addItemToInventory(playerWinnings);
+            itemMan.updateInventory();
         }
+    }
 
-        //determine if the winning item needs a prefix
+    public static int rollRandomItem(int itemTable){
+        int returnedID = ItemTableEntry.getRandomItem(itemTable);
+        return returnedID;
+    }
 
-        if(selectedRow.pModTable != 0){
+    public static ItemBase getRandomVorg(ItemBase itemBase){
-            int prefixRoll = ThreadLocalRandom.current().nextInt(220,320 + 1);
+        int roll = 0;
-            ModTableEntry prefix = ModTableEntry.rollTable(selectedRow.pModTable, prefixRoll);
+        if(vorg_ha_uuids.contains(itemBase.getUUID())) {
-            if(prefix != null)
+            roll = ThreadLocalRandom.current().nextInt(0, 10);
-                winnings.addPermanentEnchantment(prefix.action, 0, prefix.level, true);
+            switch (roll) {
+                case 1:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(0));
+                case 2:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(1));
+                case 3:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(2));
+                case 4:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(3));
+                case 5:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(4));
+                case 6:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(5));
+                case 7:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(6));
+                case 8:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(7));
+                default:
+                    return ItemBase.getItemBase(vorg_ha_uuids.get(8));
+            }
         }
 
-        //determine if the winning item needs a suffix
+        if(vorg_ma_uuids.contains(itemBase.getUUID())) {
+            roll = ThreadLocalRandom.current().nextInt(0, 10);
+            switch (roll) {
+                case 1:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(0));
+                case 2:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(1));
+                case 3:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(2));
+                case 4:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(3));
+                case 5:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(4));
+                case 6:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(5));
+                case 7:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(6));
+                default:
+                    return ItemBase.getItemBase(vorg_ma_uuids.get(7));
+            }
+        }
 
-        if(selectedRow.sModTable != 0){
+        if(vorg_la_uuids.contains(itemBase.getUUID())) {
-            int suffixRoll = ThreadLocalRandom.current().nextInt(220,320 + 1);
+            roll = ThreadLocalRandom.current().nextInt(0, 10);
-            ModTableEntry suffix = ModTableEntry.rollTable(selectedRow.sModTable, suffixRoll);
+            switch (roll) {
-            if (suffix != null)
+                case 1:
-                winnings.addPermanentEnchantment(suffix.action, 0, suffix.level, true);
+                    return ItemBase.getItemBase(vorg_la_uuids.get(0));
+                case 2:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(1));
+                case 3:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(2));
+                case 4:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(3));
+                case 5:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(4));
+                case 6:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(5));
+                case 7:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(6));
+                default:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(7));
+            }
         }
-        winnings.setIsID(true);
 
-        //remove gift from inventory
+        if(vorg_cloth_uuids.contains(itemBase.getUUID())) {
+            roll = ThreadLocalRandom.current().nextInt(0, 10);
+            switch (roll) {
+                case 1:
+                    return ItemBase.getItemBase(vorg_cloth_uuids.get(0));
+                case 2:
+                    return ItemBase.getItemBase(vorg_cloth_uuids.get(1));
+                case 3:
+                    return ItemBase.getItemBase(vorg_cloth_uuids.get(2));
+                case 4:
+                    return ItemBase.getItemBase(vorg_cloth_uuids.get(3));
+                default:
+                    return ItemBase.getItemBase(vorg_cloth_uuids.get(4));
+            }
+        }
+
+        return null;
+    }
+
+    public static void DropPresent(Mob mob){
+        int random = 971049 + ThreadLocalRandom.current().nextInt(24);
+        if (random > 971071)
+            random = 971071;
+
+        ItemBase present = ItemBase.getItemBase(random);
+        if (present != null) {
+            MobLoot toAdd = new MobLoot(mob, present, true);
+
+            if (toAdd != null)
+                mob.getCharItemManager().addItemToInventory(toAdd);
+        }
+    }
 
-        itemMan.consume(gift);
+    public static void GenerateStrongholdLoot(Mob mob, boolean commander, boolean epic) {
 
-        //add winnings to player inventory
+        mob.getCharItemManager().clearInventory();
 
-        Item playerWinnings = winnings.promoteToItem(playerCharacter);
+        int multiplier = 1;
-        itemMan.addItemToInventory(playerWinnings);
+        if (commander)
-        itemMan.updateInventory();
+            multiplier = 2;
+        if(epic)
+            multiplier = 10;
+
+        int high = 125000;
+        int low = 50000;
+        int gold = ThreadLocalRandom.current().nextInt(low, high + 1) * multiplier;
+
+        if (gold > 0) {
+            MobLoot goldAmount = new MobLoot(mob, gold);
+            mob.getCharItemManager().addItemToInventory(goldAmount);
+        }
+
+        //present drop chance for all
+        if (ThreadLocalRandom.current().nextInt(100) < 35)
+            DropPresent(mob);
+
+        //random contract drop chance for all
+        if (ThreadLocalRandom.current().nextInt(100) < 40) {
+            int contractTableID = 250;
+            contractTableID += ThreadLocalRandom.current().nextInt(0, 11);
+            if (contractTableID > 259)
+                contractTableID = 659;
+
+                int id = rollRandomItem(contractTableID);
+                ItemBase ib = ItemBase.getItemBase(id);
+                if (ib != null) {
+                    MobLoot contract = new MobLoot(mob, ib, true);
+
+                    if (contract != null)
+                        mob.getCharItemManager().addItemToInventory(contract);
+                }
+        }
+
+        //special commander drop chances
+        if (commander)
+            GenerateCommanderLoot(mob,false);
+
+        //special epic drop chances
+        if (epic) {
+            GenerateCommanderLoot(mob, true);
+            GenerateCommanderLoot(mob,false);
+        }
+    }
+
+    public static void GenerateCommanderLoot(Mob mob, boolean epic){
+        //present chance
+        if (ThreadLocalRandom.current().nextInt(100) < 25)
+            DropPresent(mob);
+
+        //present chance
+        if (ThreadLocalRandom.current().nextInt(100) < 25)
+            DropPresent(mob);
+
+        //chance for glass
+        if (ThreadLocalRandom.current().nextInt(100) < 75) {
+            int glassID = rollRandomItem(126);
+            ItemBase glassItem = ItemBase.getItemBase(glassID);
+            if (glassItem != null) {
+                MobLoot toAdd2 = new MobLoot(mob, glassItem, true);
+
+                if (toAdd2 != null)
+                    mob.getCharItemManager().addItemToInventory(toAdd2);
+            }
+        }
+
+        //chance for disc
+        if (ThreadLocalRandom.current().nextInt(100) < 75) {
+            int discID = rollRandomItem(3202);
+            ItemBase discItem = ItemBase.getItemBase(discID);
+            if (discItem != null) {
+                MobLoot toAdd3 = new MobLoot(mob, discItem, true);
+
+                if (toAdd3 != null)
+                    mob.getCharItemManager().addItemToInventory(toAdd3);
+            }
+        }
+
+        //chance for stat rune
+        if (ThreadLocalRandom.current().nextInt(100) < 75) {
+            int runeID = rollRandomItem(3201);
+            ItemBase runeItem = ItemBase.getItemBase(runeID);
+            if (runeItem != null) {
+                MobLoot toAdd4 = new MobLoot(mob, runeItem, true);
+
+                if (toAdd4 != null)
+                    mob.getCharItemManager().addItemToInventory(toAdd4);
+            }
+        }
+        if(epic){
+            int contractTableID = 250;
+            contractTableID += ThreadLocalRandom.current().nextInt(0, 11);
+            if (contractTableID > 259)
+                contractTableID = 659;
+
+            int id = rollRandomItem(contractTableID);
+            ItemBase ib = ItemBase.getItemBase(id);
+            if (ib != null) {
+                MobLoot contract = new MobLoot(mob, ib, true);
+
+                if (contract != null)
+                    mob.getCharItemManager().addItemToInventory(contract);
+            }
+        }
     }
 }

src/engine/gameManager/MaintenanceManager.java

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

src/engine/gameManager/MovementManager.java

@@ -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/NPCManager.java

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

src/engine/gameManager/PowersManager.java

@@ -10,6 +10,7 @@ package engine.gameManager;
 
 import engine.Enum.*;
 import engine.InterestManagement.HeightMap;
+import engine.InterestManagement.InterestManager;
 import engine.InterestManagement.WorldGrid;
 import engine.db.handlers.dbEffectsBaseHandler;
 import engine.db.handlers.dbPowerHandler;
@@ -163,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
 
@@ -171,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);
@@ -192,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);
         }
     }
 
@@ -205,6 +212,41 @@ public enum PowersManager {
 
         boolean CSRCast = false;
 
+        if(msg.getPowerUsedID() == 430628895) {
+
+            boolean failed = false;// group teleport
+            City city = ZoneManager.getCityAtLocation(playerCharacter.loc);
+            if (city == null) {
+                failed = true;
+            }else{
+                Bane bane = city.getBane();
+                if (bane == null) {
+                    failed = true;
+                }else{
+                    if(!bane.getSiegePhase().equals(SiegePhase.WAR)){
+                        failed = true;
+                    }
+                }
+            }
+            if(failed){
+                //check to see if we are at an active mine
+                Zone zone = ZoneManager.findSmallestZone(playerCharacter.loc);
+                if(zone != null){
+                    Mine mine = null;
+                    for(Building building : zone.zoneBuildingSet){
+                        if(building.getBlueprint().getBuildingGroup().equals(BuildingGroup.MINE)){
+                            mine = Mine.getMineFromTower(building.getObjectUUID());
+                        }
+                    }
+                    if(mine != null){
+                        failed = !mine.isActive;
+                    }
+                }
+            }
+
+            if(failed)
+                return false;
+        }
 
         if (MBServerStatics.POWERS_DEBUG) {
             ChatManager.chatSayInfo(
@@ -241,6 +283,7 @@ public enum PowersManager {
 
         // get power
         PowersBase pb = PowersManager.powersBaseByToken.get(msg.getPowerUsedID());
+
         if (pb == null) {
             ChatManager.chatSayInfo(playerCharacter,
                     "This power is not implemented yet.");
@@ -252,6 +295,35 @@ public enum PowersManager {
             // return false;
         }
 
+        //check for movement buffs while flying
+        if(playerCharacter.isFlying()) {
+            switch(pb.token){
+                case 429005674:
+                case 429505739:
+                case 431054700:
+                case 428005600:
+                case 431610080:
+                case 427935608:
+                case 427857146:
+                case 427988218:
+                case 431854842:
+                case 421074170:
+                case 429611355:
+                case 428955899:
+                case 1794395699:
+                case 429428796:
+                case 1514898036:
+                    ChatManager.chatSystemInfo(playerCharacter, "You Cannot Fly While Having A MovementBuff");
+                    //resync stamina
+                    playerCharacter.setStamina(playerCharacter.getStamina(), playerCharacter);
+
+                    // Update all surrounding clients.
+                    TargetedActionMsg cmm = new TargetedActionMsg(playerCharacter);
+                    DispatchMessage.dispatchMsgToInterestArea(playerCharacter, cmm, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
+                    return true;
+            }
+        }
+
         if (playerCharacter.getLastPower() != null)
             return true;
 
@@ -279,6 +351,14 @@ public enum PowersManager {
             msg.setNumTrains(trains);
         }
 
+        //double stack point values for some useless disc spells
+        switch(pb.token){
+            case 429420458: // BH eyes
+            case 429601664: // huntsman skin the beast
+                msg.setNumTrains(msg.getNumTrains() * 2);
+                break;
+        }
+
         // can't go over total trains by player
         if (playerCharacter.getPowers() != null && playerCharacter.getPowers().containsKey(msg.getPowerUsedID())) {
             CharacterPower cp = playerCharacter.getPowers().get(msg.getPowerUsedID());
@@ -370,15 +450,20 @@ public enum PowersManager {
                 float range = pb.getRange();
                 // verify target is in range
 
+                if(pb.token != 429396028) {
+
+                    if (verifyInvalidRange(playerCharacter, target, range))
+                        // (pc.getLoc().distance(target.getLoc()) > pb.getRange()) {
+                        // TODO send message that target is out of range
+                        return true;
+// verify target is valid type
+                    if (!validateTarget(target, playerCharacter, pb))
+                        return true;
+                }else{
+                    pb.isSpell = false;
+                }
 
-                if (verifyInvalidRange(playerCharacter, target, range))
-                    // (pc.getLoc().distance(target.getLoc()) > pb.getRange()) {
-                    // TODO send message that target is out of range
-                    return true;
 
-                // verify target is valid type
-                if (!validateTarget(target, playerCharacter, pb))
-                    return true;
 
 
                 if (AbstractWorldObject.IsAbstractCharacter(target))
@@ -487,7 +572,6 @@ public enum PowersManager {
         // Validity checks passed, move on to casting spell
         //get caster's live counter
         int casterLiveCounter = playerCharacter.getLiveCounter();
-
         // run recycle job for when cast is available again, don't bother adding the timer for CSRs
         if (time > 0) {
             FinishRecycleTimeJob frtj = new FinishRecycleTimeJob(playerCharacter, msg);
@@ -514,7 +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);
@@ -522,10 +606,12 @@ public enum PowersManager {
         }
 
         // update cast (use skill) fail condition
-        playerCharacter.cancelOnCast();
+        if(pb.token != 429396028 && pb.breaksForm) {
+            playerCharacter.cancelOnCast();
+        }
 
         // update castSpell (use spell) fail condition if spell
-        if (pb.isSpell())
+        if (pb.isSpell() && pb.breaksForm)
             playerCharacter.cancelOnSpell();
 
         // get cast time in ms.
@@ -535,13 +621,12 @@ public enum PowersManager {
 
 
         if (time > 100) {
-            playerCharacter.update();
+            playerCharacter.update(false);
             playerCharacter.setIsCasting(true);
         }
 
 
         playerCharacter.setLastMovementState(playerCharacter.getMovementState());
-
         // run timer job to end cast
         if (time < 1) // run immediately
             finishUsePower(copyMsg, playerCharacter, casterLiveCounter, targetLiveCounter);
@@ -667,10 +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.
@@ -706,8 +792,17 @@ public enum PowersManager {
         if (playerCharacter == null || msg == null)
             return;
 
+        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);
         }
 
@@ -809,15 +904,16 @@ public enum PowersManager {
                 }
                 float range = pb.getRange() + speedRange;
 
+                if(pb.token != 429396028) {
 
-                if (verifyInvalidRange(playerCharacter, mainTarget, range)) {
+                    if (verifyInvalidRange(playerCharacter, mainTarget, range)) {
 
-                    sendPowerMsg(playerCharacter, 8, msg);
+                        sendPowerMsg(playerCharacter, 8, msg);
-                    return;
+                        return;
+                    }
+                    // (pc.getLoc().distance(target.getLoc()) > pb.getRange()) {
+                    // TODO send message that target is out of range
                 }
-                // (pc.getLoc().distance(target.getLoc()) > pb.getRange()) {
-                // TODO send message that target is out of range
-
 
             }
 
@@ -1233,7 +1329,7 @@ public enum PowersManager {
 
         PlayerCharacter target = SessionManager
                 .getPlayerCharacterByLowerCaseName(msg.getTargetName());
-        if (target == null || target.equals(pc) || target.isCombat()) {
+        if (target == null || target.equals(pc)) {
 
             if (target == null) // Player not found. Send not found message
                 ChatManager.chatInfoError(pc,
@@ -1337,6 +1433,16 @@ public enum PowersManager {
                 else
                     duration = 45000; // Belgosh Summons, 45 seconds
 
+                boolean enemiesNear = false;
+                for(AbstractWorldObject awo : WorldGrid.getObjectsInRangePartial(pc.loc,MBServerStatics.CHARACTER_LOAD_RANGE, MBServerStatics.MASK_PLAYER)){
+                    PlayerCharacter playerCharacter = (PlayerCharacter)awo;
+                    if(!playerCharacter.guild.getNation().equals(pc.guild.getNation())){
+                        enemiesNear = true;
+                    }
+                }
+
+                if(enemiesNear && !pc.isInSafeZone())
+                    duration += 60000;
 
                 // Teleport to summoners location
                 FinishSummonsJob fsj = new FinishSummonsJob(source, pc);
@@ -1462,8 +1568,17 @@ public enum PowersManager {
         }
 
         // create list of characters
-        HashSet<AbstractCharacter> trackChars = RangeBasedAwo.getTrackList(
+        HashSet<AbstractCharacter> trackChars;
-                allTargets, playerCharacter, maxTargets);
+        switch(msg.getPowerToken()){
+            case 431511776:
+            case 429578587:
+            case 429503360:
+                trackChars = getTrackList(playerCharacter);
+                break;
+            default:
+                trackChars = RangeBasedAwo.getTrackList(allTargets, playerCharacter, maxTargets);
+                break;
+        }
 
         TrackWindowMsg trackWindowMsg = new TrackWindowMsg(msg);
 
@@ -1476,6 +1591,30 @@ public enum PowersManager {
 
     }
 
+    public static HashSet<AbstractCharacter> getTrackList(PlayerCharacter tracker){
+        HashSet<AbstractCharacter> list = new HashSet<AbstractCharacter>();
+        HashSet<AbstractWorldObject> shortList = WorldGrid.getObjectsInRangePartial(tracker.loc,MBServerStatics.CHARACTER_LOAD_RANGE, MBServerStatics.MASK_PLAYER);
+        HashSet<AbstractWorldObject> fullList = WorldGrid.getObjectsInRangePartial(tracker.loc,1408, MBServerStatics.MASK_PLAYER);
+        ArrayList<Guild> guildsPresent = new ArrayList<>();
+        for(AbstractWorldObject awo : shortList){
+            PlayerCharacter pc = (PlayerCharacter)awo;
+            if(!guildsPresent.contains(pc.guild.getNation())){
+                guildsPresent.add(pc.guild.getNation());
+            }
+        }
+        for(AbstractWorldObject awo : fullList){
+            if(awo.equals(tracker))
+                continue;
+            PlayerCharacter pc = (PlayerCharacter)awo;
+            if(!pc.isAlive())
+                continue;
+            if(guildsPresent.contains(pc.guild.getNation()))
+                list.add(pc);
+        }
+
+        return list;
+    }
+
     private static void sendRecyclePower(int token, ClientConnection origin) {
         RecyclePowerMsg recyclePowerMsg = new RecyclePowerMsg(token);
 
@@ -2189,7 +2328,7 @@ public enum PowersManager {
 
         // set player is not casting for regens
         if (pc.isCasting()) {
-            pc.update();
+            pc.update(false);
         }
         pc.setIsCasting(false);
 
@@ -2241,28 +2380,26 @@ public enum PowersManager {
             defense = 0f;
         // Get hit chance
 
-        if (pc.getDebug(16)) {
+        //if (pc.getDebug(16)) {
-            String smsg = "ATR: " + atr + ", Defense: " + defense;
+        //    String smsg = "ATR: " + atr + ", Defense: " + defense;
-            ChatManager.chatSystemInfo(pc, smsg);
+         //   ChatManager.chatSystemInfo(pc, smsg);
-        }
+        //}
 
-        int chance;
+        //int chance;
 
-        if (atr > defense || defense == 0)
+        //if (atr > defense || defense == 0)
-            chance = 94;
+        //    chance = 94;
-        else {
+        //else {
-            float dif = atr / defense;
+        //    float dif = atr / defense;
-            if (dif <= 0.8f)
+        //    if (dif <= 0.8f)
-                chance = 4;
+        //        chance = 4;
-            else
+        //    else
-                chance = ((int) (450 * (dif - 0.8f)) + 4);
+        //        chance = ((int) (450 * (dif - 0.8f)) + 4);
-        }
+        //}
 
         // calculate hit/miss
-        int roll = ThreadLocalRandom.current().nextInt(100);
 
-        boolean disable = true;
+        if (CombatManager.LandHit((int)atr,(int)defense)) {
-        if (roll < chance) {
             // Hit, check if dodge kicked in
             if (awo instanceof AbstractCharacter) {
                 AbstractCharacter tarAc = (AbstractCharacter) awo;
@@ -2562,7 +2699,9 @@ public enum PowersManager {
     }
 
     public static void cancelOnStun(AbstractCharacter ac) {
-
+        if(ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
+            //PlayerCharacter.GroundPlayer((PlayerCharacter)ac);
+        }
     }
 
     private static PowersBase getLastPower(AbstractCharacter ac) {
@@ -2708,6 +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

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

src/engine/gameManager/StrongholdManager.java

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

src/engine/gameManager/ZergManager.java

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

src/engine/gameManager/ZoneManager.java

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

src/engine/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/FinishSummonsJob.java

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

src/engine/jobs/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

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

src/engine/loot/ModTableEntry.java

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

src/engine/math/Bounds.java

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

src/engine/mobileAI/MobAI.java

@@ -9,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;
@@ -82,6 +81,16 @@ public class MobAI {
 
             mob.updateLocation();
 
+            if(mob.StrongholdGuardian || mob.StrongholdEpic){
+                // attempt to ground all players in attack range
+                for(int i : mob.playerAgroMap.keySet()){
+                    PlayerCharacter tar = PlayerCharacter.getFromCache(i);
+                    if(tar != null && tar.loc.distanceSquared(mob.loc) < 80){
+                        PowersManager.applyPower(mob,tar,tar.loc, 111111,40,false);
+                    }
+                }
+            }
+
         } catch (Exception e) {
             Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
         }
@@ -99,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;
             }
@@ -156,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());
@@ -166,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())
@@ -195,11 +207,11 @@ public class MobAI {
                 mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
             }
 
-            if (mob.isSiege()) {
+            //if (mob.isSiege()) {
-                PowerProjectileMsg ppm = new PowerProjectileMsg(mob, target);
+            //    PowerProjectileMsg ppm = new PowerProjectileMsg(mob, target);
-                ppm.setRange(50);
+            //    ppm.setRange(50);
-                DispatchMessage.dispatchMsgToInterestArea(mob, ppm, DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
+            //    DispatchMessage.dispatchMsgToInterestArea(mob, ppm, DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
-            }
+            //}
 
         } catch (Exception e) {
             Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackBuilding" + " " + e.getMessage());
@@ -308,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())) {
@@ -400,7 +412,7 @@ public class MobAI {
 
                 PerformActionMsg msg;
 
-                if (!mobPower.isHarmful() || mobPower.targetSelf) {
+                if (!mob.StrongholdCommander && !mob.StrongholdEpic && (!mobPower.isHarmful() || mobPower.targetSelf)) {
                     PowersManager.useMobPower(mob, mob, mobPower, powerRank);
                     msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, mob);
                 } else {
@@ -588,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());
@@ -625,9 +640,6 @@ public class MobAI {
 
                 //check to send mob home for player guards to prevent exploit of dragging guards away and then teleporting
 
-                if (mob.BehaviourType.ordinal() != Enum.MobBehaviourType.Pet1.ordinal())
-                    CheckToSendMobHome(mob);
-
                 return;
             }
 
@@ -646,7 +658,7 @@ public class MobAI {
                 return;
             }
 
-            if (mob.BehaviourType.ordinal() != Enum.MobBehaviourType.Pet1.ordinal())
+            if(mob.isPet() == false && mob.isPlayerGuard == false)
                 CheckToSendMobHome(mob);
 
             if (mob.getCombatTarget() != null) {
@@ -857,26 +869,31 @@ public class MobAI {
                         return;
                     }
                     //No items in inventory.
+                } else if (aiAgent.isHasLoot()) {
+                    if (System.currentTimeMillis() > aiAgent.deathTime + MBServerStatics.DESPAWN_TIMER_ONCE_LOOTED) {
+                        aiAgent.despawn();
+                        aiAgent.deathTime = System.currentTimeMillis();
+                        return;
+                    }
+                    //Mob never had Loot.
                 } else {
-                    //Mob's Loot has been looted.
-                    if (aiAgent.isHasLoot()) {
-                        if (System.currentTimeMillis() > aiAgent.deathTime + MBServerStatics.DESPAWN_TIMER_ONCE_LOOTED) {
-                            aiAgent.despawn();
-                            aiAgent.deathTime = System.currentTimeMillis();
-                            return;
-                        }
-                        //Mob never had Loot.
-                    } else {
                         if (System.currentTimeMillis() > aiAgent.deathTime + MBServerStatics.DESPAWN_TIMER) {
                             aiAgent.despawn();
                             aiAgent.deathTime = System.currentTimeMillis();
                             return;
                         }
                     }
+                return;
                 }
-            } else if (System.currentTimeMillis() > (aiAgent.deathTime + (aiAgent.spawnTime * 1000))) {
 
-                if (Zone.respawnQue.contains(aiAgent) == false) {
+            if(Mob.discDroppers.contains(aiAgent))
+                return;
+
+            if(aiAgent.StrongholdGuardian || aiAgent.StrongholdEpic || aiAgent.StrongholdCommander)
+                return;
+
+            if (aiAgent.despawned && System.currentTimeMillis() > (aiAgent.deathTime + (aiAgent.spawnTime * 1000L))) {
+                if (!Zone.respawnQue.contains(aiAgent)) {
                     Zone.respawnQue.add(aiAgent);
                 }
             }
@@ -896,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;
             }
@@ -911,7 +930,21 @@ 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);
+                return;
+            }
+
             if (mob.BehaviourType.isAgressive) {
 
                 if (mob.isPlayerGuard()) {
@@ -922,9 +955,6 @@ public class MobAI {
                 }
             }
 
-            if (mob.getCombatTarget() != null && CombatUtilities.inRange2D(mob, mob.getCombatTarget(), MobAIThread.AI_BASE_AGGRO_RANGE * 0.5f))
-                return;
-
             if (mob.isPlayerGuard() && !mob.despawned) {
 
                 City current = ZoneManager.getCityAtLocation(mob.getLoc());
@@ -934,7 +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
@@ -945,7 +974,7 @@ public class MobAI {
                         }
                     }
                 }
-            } else if (MovementUtilities.inRangeOfBindLocation(mob) == false) {
+            } else if (!MovementUtilities.inRangeOfBindLocation(mob)) {
 
                 PowersBase recall = PowersManager.getPowerByToken(-1994153779);
                 PowersManager.useMobPower(mob, mob, recall, 40);
@@ -953,6 +982,7 @@ public class MobAI {
 
                 for (Entry playerEntry : mob.playerAgroMap.entrySet())
                     PlayerCharacter.getFromCache((int) playerEntry.getKey()).setHateValue(0);
+                mob.setCombatTarget(null);
             }
         } catch (Exception e) {
             Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckToSendMobHome" + " " + e.getMessage());
@@ -963,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());
 
@@ -1006,7 +1041,7 @@ public class MobAI {
 
                 //dont scan self.
 
-                if (mob.equals(awoMob) || (mob.agentType.equals(Enum.AIAgentType.GUARD)) == true)
+                if (mob.equals(awoMob) || (mob.agentType.equals(Enum.AIAgentType.GUARD)) || (mob.agentType.equals(Enum.AIAgentType.PET)))
                     continue;
 
                 Mob aggroMob = (Mob) awoMob;
@@ -1029,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);
 
@@ -1056,6 +1104,8 @@ public class MobAI {
     public static void GuardMinionLogic(Mob mob) {
 
         try {
+            checkToDropGuardAggro(mob);
+
             boolean isComanded = mob.npcOwner.isAlive();
             if (!isComanded) {
                 GuardCaptainLogic(mob);
@@ -1076,6 +1126,8 @@ public class MobAI {
     public static void GuardWallArcherLogic(Mob mob) {
 
         try {
+            checkToDropGuardAggro(mob);
+
             if (mob.getCombatTarget() == null)
                 CheckForPlayerGuardAggro(mob);
             else
@@ -1351,21 +1403,31 @@ public class MobAI {
         return null;
     }
 
-    public static void RecoverHealth(Mob mob){
+    public static void RecoverHealth(Mob mob) {
         //recover health
+        try {
+            if (mob.getTimestamps().containsKey("HEALTHRECOVERED") == false)
+                mob.getTimestamps().put("HEALTHRECOVERED", System.currentTimeMillis());
 
-        if (mob.getTimestamps().containsKey("HEALTHRECOVERED") == false)
+            if (mob.isSit() && mob.getTimeStamp("HEALTHRECOVERED") < System.currentTimeMillis() + 3000)
-            mob.getTimestamps().put("HEALTHRECOVERED", System.currentTimeMillis());
+                if (mob.getHealth() < mob.getHealthMax()) {
 
-        if (mob.isSit() && mob.getTimeStamp("HEALTHRECOVERED") < System.currentTimeMillis() + 3000)
+                    float recoveredHealth = mob.getHealthMax() * ((1 + mob.getBonuses().getFloatPercentAll(Enum.ModType.HealthRecoverRate, Enum.SourceType.None)) * 0.01f);
-            if (mob.getHealth() < mob.getHealthMax()) {
+                    mob.setHealth(mob.getHealth() + recoveredHealth);
+                    mob.getTimestamps().put("HEALTHRECOVERED", System.currentTimeMillis());
 
-                float recoveredHealth = mob.getHealthMax() * ((1 + mob.getBonuses().getFloatPercentAll(Enum.ModType.HealthRecoverRate, Enum.SourceType.None)) * 0.01f);
+                    if (mob.getHealth() > mob.getHealthMax())
-                mob.setHealth(mob.getHealth() + recoveredHealth);
+                        mob.setHealth(mob.getHealthMax());
-                mob.getTimestamps().put("HEALTHRECOVERED", System.currentTimeMillis());
+                }
+        } catch (Exception e) {
+            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: RecoverHealth" + " " + e.getMessage());
+        }
+    }
 
-                if (mob.getHealth() > mob.getHealthMax())
+    public static void enterCombat(Mob mob){
-                    mob.setHealth(mob.getHealthMax());
+        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()) {
-
+                if (zone != null && zone.zoneMobSet != null) {
-                for (Mob mob : zone.zoneMobSet) {
+                    synchronized (zone.zoneMobSet) {
-
+                        for (Mob mob : zone.zoneMobSet) {
-                    try {
+                            try {
-                        if (mob != null)
+                                if (mob != null) {
-                            MobAI.DetermineAction(mob);
+                                    MobAI.DetermineAction(mob);
-                    } catch (Exception e) {
+                                }
-                        Logger.error("Mob: " + mob.getName() + " UUID: " + mob.getObjectUUID() + " ERROR: " + e);
+                            } catch (Exception e) {
-                        e.printStackTrace();
+                                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 (running) {
-        while (true) {
-
             try {
-                for (Zone zone : ZoneManager.getAllZones()) {
+                Collection<Zone> zones = ZoneManager.getAllZones();
-
+                if (zones != null) {
-                    if (zone.respawnQue.isEmpty() == false && zone.lastRespawn + 100 < System.currentTimeMillis()) {
+                    for (Zone zone : zones) {
-
+                        synchronized (zone) { // Optional: Synchronize on zone
-                        Mob respawner = zone.respawnQue.iterator().next();
+                            if (!zone.respawnQue.isEmpty() &&
+                                    zone.lastRespawn + RESPAWN_INTERVAL < System.currentTimeMillis()) {
 
-                        if (respawner == null)
+                                Mob respawner = zone.respawnQue.iterator().next();
-                            continue;
+                                if (respawner != null) {
-
+                                    respawner.respawn();
-                        respawner.respawn();
+                                    zone.respawnQue.remove(respawner);
-                        zone.respawnQue.remove(respawner);
+                                    zone.lastRespawn = System.currentTimeMillis();
-                        zone.lastRespawn = System.currentTimeMillis();
+                                    Thread.sleep(100);
+                                }
+                            }
+                        }
                     }
                 }
+                Thread.sleep(100); // Prevent busy-waiting
             } catch (Exception e) {
-                Logger.error(e);
+                Logger.error("Error in MobRespawnThread", e);
             }
-
         }
+        Logger.info("MobRespawnThread stopped.");
     }
+
+    public void stop() {
+        running = false;
+    }
+
     public static void startRespawnThread() {
-        Thread respawnThread;
+        Thread respawnThread = new Thread(new MobRespawnThread());
-        respawnThread = new Thread(new MobRespawnThread());
         respawnThread.setName("respawnThread");
         respawnThread.start();
     }

src/engine/mobileAI/utilities/CombatUtilities.java

@@ -139,37 +139,26 @@ public class CombatUtilities {
     }
 
     public static boolean triggerDefense(Mob agent, AbstractWorldObject target) {
-        int defenseScore = 0;
+        int defense = 0;
-        int attackScore = agent.getAtrHandOne();
+        int atr = agent.mobBase.getAtr();
+        if(agent.getBonuses() != null){
+            atr += agent.getBonuses().getFloat(ModType.OCV,SourceType.None);
+            atr *= 1 + agent.getBonuses().getFloatPercentAll(ModType.OCV,SourceType.None);
+        }
         switch (target.getObjectType()) {
             case PlayerCharacter:
-                defenseScore = ((AbstractCharacter) target).getDefenseRating();
+                defense = ((AbstractCharacter) target).getDefenseRating();
                 break;
             case Mob:
 
                 Mob mob = (Mob) target;
                 if (mob.isSiege())
-                    defenseScore = attackScore;
+                    defense = atr;
                 break;
             case Building:
                 return false;
         }
-
+        return !CombatManager.LandHit(atr,defense);
-        int hitChance;
-        if (attackScore > defenseScore || defenseScore == 0)
-            hitChance = 94;
-        else if (attackScore == defenseScore && target.getObjectType() == GameObjectType.Mob)
-            hitChance = 10;
-        else {
-            float dif = attackScore / defenseScore;
-            if (dif <= 0.8f)
-                hitChance = 4;
-            else
-                hitChance = ((int) (450 * (dif - 0.8f)) + 4);
-            if (target.getObjectType() == GameObjectType.Building)
-                hitChance = 100;
-        }
-        return ThreadLocalRandom.current().nextInt(100) > hitChance;
     }
 
     public static boolean triggerBlock(Mob agent, AbstractWorldObject ac) {
@@ -267,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 range1 = getMaxDmg(agent) - getMinDmg(agent);
-                double damage1 = getMinDmg(weapon1.getMinDamage(), agent, weapon1) + ((ThreadLocalRandom.current().nextFloat() * range1) + (ThreadLocalRandom.current().nextFloat() * range1)) / 2;
+                double damage1 = getMinDmg(agent) + ((ThreadLocalRandom.current().nextFloat() * range1) + (ThreadLocalRandom.current().nextFloat() * range1)) / 2;
                 swingIsDamage(agent, target, (float) damage1, CombatManager.getSwingAnimation(weapon1, null, true));
                 ItemBase weapon2 = agent.getEquip().get(2).getItemBase();
-                double range2 = getMaxDmg(weapon2.getMinDamage(), agent, weapon2) - getMinDmg(weapon2.getMinDamage(), agent, weapon2);
+                double range2 = getMaxDmg(agent) - getMinDmg(agent);
-                double damage2 = getMinDmg(weapon2.getMinDamage(), agent, weapon2) + ((ThreadLocalRandom.current().nextFloat() * range2) + (ThreadLocalRandom.current().nextFloat() * range2)) / 2;
+                double damage2 = getMinDmg(agent) + ((ThreadLocalRandom.current().nextFloat() * range2) + (ThreadLocalRandom.current().nextFloat() * range2)) / 2;
                 swingIsDamage(agent, target, (float) damage2, CombatManager.getSwingAnimation(weapon1, null, false));
             } else {
                 swingIsDamage(agent, target, determineDamage(agent), anim);
@@ -322,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) {
+        if (agent.BehaviourType.equals(MobBehaviourType.Pet1)) {
-            damage = calculatePetDamage(agent);
+            damage = calculateMobDamage(agent);
-        } else if (agent.isPlayerGuard() == true) {
+        } else if (agent.isPlayerGuard()) {
             //damage = calculateGuardDamage(agent);
             damage = calculateMobDamage(agent);
         } else if (agent.getLevel() > 80) {
@@ -364,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 minDmg = getMinDmg(agent);
-        double maxDmg = getMaxDmg(max, agent, null);
+        double maxDmg = getMaxDmg(agent);
         dmgMultiplier += agent.getLevel() * 0.1f;
         range = (float) (maxDmg - minDmg);
         damage = min + ((ThreadLocalRandom.current().nextFloat() * range) + (ThreadLocalRandom.current().nextFloat() * range)) / 2;
@@ -381,8 +370,8 @@ public class CombatUtilities {
 
         double minDmg = weapon.getMinDamage();
         double maxDmg = weapon.getMaxDamage();
-        double min = getMinDmg(minDmg, agent, weapon);
+        double min = getMinDmg(agent);
-        double max = getMaxDmg(maxDmg, agent, weapon);
+        double max = getMaxDmg(agent);
 
         DamageType dt = weapon.getDamageType();
 
@@ -423,92 +412,48 @@ public class CombatUtilities {
     }
 
     public static int calculateMobDamage(Mob agent) {
-        ItemBase weapon = null;
+        double minDmg = getMinDmg(agent);
-        double minDmg;
+        double maxDmg = getMaxDmg(agent);
-        double maxDmg;
+        DamageType dt = getDamageType(agent);
-        DamageType dt;
-
-        //main hand or offhand damage
-
-        if (agent.getEquip().get(1) != null)
-            weapon = agent.getEquip().get(1).getItemBase();
-        else if (agent.getEquip().get(2) != null)
-            weapon = agent.getEquip().get(2).getItemBase();
-
-        if (weapon != null) {
-            minDmg = getMinDmg(weapon.getMinDamage(), agent, weapon);
-            maxDmg = getMaxDmg(weapon.getMaxDamage(), agent, weapon);
-            dt = weapon.getDamageType();
-        } else {
-            minDmg = agent.getMobBase().getDamageMin();
-            maxDmg = agent.getMobBase().getDamageMax();
-            dt = DamageType.Crush;
-        }
 
         AbstractWorldObject target = agent.getCombatTarget();
 
-        float dmgMultiplier = 1 + agent.getBonuses().getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
+        double damage = ThreadLocalRandom.current().nextInt((int)minDmg,(int)maxDmg + 1);
-        double range = maxDmg - minDmg;
-        double damage = minDmg + ((ThreadLocalRandom.current().nextFloat() * range) + (ThreadLocalRandom.current().nextFloat() * range)) / 2;
 
         if (AbstractWorldObject.IsAbstractCharacter(target))
             if (((AbstractCharacter) target).isSit())
                 damage *= 2.5f; //increase damage if sitting
         if (AbstractWorldObject.IsAbstractCharacter(target))
-            return (int) (((AbstractCharacter) target).getResists().getResistedDamage(agent, (AbstractCharacter) target, dt, (float) damage, 0) * dmgMultiplier);
+            return (int) (((AbstractCharacter) target).getResists().getResistedDamage(agent, (AbstractCharacter) target, dt, (float) damage, 0));
         return 0;
     }
 
-    public static double getMinDmg(double min, Mob agent, ItemBase weapon) {
+    public static double getMinDmg(Mob agent) {
-
+            if(agent.getEquip() != null){
-        int primary = agent.getStatStrCurrent();
+                if(agent.getEquip().get(ItemSlotType.RHELD) != null){
-        int secondary = agent.getStatDexCurrent();
+                    return agent.minDamageHandOne;
-        int focusLevel = 0;
+                }else if(agent.getEquip().get(ItemSlotType.LHELD) != null){
-        int masteryLevel = 0;
+                    return agent.getMinDamageHandTwo();
-
+                }else{
-        if (weapon != null) {
+                    return agent.minDamageHandOne;
-            if (weapon.isStrBased() == true) {
-                primary = agent.getStatStrCurrent();
-                secondary = agent.getStatDexCurrent();
-            } else {
-                primary = agent.getStatDexCurrent();
-                secondary = agent.getStatStrCurrent();
-                if (agent.getSkills().containsKey(weapon.getSkillRequired())) {
-                    focusLevel = (int) agent.getSkills().get(weapon.getSkillRequired()).getModifiedAmount();
-                }
-                if (agent.getSkills().containsKey(weapon.getMastery())) {
-                    masteryLevel = (int) agent.getSkills().get(weapon.getMastery()).getModifiedAmount();
                 }
+            }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) {
+    public static double getMaxDmg(Mob agent) {
-
+            if(agent.getEquip() != null){
-        int primary = agent.getStatStrCurrent();
+                if(agent.getEquip().get(ItemSlotType.RHELD) != null){
-        int secondary = agent.getStatDexCurrent();
+                    return agent.maxDamageHandOne;
-        int focusLevel = 0;
+                }else if(agent.getEquip().get(ItemSlotType.LHELD) != null){
-        int masteryLevel = 0;
+                    return agent.getMaxDamageHandTwo();
-
+                }else{
-        if (weapon != null) {
+                    return agent.maxDamageHandOne;
-
+                }
-            if (weapon.isStrBased() == true) {
+            }else{
-                primary = agent.getStatStrCurrent();
+                return agent.maxDamageHandOne;
-                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.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
+                        PlaceAssetMsg.sendPlaceAssetError(player.getClientConnection(), 1, "Please Report What You Just Did. Ref Code: " + opcode);
-                        Logger.error("Invalid protocol msg  : " + opcode + " lastopcode: " + origin.lastProtocol.name() + " Error Code : " + errorCode);
+                    }
-
                 }
 
                 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
+            //Logger
-                    .error(
+                    //.error(
-                            "Tried to remove improperly initialized session. Skipping." +
+                            //"Tried to remove improperly initialized session. Skipping." +
-                                    e);
+                                    //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());
 
@@ -560,12 +560,30 @@ public class ClientMessagePump implements NetMsgHandler {
         if (!itemManager.inventoryContains(i))
             return;
 
-        if (i.isCanDestroy())
+        //cannot delete gold
-            if (itemManager.delete(i) == true) {
+        if(i.getItemBaseID() == 7)
+            return;
+
+        if (i.isCanDestroy()) {
+            int goldValue = i.getBaseValue();
+            if (i.getItemBase().isRune())
+                goldValue = 500000;
+
+            if (i.getItemBaseID() == 980066)
+                goldValue = 0;
+
+            if(itemManager.getGoldInventory().getNumOfItems() + goldValue > 10000000)
+                return;
+
+            if (itemManager.delete(i)) {
+                if (goldValue > 0)
+                    itemManager.addGoldToInventory(goldValue, false);
+
+                itemManager.updateInventory();
                 Dispatch dispatch = Dispatch.borrow(sourcePlayer, msg);
                 DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
             }
-
+        }
     }
 
     private static void ackBankWindowOpened(AckBankWindowOpenedMsg msg, ClientConnection origin) {
@@ -654,6 +672,8 @@ public class ClientMessagePump implements NetMsgHandler {
         JobScheduler.getInstance().scheduleJob(new RefreshGroupJob(sourcePlayer), MBServerStatics.LOAD_OBJECT_DELAY);
     }
 
+
+
     private static void lootWindowRequest(LootWindowRequestMsg msg, ClientConnection origin) throws MsgSendException {
 
         PlayerCharacter pc = SessionManager.getPlayerCharacter(origin);
@@ -1243,6 +1263,8 @@ public class ClientMessagePump implements NetMsgHandler {
 
 
                 cost = sell.getBaseValue();
+                if(sell.getItemBaseID() == 980066)
+                    cost = 0;
 
                 //apply damaged value reduction
                 float durabilityCurrent = sell.getDurabilityCurrent();
@@ -1347,6 +1369,8 @@ public class ClientMessagePump implements NetMsgHandler {
             return;
 
         // test within talking range
+        if(npc.isInSafeZone())
+            npc.sellPercent = 0;
 
         if (sourcePlayer.getLoc().distanceSquared2D(npc.getLoc()) > MBServerStatics.NPC_TALK_RANGE * MBServerStatics.NPC_TALK_RANGE) {
             ErrorPopupMsg.sendErrorPopup(sourcePlayer, 14);
@@ -1358,219 +1382,192 @@ public class ClientMessagePump implements NetMsgHandler {
     }
 
     private static void buyFromNPC(BuyFromNPCMsg msg, ClientConnection origin) {
-
         PlayerCharacter sourcePlayer = SessionManager.getPlayerCharacter(origin);
-
         if (sourcePlayer == null)
             return;
-
         if (origin.buyLock.tryLock()) {
-
             try {
                 CharacterItemManager itemMan = sourcePlayer.getCharItemManager();
-
+                if (itemMan == null) {
-                if (itemMan == null)
                     return;
-
+                }
                 NPC npc = NPC.getFromCache(msg.getNPCID());
-
+                if (npc == null) {
-                if (npc == null)
                     return;
-
+                }
                 Item gold = itemMan.getGoldInventory();
-
+                if (gold == null) {
-                if (gold == null)
                     return;
-
+                }
                 Item buy = null;
-
                 if (msg.getItemType() == GameObjectType.MobEquipment.ordinal()) {
                     ArrayList<MobEquipment> sellInventory = npc.getContract().getSellInventory();
-                    if (sellInventory == null)
+                    //if(npc.contract.getObjectUUID() == 890){ // default steward
+                    //    sellInventory = npc.getSellInventorySteward();
+                    //}
+                    //if(npc.contract.getObjectUUID() == 889){ // default builder
+                    //    sellInventory = npc.getSellInventoryBuilder();
+                    //}
+                    if (sellInventory == null) {
                         return;
+                    }
                     for (MobEquipment me : sellInventory) {
                         if (me.getObjectUUID() == msg.getItemID()) {
                             ItemBase ib = me.getItemBase();
-                            if (ib == null)
+                            if (ib == null) {
                                 return;
-
+                            }
                             //test room available for item
-                            if (!itemMan.hasRoomInventory(ib.getWeight()))
+                            if (!itemMan.hasRoomInventory(ib.getWeight())) {
                                 return;
-
+                            }
                             int cost = me.getMagicValue();
-
                             float bargain = sourcePlayer.getBargain();
+                            switch(npc.getContractID()){
+                                case 1201:
+                                    cost = ItemBase.getDiscPrice(ib.getUUID());
+                                    bargain = 0;
+                                    break;
+                                case 1202:
+                                    cost = ItemBase.getStatPrice(ib.getUUID());
+                                    bargain = 0;
+                                    break;
+                                case 900:
+                                    cost = Warehouse.getCostForResource(ib.getUUID()) * Warehouse.getSellStackSize(ib.getUUID());
+                                    bargain = 0;
+                                    break;
+                            }
+                            float profit;
 
-                            float profit = npc.getSellPercent(sourcePlayer) - bargain;
+                            if(npc.isInSafeZone())
-
+                                profit = 0;
-                            if (profit < 1)
+                            else
-                                profit = 1;
+                                profit = npc.getSellPercent(sourcePlayer) - bargain;
-
 
-                            cost *= profit;
 
+                            if(profit > 0)
+                                cost *= profit;
 
                             if (gold.getNumOfItems() - cost < 0) {
                                 //dont' have enough goldItem exit!
                                 // chatMan.chatSystemInfo(pc, "" + "You dont have enough gold.");
                                 return;
                             }
-
                             Building b = (!npc.isStatic()) ? npc.getBuilding() : null;
-
                             if (b != null && b.getProtectionState().equals(ProtectionState.NPC))
                                 b = null;
                             int buildingDeposit = cost - me.getMagicValue();
-                            if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold()) {
+                            if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold() && !b.isOwnerIsNPC()) {
                                 ErrorPopupMsg.sendErrorPopup(sourcePlayer, 206);
                                 return;
-                            }
+                            }if(npc.getContractID() == 1502041){
-
+                                me.fromNoob = true;
-                            if (!itemMan.buyFromNPC(b, cost, buildingDeposit)) {
+                            } else if (!itemMan.buyFromNPC(b, cost, buildingDeposit)) {
                                 // chatMan.chatSystemInfo(pc, "" + "You Failed to buy the item.");
+                                ChatManager.chatSystemError(sourcePlayer, "Failed To Buy Item");
                                 return;
                             }
-
+                            if(me.getItemBase().getType().equals(ItemType.RESOURCE) && npc.getContractID() == 900){
-                            buy = Item.createItemForPlayer(sourcePlayer, ib);
+                                handleResourcePurchase(me,itemMan,sourcePlayer,ib);
-
+                            }else {
-                            if (buy != null) {
+                                buy = Item.createItemForPlayer(sourcePlayer, ib, me.fromNoob);
-                                me.transferEnchants(buy);
+                                if (buy != null) {
-                                itemMan.addItemToInventory(buy);
+                                    me.transferEnchants(buy);
-                                //itemMan.updateInventory();
+                                    itemMan.addItemToInventory(buy);
+                                    if(npc.contractUUID == 900 && buy.getItemBaseID() == 1705032){
+                                        buy.setNumOfItems(10);
+                                        DbManager.ItemQueries.UPDATE_NUM_ITEMS(buy,buy.getNumOfItems());
+                                    }
+                                    //itemMan.updateInventory();
+                                }
                             }
                         }
                     }
                 } else if (msg.getItemType() == GameObjectType.Item.ordinal()) {
-
                     CharacterItemManager npcCim = npc.getCharItemManager();
-
                     if (npcCim == null)
                         return;
-
                     buy = Item.getFromCache(msg.getItemID());
-
                     if (buy == null)
                         return;
-
                     ItemBase ib = buy.getItemBase();
-
                     if (ib == null)
                         return;
-
                     if (!npcCim.inventoryContains(buy))
                         return;
-
                     //test room available for item
                     if (!itemMan.hasRoomInventory(ib.getWeight()))
                         return;
-
                     //TODO test cost and subtract goldItem
-
                     //TODO CHnage this if we ever put NPc city npcs in buildings.
                     int cost = buy.getBaseValue();
-
                     if (buy.isID() || buy.isCustomValue())
                         cost = buy.getMagicValue();
-
                     float bargain = sourcePlayer.getBargain();
-
                     float profit = npc.getSellPercent(sourcePlayer) - bargain;
-
                     if (profit < 1)
                         profit = 1;
-
                     if (!buy.isCustomValue())
                         cost *= profit;
                     else
                         cost = buy.getValue();
-
-
                     if (gold.getNumOfItems() - cost < 0) {
                         ErrorPopupMsg.sendErrorPopup(sourcePlayer, 128);  // Insufficient Gold
                         return;
                     }
-
                     Building b = (!npc.isStatic()) ? npc.getBuilding() : null;
-
                     if (b != null)
                         if (b.getProtectionState().equals(ProtectionState.NPC))
                             b = null;
-
                     int buildingDeposit = cost;
-
+                    if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold() && !b.isOwnerIsNPC()) {
-                    if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold()) {
                         ErrorPopupMsg.sendErrorPopup(sourcePlayer, 206);
                         return;
                     }
-
                     if (!itemMan.buyFromNPC(b, cost, buildingDeposit)) {
                         ErrorPopupMsg.sendErrorPopup(sourcePlayer, 110);
                         return;
                     }
-
                     if (buy != null)
                         itemMan.buyFromNPC(buy, npc);
-
                 } else if (msg.getItemType() == GameObjectType.MobLoot.ordinal()) {
-
                     CharacterItemManager npcCim = npc.getCharItemManager();
-
                     if (npcCim == null)
                         return;
-
                     buy = MobLoot.getFromCache(msg.getItemID());
-
                     if (buy == null)
                         return;
-
                     ItemBase ib = buy.getItemBase();
-
                     if (ib == null)
                         return;
-
                     if (!npcCim.inventoryContains(buy))
                         return;
-
                     //test room available for item
                     if (!itemMan.hasRoomInventory(ib.getWeight()))
                         return;
-
                     //TODO test cost and subtract goldItem
-
                     //TODO CHnage this if we ever put NPc city npcs in buildings.
-
                     int cost = buy.getMagicValue();
                     cost *= npc.getSellPercent(sourcePlayer);
-
-
                     if (gold.getNumOfItems() - cost < 0) {
                         ErrorPopupMsg.sendErrorPopup(sourcePlayer, 128);  // Insufficient Gold
                         return;
                     }
-
                     Building b = (!npc.isStatic()) ? npc.getBuilding() : null;
-
                     if (b != null && b.getProtectionState().equals(ProtectionState.NPC))
                         b = null;
                     int buildingDeposit = cost;
-
+                    if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold() && !b.isOwnerIsNPC()) {
-                    if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold()) {
                         ErrorPopupMsg.sendErrorPopup(sourcePlayer, 206);
                         return;
                     }
-
                     if (!itemMan.buyFromNPC(b, cost, buildingDeposit))
                         return;
-
                     if (buy != null)
                         itemMan.buyFromNPC(buy, npc);
-
                 } else
                     return;
-
                 if (buy != null) {
-
                     msg.setItem(buy);
                     //send the buy message back to update player
                     //					msg.setItemType(buy.getObjectType().ordinal());
@@ -1579,14 +1576,43 @@ public class ClientMessagePump implements NetMsgHandler {
                     DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
                     itemMan.updateInventory();
                 }
-
             } finally {
                 origin.buyLock.unlock();
             }
         } else {
             ErrorPopupMsg.sendErrorPopup(origin.getPlayerCharacter(), 12); // All production slots taken
         }
+    }
 
+    public static void handleResourcePurchase(MobEquipment me, CharacterItemManager itemMan, PlayerCharacter sourcePlayer, ItemBase ib){
+        boolean stacked = false;
+        int buystack = Warehouse.getSellStackSize(me.getItemBase().getUUID());
+        for(Item item : itemMan.getInventory()){
+            int itemID = item.getItemBaseID();
+            int meID = me.getItemBase().getUUID();
+            if(itemID == meID){
+                if(Warehouse.maxResources.isEmpty())
+                    Warehouse.getMaxResources();
+                int maxStack = Warehouse.maxResources.get(itemID);
+                if(maxStack > item.getNumOfItems() + buystack){
+                    item.setNumOfItems(item.getNumOfItems() + buystack);
+                    stacked = true;
+                    itemMan.updateInventory();
+                    DbManager.ItemQueries.UPDATE_NUM_ITEMS(item,item.getNumOfItems());
+                    break;
+                }
+            }
+        }
+        if(!stacked){
+            Item buy = Item.createItemForPlayer(sourcePlayer, ib, false);
+            if (buy != null) {
+                me.transferEnchants(buy);
+                itemMan.addItemToInventory(buy);
+                buy.setNumOfItems(buystack);
+                DbManager.ItemQueries.UPDATE_NUM_ITEMS(buy,buy.getNumOfItems());
+            }
+        }
+        itemMan.updateInventory();
     }
 
     private static void Repair(RepairMsg msg, ClientConnection origin) {
@@ -1646,14 +1672,21 @@ public class ClientMessagePump implements NetMsgHandler {
             max *= (1 + (durMod * 0.01f));
             if (dur >= max || dur < 1) {
                 //redundancy message to clear item from window in client
+                if (!DbManager.ItemQueries.SET_DURABILITY(toRepair, dur))
+                    return;
                 toRepair.setDurabilityCurrent(max);
                 msg.setupRepairAck(max - dur);
                 dispatch = Dispatch.borrow(player, msg);
                 DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
                 return;
             }
-            //TODO get cost to repair
+
-            int cost = (int) ((max - dur) * 80.1);
+            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/ArcMineChangeProductionMsgHandler.java

@@ -11,6 +11,7 @@ import engine.objects.GuildStatusController;
 import engine.objects.Mine;
 import engine.objects.PlayerCharacter;
 import engine.objects.Resource;
+import org.pmw.tinylog.Logger;
 
 /*
  * @Author:
@@ -35,26 +36,28 @@ public class ArcMineChangeProductionMsgHandler extends AbstractClientMsgHandler
 
         //TODO verify this against the warehouse?
 
-        if (GuildStatusController.isInnerCouncil(playerCharacter.getGuildStatus()) == false) // is this only GL?
+        if (!GuildStatusController.isInnerCouncil(playerCharacter.getGuildStatus())) // is this only GL?
             return true;
 
         Mine mine = Mine.getMine(changeProductionMsg.getMineID());
 
-        if (mine == null)
+        if (mine == null) {
+            Logger.error("Player Character: " + playerCharacter.getName() + " Tried To Change Mine: " + changeProductionMsg.getMineID() + " and Mine was Null");
             return true;
-
+        }
         //make sure mine belongs to guild
 
-        if (mine.getOwningGuild().isEmptyGuild() ||
+        if (mine.getOwningGuild().isEmptyGuild() || mine.getOwningGuild().getObjectUUID() != playerCharacter.getGuild().getObjectUUID())
-                mine.getOwningGuild().getObjectUUID() != playerCharacter.getGuild().getObjectUUID())
             return true;
 
         //make sure valid resource
 
         Resource resource = Resource.resourceByHash.get(changeProductionMsg.getResourceHash());
 
-        if (resource == null)
+        if (resource == null) {
+            Logger.error("Player Character: " + playerCharacter.getName() + " Tried To Change Mine: " + changeProductionMsg.getMineID() + " and Resource was Null");
             return true;
+        }
 
         //update resource
 

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/CityDataHandler.java

@@ -63,7 +63,7 @@ public class CityDataHandler extends AbstractClientMsgHandler {
 
         // If the hotZone has changed then update the client's map accordingly.
 
-        if (playerCharacter.getTimeStamp("hotzoneupdate") <= ZoneManager.hotZoneLastUpdate.toEpochMilli() && ZoneManager.hotZone != null) {
+        if (playerCharacter.getTimestamps().containsKey("hotzoneupdate") && playerCharacter.getTimeStamp("hotzoneupdate") <= ZoneManager.hotZoneLastUpdate.toEpochMilli() && ZoneManager.hotZone != null) {
             HotzoneChangeMsg hotzoneChangeMsg = new HotzoneChangeMsg(Enum.GameObjectType.Zone.ordinal(), ZoneManager.hotZone.getObjectUUID());
             dispatch = Dispatch.borrow(playerCharacter, hotzoneChangeMsg);
             DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);

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

@@ -62,7 +62,7 @@ public class DestroyBuildingHandler extends AbstractClientMsgHandler {
         if (city != null)
             bane = city.getBane();
 
-        if (bane != null && bane.getSiegePhase() == Enum.SiegePhase.WAR) {
+        if (bane != null){// && bane.getSiegePhase() == Enum.SiegePhase.WAR) {
             ErrorPopupMsg.sendErrorPopup(pc, 171);
             return true;
         }

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

@@ -102,7 +102,7 @@ public class GroupInviteResponseHandler extends AbstractClientMsgHandler {
 
             // Run Keyclone Audit
 
-            KEYCLONEAUDIT.audit(player, group);
+            //KEYCLONEAUDIT.audit(player, group);
 
             return true;
         }

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/ItemProductionMsgHandler.java

@@ -360,6 +360,11 @@ public class ItemProductionMsgHandler extends AbstractClientMsgHandler {
                 targetItem.recycle(vendor);
                 vendor.removeItemFromForge(targetItem);
 
+                //refund the gold for cancelled item
+                if(vendor.building.getStrongboxValue() + targetItem.getItemBase().getBaseValue() < 15000000){
+                    vendor.building.setStrongboxValue(vendor.building.getStrongboxValue() + targetItem.getItemBase().getBaseValue());
+                }
+
                 // Refresh vendor's inventory to client
 
                 outMsg = new ManageNPCMsg(vendor);

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

@@ -62,16 +62,23 @@ public class MOTDEditHandler extends AbstractClientMsgHandler {
                 return true;
             }
 
-            if (type == 1) // Guild MOTD
+            if (type == 1) { // Guild MOTD
                 msg.setMessage(guild.getMOTD());
-            else if (type == 3) // IC MOTD
+                guild.updateDatabase();
+            }else if (type == 3) { // IC MOTD
                 msg.setMessage(guild.getICMOTD());
-            else if (type == 0) { // Nation MOTD
+                guild.updateDatabase();
+            }else if (type == 0) { // Nation MOTD
                 Guild nation = guild.getNation();
                 if (nation == null || !nation.isNation()) {
                     ErrorPopupMsg.sendErrorMsg(playerCharacter, "You do not have such authority!");
                     return true;
                 }
+                nation.setNMOTD(msg.getMessage());
+                nation.updateDatabase();
+                for(Guild sub : nation.getSubGuildList()){
+                    sub.setNMOTD(nation.getNMOTD());
+                }
                 msg.setMessage(nation.getMOTD());
             }
             dispatch = Dispatch.borrow(playerCharacter, msg);

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

@@ -17,6 +17,7 @@ import engine.powers.PowersBase;
 import engine.server.MBServerStatics;
 
 import java.util.ArrayList;
+import java.util.Objects;
 
 /*
  * @Author:
@@ -105,7 +106,7 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
 
         // Validate player can obtain blessing
 
-        if (GuildStatusController.isGuildLeader(player.getGuildStatus()) == false) {
+        if (!GuildStatusController.isGuildLeader(player.getGuildStatus())) {
             ErrorPopupMsg.sendErrorPopup(player, 173); // You must be the leader of a guild to receive a blessing
             return;
         }
@@ -126,12 +127,12 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
 
         realm = RealmMap.getRealmForCity(city);
 
-        if (realm.getCanBeClaimed() == false) {
+        if (!realm.getCanBeClaimed()) {
             ErrorPopupMsg.sendErrorPopup(player, 180); // This territory cannot be ruled by anyone
             return;
         }
 
-        if (realm.isRuled() == true) {
+        if (realm.isRuled()) {
             ErrorPopupMsg.sendErrorPopup(player, 178); // This territory is already claimed
             return;
         }
@@ -142,12 +143,12 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
 
     }
 
-    private static void requestBoon(MerchantMsg msg, ClientConnection origin, PlayerCharacter player, NPC npc) {
+    private static void requestBoon(PlayerCharacter player, NPC npc) {
 
         Building shrineBuilding;
         Shrine shrine;
 
-        if (npc.getGuild() != player.getGuild())
+        if (!npc.getGuild().getNation().equals(player.getGuild().getNation()))
             return;
 
         shrineBuilding = npc.getBuilding();
@@ -155,7 +156,7 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
         if (shrineBuilding == null)
             return;
 
-        if (shrineBuilding.getBlueprint() != null && shrineBuilding.getBlueprint().getBuildingGroup() != engine.Enum.BuildingGroup.SHRINE)
+        if (shrineBuilding.getBlueprint() != null && !shrineBuilding.getBlueprint().getBuildingGroup().equals(engine.Enum.BuildingGroup.SHRINE))
             return;
 
         if (shrineBuilding.getRank() == -1)
@@ -171,11 +172,9 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
             return;
         }
 
-        //already haz boon.
-
         if (player.containsEffect(shrine.getShrineType().getPowerToken())) {
-            ErrorPopupMsg.sendErrorPopup(player, 199);
+            //remove old boon to apply new one, allows boon refreshing
-            return;
+            player.effects.remove(PowersManager.getPowerByToken(shrine.getShrineType().getPowerToken()).name);
         }
 
         if (!Shrine.canTakeFavor(player, shrine))
@@ -191,16 +190,31 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
             return;
         }
 
-        int rank = shrine.getRank();
+        int trains = 0;
-        //R8 trees always get atleast rank 2 boons. rank uses index, where 0 is first place, 1 is second, etc...
+        switch(npc.getRank()){
-        if (shrineBuilding.getCity() != null && shrineBuilding.getCity().getTOL() != null && shrineBuilding.getCity().getTOL().getRank() == 8)
+            case 1:
-            if (rank != 0)
+                trains = 10;
-                rank = 1;
+                break;
-        int trains = 40 - (rank * 10);
+            case 2:
-        if (trains < 0)
+                trains = 15;
-            trains = 0;
+                break;
+            case 3:
+                trains = 20;
+                break;
+            case 4:
+                trains = 25;
+                break;
+            case 5:
+                trains = 30;
+                break;
+            case 6:
+                trains = 35;
+                break;
+            case 7:
+                trains = 40;
+                break;
+        }
 
-        //System.out.println(trains);
         PowersManager.applyPower(player, player, player.getLoc(), shrinePower.getToken(), trains, false);
         ChatManager.chatGuildInfo(player.getGuild(), player.getName() + " has recieved a boon costing " + 1 + " point of favor.");
         shrineBuilding.addEffectBit(1000000 << 2);
@@ -260,60 +274,85 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
             }
         }
 
-        if (targetCity == null)
+        if (targetCity == null){
-            return;
+            Mine mineTele = null;
-
+            for(Mine mine : Mine.getMinesToTeleportTo(player)){
-        //verify level required to teleport or repledge
+                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
 
-        Guild toGuild = targetCity.getGuild();
+            Guild toGuild = targetCity.getGuild();
 
-        if (toGuild != null)
+            if (toGuild != null)
-            if (isTeleport) {
+                if (isTeleport) {
-                if (player.getLevel() < toGuild.getTeleportMin() || player.getLevel() > toGuild.getTeleportMax())
+                    if (player.getLevel() < toGuild.getTeleportMin() || player.getLevel() > toGuild.getTeleportMax())
+                        return;
+                } else if (player.getLevel() < toGuild.getRepledgeMin() || player.getLevel() > toGuild.getRepledgeMax())
                     return;
-            } else if (player.getLevel() < toGuild.getRepledgeMin() || player.getLevel() > toGuild.getRepledgeMax())
-                return;
 
-        boolean joinedGuild = false;
+            boolean joinedGuild = false;
 
-        //if repledge, reguild the player
+            //if repledge, reguild the player
 
-        if (!isTeleport)
+            if (!isTeleport)
-            joinedGuild = GuildManager.joinGuild(player, targetCity.getGuild(), targetCity.getObjectUUID(), GuildHistoryType.JOIN);
+                joinedGuild = GuildManager.joinGuild(player, targetCity.getGuild(), targetCity.getObjectUUID(), GuildHistoryType.JOIN);
 
-        int time;
+            int time;
 
-        if (!isTeleport) //repledge
+            if (!isTeleport) //repledge
-            time = MBServerStatics.REPLEDGE_TIME_IN_SECONDS;
+                time = MBServerStatics.REPLEDGE_TIME_IN_SECONDS;
-        else
+            else
-            time = MBServerStatics.TELEPORT_TIME_IN_SECONDS;
+                time = MBServerStatics.TELEPORT_TIME_IN_SECONDS;
 
-        //resend message
+            //resend message
-        msg.setTeleportTime(time);
+            msg.setTeleportTime(time);
 
-        if ((!isTeleport && joinedGuild) || (isTeleport)) {
+            if ((!isTeleport && joinedGuild) || (isTeleport)) {
 
-            dispatch = Dispatch.borrow(player, msg);
+                dispatch = Dispatch.borrow(player, msg);
-            DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
+                DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
-        }
+            }
 
-        //teleport player to city
+            //teleport player to city
 
-        Vector3fImmutable teleportLoc;
+            Vector3fImmutable teleportLoc;
 
-        if (targetCity.getTOL().getRank() == 8)
+            if (targetCity.getTOL().getRank() == 8)
-            teleportLoc = targetCity.getTOL().getStuckLocation();
+                teleportLoc = targetCity.getTOL().getStuckLocation();
-        else
+            else
-            teleportLoc = Vector3fImmutable.getRandomPointOnCircle(targetCity.getTOL().getLoc(), MBServerStatics.TREE_TELEPORT_RADIUS);
+                teleportLoc = Vector3fImmutable.getRandomPointOnCircle(targetCity.getTOL().getLoc(), MBServerStatics.TREE_TELEPORT_RADIUS);
-
+
-        if (time > 0) {
+            if (time > 0) {
-            //TODO add timer to teleport
+                //TODO add timer to teleport
-            TeleportJob tj = new TeleportJob(player, npc, teleportLoc, origin, true);
+                TeleportJob tj = new TeleportJob(player, npc, teleportLoc, origin, true);
-            JobScheduler.getInstance().scheduleJob(tj, time * 1000);
+                JobScheduler.getInstance().scheduleJob(tj, time * 1000);
-        } else if (joinedGuild) {
+            } else if (joinedGuild) {
-            player.teleport(teleportLoc);
+                player.teleport(teleportLoc);
-            player.setSafeMode();
+                player.setSafeMode();
+            }
         }
+
+
     }
 
     private static PowersBase getPowerforHermit(NPC npc) {
@@ -420,7 +459,7 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
                 if (isHermit(npc))
                     requestHermitBlessing(msg, origin, player, npc);
                 else
-                    requestBoon(msg, origin, player, npc);
+                    requestBoon(player, npc);
                 break;
             case 15:
                 LeaderboardMessage lbm = new LeaderboardMessage();

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

@@ -421,31 +421,12 @@ public class ObjectActionMsgHandler extends AbstractClientMsgHandler {
                                 itemMan.consume(item);
                             }
                             break;
-                        //ANNIVERSERY GIFT
                         case 31:
-                            // *** Disabled for now: Needs bootyset created
-
-                            //if (ib.getUUID() == 971012) {
-                            //    int random = ThreadLocalRandom.current().nextInt(ItemBase.AnniverseryGifts.size());
-                            //    int annyID = ItemBase.AnniverseryGifts.get(random);
-
-                            //    ItemBase annyIB = ItemBase.getItemBase(annyID);
-                            //    if (annyIB != null) {
-                            //        Item gift = MobLoot.createItemForPlayer(player, annyIB);
-                            //        if (gift != null) {
-                            //            itemMan.addItemToInventory(gift);
-                            //            itemMan.consume(item);
-                            //        }
-                            //    }
-                            //    break;
-                            //}
-
                             LootManager.peddleFate(player,item);
                             break;
 
                         case 30: //water bucket
                         case 8: //potions, tears of saedron
-
                         case 5: //runes, petition, warrant, scrolls
                             if (uuid > 3000 && uuid < 3050) { //Discipline Runes
                                 if (ApplyRuneMsg.applyRune(uuid, origin, player)) {
@@ -462,7 +443,12 @@ public class ObjectActionMsgHandler extends AbstractClientMsgHandler {
                                     itemMan.consume(item);
                                 }
                                 break;
-                            } else if (uuid > 252122 && uuid < 252128) { //mastery runes
+                            } else if (uuid > 252122 && uuid < 252137) { //blood runes
+                                if (ApplyRuneMsg.applyRune(uuid, origin, player)) {
+                                    itemMan.consume(item);
+                                }
+                                break;
+                            } else if (uuid > 252128 && uuid < 252128) { //mastery runes
                                 if (ApplyRuneMsg.applyRune(uuid, origin, player)) {
                                     itemMan.consume(item);
                                 }
@@ -528,7 +514,6 @@ public class ObjectActionMsgHandler extends AbstractClientMsgHandler {
                                     }
 
                                     // Send piss bucket animation
-
                                     VisualUpdateMessage vum = new VisualUpdateMessage(player, 16323);
                                     vum.configure();
                                     DispatchMessage.sendToAllInRange(player, vum);
@@ -543,7 +528,9 @@ public class ObjectActionMsgHandler extends AbstractClientMsgHandler {
 
                             dispatch = Dispatch.borrow(player, msg);
                             DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
-                            player.cancelOnSpell();
+                            if(!item.getItemBase().getType().equals(ItemType.POTION)) {
+                                player.cancelOnSpell();
+                            }
                             break;
                         default: //shouldn't be here, consume item
                             dispatch = Dispatch.borrow(player, msg);

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/handlers/TaxCityMsgHandler.java

@@ -135,7 +135,8 @@ public class TaxCityMsgHandler extends AbstractClientMsgHandler {
 
         msg = (TaxCityMsg) baseMsg;
 
-        ViewTaxes(msg, player);
+        //realm taxing disabled
+        //ViewTaxes(msg, player);
 
 
         return true;

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

@@ -10,6 +10,7 @@
 package engine.net.client.msg;
 
 import engine.Enum;
+import engine.gameManager.ChatManager;
 import engine.gameManager.DbManager;
 import engine.net.*;
 import engine.net.client.ClientConnection;
@@ -70,62 +71,120 @@ public class ApplyRuneMsg extends ClientNetMsg {
     }
 
     public static boolean applyRune(int runeID, ClientConnection origin, PlayerCharacter playerCharacter) {
-
         RuneBase rb = RuneBase.getRuneBase(runeID);
         Dispatch dispatch;
-
         if (playerCharacter == null || origin == null || rb == null) {
             return false;
         }
-
+        int raceID = playerCharacter.getRaceID();
         //Check race is met
         ConcurrentHashMap<Integer, Boolean> races = rb.getRace();
-        if (races.size() > 0) {
+        if(runeID != 3007 && runeID != 3014) {//bounty hunter and huntsman
-            int raceID = playerCharacter.getRaceID();
+            if (races.size() > 0) {
-            boolean valid = false;
+                boolean valid = false;
-            for (int validID : races.keySet()) {
+                for (int validID : races.keySet()) {
-                if (validID == raceID) {
+                    if (validID == raceID) {
-                    valid = true;
+                        valid = true;
-                    break;
+                        break;
+                    }
                 }
-            }
+                if(runeID == 3040)
-            if (!valid) {
+                    valid = true;
-                return false;
-            }
-        }
 
-        //Check base class is met
+                if(runeID == 3049)
-        ConcurrentHashMap<Integer, Boolean> baseClasses = rb.getBaseClass();
-        if (baseClasses.size() > 0) {
-            int baseClassID = playerCharacter.getBaseClassID();
-            boolean valid = false;
-            for (int validID : baseClasses.keySet()) {
-                if (validID == baseClassID) {
                     valid = true;
-                    break;
+
+                if(raceID == 1999){
+                    switch(runeID){
+                        case 2514:
+                        case 3036:
+                        case 3033:
+                        case 3001:
+                        case 3002:
+                        case 3003:
+                        case 3004:
+                        case 3008:
+                        case 3009:
+                        case 3013:
+                        case 3016:
+                        case 3017:
+                        case 3018:
+                        case 3020:
+                        case 3021:
+                        case 3030:
+                        case 3031:
+                        case 3037:
+                        case 3045:
+                        case 3046:
+                        case 3047:
+                        case 3048:
+                        case 3049:
+                            valid = true;
+                            break;
+                    }
+                }
+                if (!valid) {
+                    return false;
                 }
             }
-            if (!valid) {
+            //Check base class is met
-                return false;
+            ConcurrentHashMap<Integer, Boolean> baseClasses = rb.getBaseClass();
+            if (baseClasses.size() > 0) {
+                int baseClassID = playerCharacter.getBaseClassID();
+                boolean valid = false;
+                for (int validID : baseClasses.keySet()) {
+                    if (validID == baseClassID) {
+                        valid = true;
+                        break;
+                    }
+                }
+                if(runeID == 3040)
+                    valid = true;
+                if(runeID == 3036 && raceID == 1999)
+                    valid = true;
+                if(runeID == 3033 && raceID == 1999)
+                    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;
+                }
             }
-        }
+            //Check promotion class is met
-
+            ConcurrentHashMap<Integer, Boolean> promotionClasses = rb.getPromotionClass();
-        //Check promotion class is met
+            if (promotionClasses.size() > 0) {
-        ConcurrentHashMap<Integer, Boolean> promotionClasses = rb.getPromotionClass();
+                int promotionClassID = playerCharacter.getPromotionClassID();
-        if (promotionClasses.size() > 0) {
+                int baseClassID = playerCharacter.getBaseClassID();
-            int promotionClassID = playerCharacter.getPromotionClassID();
+                boolean valid = false;
-            boolean valid = false;
+                for (int validID : promotionClasses.keySet()) {
-            for (int validID : promotionClasses.keySet()) {
+                    if (validID == promotionClassID) {
-                if (validID == promotionClassID) {
+                        valid = true;
+                        break;
+                    }
+                }
+                if(runeID == 3040)
                     valid = true;
-                    break;
+                if(runeID == 3004 && (playerCharacter.getPromotionClassID() == 2505 || playerCharacter.getPromotionClassID() == 2510))
+                    valid = true;
+                if(runeID == 3036 && raceID == 1999)
+                    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;
                 }
             }
-            if (!valid) {
+        } else{
+            if(playerCharacter.getPromotionClassID() == 2519){//priest
                 return false;
             }
         }
-
         //Check disciplines are met
         ArrayList<CharacterRune> runes = playerCharacter.getRunes();
         ConcurrentHashMap<Integer, Boolean> disciplines = rb.getDiscipline();
@@ -139,12 +198,11 @@ public class ApplyRuneMsg extends ClientNetMsg {
                 }
             }
         }
-
         int discCount = 0;
         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
@@ -152,28 +210,35 @@ public class ApplyRuneMsg extends ClientNetMsg {
                 return false;
             }
         }
-
         //Check level is met
         if (playerCharacter.getLevel() < rb.getLevelRequired()) {
             return false;
         }
-
         int strTotal = 0;
         int dexTotal = 0;
         int conTotal = 0;
         int intTotal = 0;
         int spiTotal = 0;
         int cost = 0;
-
         //Check any attributes are met
         ArrayList<RuneBaseAttribute> attrs = rb.getAttrs();
-
         if (rb.getAttrs() != null)
             for (RuneBaseAttribute rba : attrs) {
                 int attrID = rba.getAttributeID();
                 int mod = rba.getModValue();
                 switch (attrID) {
                     case MBServerStatics.RUNE_COST_ATTRIBUTE_ID:
+                        switch (rb.getName()) {
+                            case "Born of the Ethyri":
+                            case "Born of the Taripontor":
+                            case "Born of the Gwendannen":
+                            case "Born of the Invorri":
+                            case "Born of the Irydnu":
+                            case "Scion of the Dar Khelegeur":
+                            case "Scion of the Gwaridorn":
+                            case "Scion of the Twathedilion":
+                                mod = 0;
+                        }
                         if (mod > playerCharacter.getUnusedStatPoints()) {
                             return false;
                         }
@@ -226,25 +291,68 @@ public class ApplyRuneMsg extends ClientNetMsg {
                         break;
                 }
             }
-
         //Check if max number runes already reached
         if (runes.size() > 12) {
+            ChatManager.chatSystemInfo(playerCharacter,"You Have Too Many Runes Applied");
             return false;
         }
-
+        switch (rb.getName()) {
-        //if discipline, check number applied
+            case "Born of the Ethyri":
-        if (isDiscipline(runeID)) {
+            case "Born of the Taripontor":
-            if (playerCharacter.getLevel() < 70) {
+            case "Born of the Gwendannen":
-                if (discCount > 2) {
+            case "Born of the Invorri":
-                    return false;
+            case "Born of the Irydnu":
+                for (CharacterRune charRune : playerCharacter.getRunes()) {
+                    RuneBase rb2 = charRune.getRuneBase();
+                    switch (rb2.getName()) {
+                        case "Born of the Ethyri":
+                        case "Born of the Taripontor":
+                        case "Born of the Gwendannen":
+                        case "Born of the Invorri":
+                        case "Born of the Irydnu":
+                            ChatManager.chatSystemError(playerCharacter, "You Have Already Applied A Blood Rune");
+                            return false;
+                    }
                 }
-            } else {
+                break;
-                if (discCount > 3) {
+            case "Scion of the Dar Khelegeur":
-                    return false;
+            case "Scion of the Gwaridorn":
+            case "Scion of the Twathedilion":
+                for (CharacterRune charRune : playerCharacter.getRunes()) {
+                    RuneBase rb2 = charRune.getRuneBase();
+                    switch (rb2.getName()) {
+                        case "Scion of the Dar Khelegeur":
+                        case "Scion of the Gwaridorn":
+                        case "Scion of the Twathedilion":
+                            ChatManager.chatSystemError(playerCharacter, "You Have Already Applied A Blood Rune");
+                            return false;
+                    }
                 }
-            }
+                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:
+                    discAllowed = 3;
+                    break;
+                case 7:
+                case 8:
+                    discAllowed = 5;
+                    break;
+            }
 
+            if(discCount >= discAllowed)
+                return false;
+        }
         //Everything succeeded. Let's apply the rune
         //Attempt add rune to database
         CharacterRune runeWithoutID = new CharacterRune(rb, playerCharacter.getObjectUUID());
@@ -258,7 +366,6 @@ public class ApplyRuneMsg extends ClientNetMsg {
         if (cr == null) {
             return false;
         }
-
         //remove any overridden runes from player
         ArrayList<Integer> overwrite = rb.getOverwrite();
         CharacterRune toRemove = null;
@@ -267,13 +374,10 @@ public class ApplyRuneMsg extends ClientNetMsg {
                 toRemove = playerCharacter.removeRune(overwriteID);
             }
         }
-
         //add rune to player
         playerCharacter.addRune(cr);
-
         // recalculate all bonuses/formulas/skills/powers
         playerCharacter.recalculate();
-
         //if overwriting a stat rune, add any amount granted from previous rune.
         if (toRemove != null) {
             RuneBase rbs = toRemove.getRuneBase();
@@ -299,30 +403,35 @@ public class ApplyRuneMsg extends ClientNetMsg {
                 if (dif > 0 && spiTotal < (int) playerCharacter.statSpiMax) {
                     playerCharacter.addSpi(dif);
                 }
-
                 // recalculate all bonuses/formulas/skills/powers
                 playerCharacter.recalculate();
             }
         }
-
+        switch (rb.getName()) {
+            case "Born of the Ethyri":
+            case "Born of the Taripontor":
+            case "Born of the Gwendannen":
+            case "Born of the Invorri":
+            case "Born of the Irydnu":
+            case "Scion of the Dar Khelegeur":
+            case "Scion of the Gwaridorn":
+            case "Scion of the Twathedilion":
+                cost = 0;
+                break;
+        }
         if (cost > 0) {
             ModifyStatMsg msm = new ModifyStatMsg((0 - cost), 0, 3);
             dispatch = Dispatch.borrow(playerCharacter, msm);
             DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
         }
-
         //send apply rune message to client
         ApplyRuneMsg arm = new ApplyRuneMsg(playerCharacter.getObjectType().ordinal(), playerCharacter.getObjectUUID(), runeID, cr.getObjectType().ordinal(), cr.getObjectUUID(), false);
         dispatch = Dispatch.borrow(playerCharacter, arm);
         DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
-
-
         //alert them of success
         ErrorPopupMsg.sendErrorPopup(playerCharacter, 160);
-
         //reapply bonuses
         playerCharacter.applyBonuses();
-
         return true;
     }
 

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

@@ -112,6 +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 (man != null)

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

@@ -104,8 +104,10 @@ public class CityDataMsg extends ClientNetMsg {
         }
 
         temp.putInt(mineList.size());
-        for (Mine mine : mineList)
+        for (Mine mine : mineList) {
-            Mine.serializeForClientMsg(mine, temp);
+            if(mine.getParentZone() != null && !mine.getParentZone().isContinent())
+                Mine.serializeForClientMsg(mine, temp);
+        }
         temp.put((byte) 0); // PAD
     }
 
@@ -178,8 +180,10 @@ public class CityDataMsg extends ClientNetMsg {
                 }
 
                 writer.putInt(mineList.size());
-                for (Mine mine : mineList)
+                for (Mine mine : mineList) {
-                    Mine.serializeForClientMsg(mine, writer);
+                    if(mine.getParentZone() != null && !mine.getParentZone().isContinent())
+                        Mine.serializeForClientMsg(mine, writer);
+                }
             } else
                 writer.putInt(0);
         } catch (Exception e) {

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

@@ -275,7 +275,7 @@ public class ManageCityAssetsMsg extends ClientNetMsg {
 
                 writer.putString(npcHire.getName());
                 writer.putInt(1);
-                writer.putInt(Blueprint.getNpcMaintCost(npcHire.getRank()));
+                writer.putInt(0);
                 if (npcHire.getObjectType() == GameObjectType.NPC)
                     writer.putInt(((NPC) npcHire).getContract().getIconID()); // Was 60
                 else if (npcHire.getObjectType() == GameObjectType.Mob) {
@@ -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()))
+            //if (!bane.isAccepted() && this.assetManager.getGuild() == banedCity.getGuild() && GuildStatusController.isInnerCouncil(this.assetManager.getGuildStatus()))
-                writer.put((byte) 1); //canSetTime
+            //    writer.put((byte) 1); //canSetTime
-            else
+            //else
                 writer.put((byte) 0);
 
             DateTime placedOn = bane.getLiveDate();
@@ -485,36 +485,19 @@ public class ManageCityAssetsMsg extends ClientNetMsg {
 
             writer.putInt(building.getRank());
 
-            // Maintenance costs include resource if
+            writer.putInt(1); // Gold only
-            // this structure is an R8 tree
-
-            if (building.getRank() == 8)
-                writer.putInt(5); // Resources included
-            else
-                writer.putInt(1); // Gold only
 
             writer.putInt(2308551); //Gold
             if (building.getBlueprint() == null)
                 writer.putInt(0);
             else
-                writer.putInt(building.getBlueprint().getMaintCost(building.getRank())); //  maint cost
+                writer.putInt(building.getBlueprint().getMaintCost()); //  maint cost
-
-            if (building.getRank() == 8) {
-                writer.putInt(74856115); // Stone
-                writer.putInt(1500); //  maint cost
-                writer.putInt(-1603256692); // Lumber
-                writer.putInt(1500); //  maint cost
-                writer.putInt(-1596311545); // Galvor
-                writer.putInt(5); //  maint cost
-                writer.putInt(1532478436); // Wormwood
-                writer.putInt(5); //  maint cost
-            }
 
             LocalDateTime maintDate = building.maintDateTime;
 
             if (maintDate == null)
                 maintDate = LocalDateTime.now();
-            writer.putLocalDateTime(LocalDateTime.now()); // current time
+            writer.putLocalDateTime(maintDate); // current time
 
             // utc offset?
             writer.putInt((int) java.time.Duration.between(LocalDateTime.now(), maintDate).getSeconds()); // Seconds to maint date

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/ServerInfoMsg.java

@@ -11,6 +11,7 @@ package engine.net.client.msg;
 
 
 import engine.gameManager.ConfigManager;
+import engine.gameManager.DbManager;
 import engine.net.AbstractConnection;
 import engine.net.ByteBufferReader;
 import engine.net.ByteBufferWriter;
@@ -53,18 +54,45 @@ public class ServerInfoMsg extends ClientNetMsg {
 
         writer.putInt(WorldServer.worldMapID);
         writer.putString(ConfigManager.MB_WORLD_NAME.getValue());
-        if (LoginServer.population < MBServerStatics.LOW_POPULATION)
+        int TotalTrees = 21;
-            writer.putInt(0); //Land Rush
+        int currentR8Trees = DbManager.CityQueries.GET_CAPITAL_CITY_COUNT();
-        else if (LoginServer.population < MBServerStatics.NORMAL_POPULATION)
+
-            writer.putInt(1); //Low pop
+        switch(currentR8Trees){
-        else if (LoginServer.population < MBServerStatics.HIGH_POPULATION)
+            case 0:
-            writer.putInt(2); //Normal pop
+            case 1:
-        else if (LoginServer.population < MBServerStatics.VERY_OVERPOPULATED_POPULATION)
+            case 2:
-            writer.putInt(3); //High Pop
+            case 3:
-        else if (LoginServer.population < MBServerStatics.FULL_POPULATION)
+            case 4:
-            writer.putInt(4); //Very overpopulated pop
+                writer.putInt(0); //Land Rush
-        else
+                break;
-            writer.putInt(5); //Full pop
+            case 5:
+            case 6:
+            case 7:
+            case 8:
+                writer.putInt(1); //Low pop
+                break;
+            case 9:
+            case 10:
+            case 11:
+            case 12:
+                writer.putInt(2); //Normal pop
+                break;
+            case 13:
+            case 14:
+            case 15:
+            case 16:
+                writer.putInt(3); //High Pop
+                break;
+            case 17:
+            case 18:
+            case 19:
+            case 20:
+                writer.putInt(4); //Very overpopulated pop
+                break;
+            default:
+                writer.putInt(5); //Full pop
+                break;
+        }
     }
 
     /**

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

@@ -114,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)
+            if (contract == null)
-            vd = VendorDialog.getHostileVendorDialog();
-        else if (npc.getBuilding() != null) {
-            if (BuildingManager.IsPlayerHostile(npc.getBuilding(), playerCharacter))
                 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
+            if (vd == null)
-            vd = contract.getVendorDialog();
+                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);
         }
 
@@ -548,26 +558,59 @@ public class VendorDialogMsg extends ClientNetMsg {
 
         // verify race valid for profession
         Race race = pc.getRace();
-        if (race == null || !promo.isAllowedRune(race.getToken())) {
+        if(race.getRaceRuneID() == 1999) {
-            // TODO send client promotion error
+            boolean valid = false;
+        switch(promoID){
+            case 2504:
+            case 2505:
+            case 2506:
+            case 2507:
+            case 2510:
+            case 2511:
+            case 2512:
+            case 2514:
+            case 2515:
+            case 2517:
+            case 2518:
+            case 2519:
+            case 2520:
+            case 2521:
+            case 2523:
+                valid = true;
+                break;
+        }
+
+        if(!valid)
             return;
+
         }
+        else {
 
+            if (race == null || !promo.isAllowedRune(race.getToken())) {
+                // TODO send client promotion error
+                return;
+            }
+        }
         // verify baseclass valid for profession
         BaseClass bc = pc.getBaseClass();
-        if (bc == null || !promo.isAllowedRune(bc.getToken())) {
+        if (bc == null) {
             // TODO send client promotion error
             return;
         }
+        if(!promo.isAllowedRune(bc.getToken())){
+            if(!bc.getName().equals("Rogue") && !promo.getName().equals("Druid"))
+                return;
+        }
 
-        // verify gender
+        if(race.getRaceRuneID() != 1999) {
-        if (promoID == 2511 && pc.isMale()) // Fury
+            // verify gender
-            return;
+            if (promoID == 2511 && pc.isMale()) // Fury
-        if (promoID == 2512 && pc.isMale()) // Huntress
+                return;
-            return;
+            if (promoID == 2512 && pc.isMale()) // Huntress
-        if (promoID == 2517 && !pc.isMale()) // Warlock
+                return;
-            return;
+            if (promoID == 2517 && !pc.isMale()) // Warlock
-
+                return;
+        }
         // Everything valid. Let's promote
         pc.setPromotionClass(promo.getObjectUUID());
 
@@ -588,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.*;
-import engine.gameManager.ConfigManager;
-import engine.gameManager.MovementManager;
-import engine.gameManager.PowersManager;
 import engine.job.AbstractJob;
 import engine.job.JobContainer;
 import engine.job.JobScheduler;
@@ -91,17 +88,17 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
     protected Resists resists = new Resists("Genric");
     protected ConcurrentHashMap<String, JobContainer> timers;
     protected ConcurrentHashMap<String, Long> timestamps;
-    protected int atrHandOne;
+    public int atrHandOne;
     protected int atrHandTwo;
-    protected int minDamageHandOne;
+    public int minDamageHandOne;
-    protected int maxDamageHandOne;
+    public int maxDamageHandOne;
     protected int minDamageHandTwo;
     protected int maxDamageHandTwo;
     protected float rangeHandOne;
     protected float rangeHandTwo;
     protected float speedHandOne;
     protected float speedHandTwo;
-    protected int defenseRating;
+    public int defenseRating;
     protected boolean isActive; // <-Do not use this for deleting character!
     protected float altitude = 0; // 0=on terrain, 1=tier 1, 2=tier 2, etc.
     protected ConcurrentHashMap<Integer, JobContainer> recycleTimers;
@@ -496,8 +493,12 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
         boolean canFly = false;
         PlayerBonuses bonus = flyer.getBonuses();
 
-        if (bonus != null && !bonus.getBool(ModType.NoMod, SourceType.Fly) && bonus.getBool(ModType.Fly, SourceType.None) && flyer.isAlive())
+        if (bonus != null && !bonus.getBool(ModType.NoMod, SourceType.Fly) && bonus.getBool(ModType.Fly, SourceType.None) && flyer.isAlive()) {
             canFly = true;
+        }
+        if(flyer.effects.containsKey("MoveBuff")){
+            canFly = false;
+        }
 
         return canFly;
 
@@ -759,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() {
@@ -1096,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);
@@ -1104,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;
@@ -1187,10 +1185,15 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
         }
     }
 
-    public final float modifyHealth(
+    public final float modifyHealth(float value, final AbstractCharacter attacker, final boolean fromCost) {
-            final float value,
+
-            final AbstractCharacter attacker,
+        if(attacker != null && attacker.getObjectType().equals(GameObjectType.PlayerCharacter)){
-            final boolean fromCost) {
+            value *= ((PlayerCharacter)attacker).ZergMultiplier;
+        } // Health modifications are modified by the ZergMechanic
+
+        if(attacker != null && attacker.getObjectType().equals(GameObjectType.Mob) && ((Mob)attacker).getOwner() != null){
+            value *= ((Mob)attacker).getOwner().ZergMultiplier;
+        }// Health modifications from pets are modified by the owner's ZergMechanic
 
         try {
 
@@ -1254,11 +1257,19 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
     }
 
     public final float modifyMana(
-            final float value,
+            float value,
             final AbstractCharacter attacker,
             final boolean fromCost
     ) {
 
+        if(attacker != null && attacker.getObjectType().equals(GameObjectType.PlayerCharacter)){
+            value *= ((PlayerCharacter)attacker).ZergMultiplier;
+        } // Health modifications are modified by the ZergMechanic
+
+        if(attacker != null && attacker.getObjectType().equals(GameObjectType.Mob) && ((Mob)attacker).getOwner() != null){
+            value *= ((Mob)attacker).getOwner().ZergMultiplier;
+        }// Health modifications from pets are modified by the owner's ZergMechanic
+
         if (!this.isAlive()) {
             return 0f;
         }
@@ -1293,11 +1304,19 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
     }
 
     public final float modifyStamina(
-            final float value,
+            float value,
             final AbstractCharacter attacker,
             final boolean fromCost
     ) {
 
+        if(attacker != null && attacker.getObjectType().equals(GameObjectType.PlayerCharacter)){
+            value *= ((PlayerCharacter)attacker).ZergMultiplier;
+        } // Health modifications are modified by the ZergMechanic
+
+        if(attacker != null && attacker.getObjectType().equals(GameObjectType.Mob) && ((Mob)attacker).getOwner() != null){
+            value *= ((Mob)attacker).getOwner().ZergMultiplier;
+        }// Health modifications from pets are modified by the owner's ZergMechanic
+
         if (!this.isAlive()) {
             return 0f;
         }
@@ -1532,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);
@@ -1814,7 +1841,7 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
     }
 
     //updates
-    public void update() {
+    public void update(Boolean newSystem) {
     }
 
     public void updateRegen() {
@@ -1834,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.*;
-import engine.gameManager.ChatManager;
-import engine.gameManager.DbManager;
-import engine.gameManager.ZoneManager;
 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)
+        //add bane commander NPC
-            setDefaultTime();
+        //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();
+        if (DateTime.now().isAfter(timeToSetDefault)){
-        DateTime defaultTime = new DateTime(this.placementDate);
+            if(!this.capSet){
-        defaultTime = defaultTime.plusDays(2);
+                DbManager.BaneQueries.SET_BANE_CAP_NEW(20,this.getCityUUID());
-        defaultTime = defaultTime.hourOfDay().setCopy(22);
+                this.capSet = true;
-        defaultTime = defaultTime.minuteOfHour().setCopy(0);
+            }
-        defaultTime = defaultTime.secondOfMinute().setCopy(0);
+            if(!this.daySet){
-
+                DbManager.BaneQueries.SET_BANE_DAY_NEW(3,this.getCityUUID());
-        if (currentTime.isAfter(timeToSetDefault))
+                this.daySet = true;
-            this.setLiveDate(defaultTime);
+            }
-        else {
+            if(!this.timeSet){
-
+                DbManager.BaneQueries.SET_BANE_TIME_NEW(9,this.getCityUUID());
-            if (this.defaultTimeJob != null)
+                this.timeSet = true;
-                this.defaultTimeJob.cancelJob();
+            }
-
-            BaneDefaultTimeJob bdtj = new BaneDefaultTimeJob(this);
-            JobScheduler.getInstance().scheduleJob(bdtj, timeToSetDefault.getMillis());
-            this.defaultTimeJob = bdtj;
         }
     }
 
@@ -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

@@ -17,6 +17,7 @@ import org.pmw.tinylog.Logger;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.HashMap;
+import java.util.Objects;
 
 /*  @Summary - Blueprint class is used for determining
  characteristics of instanced player owned
@@ -60,13 +61,12 @@ public class Blueprint {
         this.name = rs.getString("MeshName");
         this.icon = rs.getInt("Icon");
         this.buildingGroup = BuildingGroup.valueOf(rs.getString("BuildingGroup"));
-        this.maxRank = rs.getInt("MaxRank");
         this.maxSlots = rs.getInt("MaxSlots");
         this.rank1UUID = rs.getInt("Rank1UUID");
         this.rank3UUID = rs.getInt("Rank3UUID");
         this.rank7UUID = rs.getInt("Rank7UUID");
         this.destroyedUUID = rs.getInt("DestroyedUUID");
-
+this.maxRank = rs.getInt("MaxRank");
     }
 
     // Accessors
@@ -108,9 +108,11 @@ public class Blueprint {
                 maxShrines = 2;
                 break;
             case 7:
-            case 8:
                 maxShrines = 3;
                 break;
+            case 8:
+                maxShrines = 4;
+                break;
             default:
                 maxShrines = 0;
 
@@ -167,20 +169,48 @@ public class Blueprint {
     // based upon the building's current rank
 
     public static int getNpcMaintCost(int rank) {
-        int maintCost = Integer.MAX_VALUE;
+        return 0;
-
-        maintCost = (9730 * rank) + 1890;
-
-        return maintCost;
     }
 
     public int getMaxRank() {
+        BuildingGroup bg = this.buildingGroup;
+        switch(bg){
+            case AMAZONHALL:
+            case CATHEDRAL:
+            case GREATHALL:
+            case KEEP:
+            case THIEFHALL:
+            case TEMPLEHALL:
+            case WIZARDHALL:
+            case ELVENHALL:
+            case ELVENSANCTUM:
+            case IREKEIHALL:
+            case FORESTHALL:
+                return 1;
+        }
         return maxRank;
     }
 
     public int getMaxSlots() {
         if (this.buildingGroup != null && this.buildingGroup.equals(BuildingGroup.BARRACK))
             return 1;
+        if (this.buildingGroup != null && this.buildingGroup.equals(BuildingGroup.TOL))
+            return 4;
+        BuildingGroup bg = this.buildingGroup;
+        switch(bg){
+            case AMAZONHALL:
+            case CATHEDRAL:
+            case GREATHALL:
+            case KEEP:
+            case THIEFHALL:
+            case TEMPLEHALL:
+            case WIZARDHALL:
+            case ELVENHALL:
+            case ELVENSANCTUM:
+            case IREKEIHALL:
+            case FORESTHALL:
+                return 3;
+        }
         return maxSlots;
     }
 
@@ -312,10 +342,28 @@ public class Blueprint {
             return 0;
 
         // Early exit for buildings with single or no slots
-
+        if (this.maxSlots <= 1 && !this.buildingGroup.equals(BuildingGroup.TOL))
-        if (this.maxSlots <= 1)
             return maxSlots;
 
+        BuildingGroup bg = this.buildingGroup;
+        switch(bg.name()) {
+            case "AMAZONHALL":
+            case "CATHEDRAL":
+            case "GREATHALL":
+            case "THIEFHALL":
+            case "TEMPLEHALL":
+            case "WIZARDHALL":
+            case "ELVENHALL":
+            case "ELVENSANCTUM":
+            case "IREKEIHALL":
+            case "FORESTHALL":
+                return 3;
+        }
+
+        if(bg != null && bg.equals(BuildingGroup.TOL) && currentRank == 8){
+            return 5;
+        }
+
         if (this.maxRank == 1 && currentRank == 1)
             return getMaxSlots();
 
@@ -327,20 +375,22 @@ public class Blueprint {
                 break;
             case 3:
             case 4:
-            case 5:
-            case 6:
                 availableSlots = 2;
                 break;
+            case 5:
+            case 6:
             case 7:
                 availableSlots = 3;
                 break;
             case 8:
-                availableSlots = 1;
+                availableSlots = 4;
                 break;
             default:
                 availableSlots = 0;
                 break;
         }
+        if(this.buildingGroup != null && this.buildingGroup.equals(BuildingGroup.TOL))
+            availableSlots += 1;
 
         return availableSlots;
     }
@@ -603,26 +653,14 @@ public class Blueprint {
         return this.blueprintUUID;
     }
 
-    public int getMaintCost(int rank) {
+    public int getMaintCost() {
 
         int maintCost = Integer.MAX_VALUE;
 
-        switch (this.buildingGroup) {
+        if(this.buildingGroup.equals(BuildingGroup.TOL)){
-            case TOL:
+            return 3000000;
-            case BARRACK:
+        }else{
-                maintCost = (61500 * rank) + 19500;
+            return 0;
-                break;
-            case SPIRE:
-                maintCost = (4800 * rank) + 1200;
-                break;
-            default:
-                if (maxRank == 1)
-                    maintCost = 22500;
-                else
-                    maintCost = (15900 * rank) + 3300;
-                break;
         }
-
-        return maintCost;
     }
 }

src/engine/objects/Building.java

@@ -160,28 +160,37 @@ 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);
             }
 
+            if(!this.ownerIsNPC){
+                //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);
+                        }
+                    }
+                }
+            }
+
             // Null out blueprint if not needed (npc building)
 
             if (blueprintUUID == 0)
@@ -403,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);
 
@@ -780,24 +805,9 @@ public class Building extends AbstractWorldObject {
 
     public int getMaintCost() {
 
-        int maintCost = 0;
+        if(this.getBlueprint() != null && this.getBlueprint().getBuildingGroup().equals(BuildingGroup.TOL))
-
+            return 3000000;
-        // Add cost for building structure
+        else return 0;
-
-        maintCost += this.getBlueprint().getMaintCost(rank);
-
-        // Add costs associated with hirelings
-
-        for (AbstractCharacter npc : this.hirelings.keySet()) {
-
-            if (npc.getObjectType() != GameObjectType.NPC)
-                continue;
-
-
-            maintCost += Blueprint.getNpcMaintCost(npc.getRank());
-        }
-
-        return maintCost;
     }
 
     public final void submitOpenDoorJob(int doorID) {
@@ -836,6 +846,10 @@ public class Building extends AbstractWorldObject {
         return this.meshScale;
     }
 
+    public void setMeshScale(Vector3f scale) {
+        this.meshScale = scale;
+    }
+
     public final int getMeshUUID() {
         return this.meshUUID;
     }
@@ -1123,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

@@ -610,6 +610,8 @@ public class CharacterItemManager {
         if (i == null)
             return false;
 
+        i.stripCastableEnchants();
+
         if (!this.doesCharOwnThisItem(i.getObjectUUID()))
             return false;
 
@@ -1054,6 +1056,7 @@ public class CharacterItemManager {
         // add to Bank
         this.bank.add(i);
         i.addToCache();
+        i.stripCastableEnchants();
 
         calculateWeights();
 
@@ -1202,6 +1205,7 @@ public class CharacterItemManager {
 
         calculateWeights();
 
+        i.stripCastableEnchants();
         return true;
     }
 
@@ -2009,6 +2013,7 @@ public class CharacterItemManager {
                     if (item.getItemBase().getType().equals(ItemType.GOLD)) {
                         int amt = item.getNumOfItems();
                         item.setNumOfItems(0);
+                        item.stripCastableEnchants();
                         MobLoot ml = new MobLoot(this.absCharacter, amt);
                         ml.zeroItem();
                         ml.containerType = Enum.ItemContainerType.INVENTORY;

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
@@ -992,6 +992,9 @@ public class CharacterSkill extends AbstractGameObject {
 
         //Get Base skill for unmodified stats
         float base = 7f;
+        if(this.skillsBase.getToken() == -660435875){
+            base = 0;
+        }
         float statMod = 0.5f;
         if (this.skillsBase.getStrMod() > 0)
             statMod += (float) this.skillsBase.getStrMod() * (float) (int) ((PlayerCharacter) CharacterSkill.GetOwner(this)).statStrBase / 100f;
@@ -1009,7 +1012,7 @@ public class CharacterSkill extends AbstractGameObject {
             statMod = 600f;
         base += CharacterSkill.baseSkillValues[(int) statMod];
 
-        if (base + bonus < 1f)
+        if (base + bonus < 1f && this.skillsBase.getToken() != -660435875)
             this.baseAmountBeforeMods = 1f;
         else
             this.baseAmountBeforeMods = base + bonus;
@@ -1084,6 +1087,9 @@ public class CharacterSkill extends AbstractGameObject {
         //Get Base skill for modified stats
         //TODO this fomula needs verified
         float base = 7f;
+        if(this.skillsBase.getToken() == -660435875){
+            base = 0;
+        }
         float statMod = 0.5f;
         if (this.skillsBase.getStrMod() > 0)
             statMod += (float) this.skillsBase.getStrMod() * (float) CharacterSkill.GetOwner(this).getStatStrCurrent() / 100f;
@@ -1099,6 +1105,9 @@ public class CharacterSkill extends AbstractGameObject {
             statMod = 1f;
         else if (statMod > 600)
             statMod = 600f;
+        if(this.skillsBase.getToken() == -660435875){
+            statMod = 0;
+        }
         base += CharacterSkill.baseSkillValues[(int) statMod];
         SourceType sourceType = SourceType.GetSourceType(this.skillsBase.getNameNoSpace());
 
@@ -1109,7 +1118,7 @@ public class CharacterSkill extends AbstractGameObject {
             base += bonus + CharacterSkill.GetOwner(this).getBonuses().getFloat(ModType.Skill, sourceType);
         }
 
-        if (base < 1f)
+        if (base < 1f && this.skillsBase.getToken() != -660435875)
             this.baseAmount = 1f;
         else
             this.baseAmount = base;

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
@@ -289,8 +309,11 @@ public class City extends AbstractWorldObject {
         else
             writer.putString(rulingNation.getName());
 
-        writer.putInt(city.getTOL().getRank());
+        if(city.getTOL() != null) {
-
+            writer.putInt(city.getTOL().getRank());
+        } else{
+            writer.putInt(1);
+        }
         if (city.isNoobIsle > 0)
             writer.putInt(1);
         else
@@ -317,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);
@@ -986,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) {
@@ -998,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;
 
@@ -1025,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()) {
@@ -1054,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);
+        _playerMemory.removeAll(toRemoveStandard);
-        for (Integer removalUUID : toRemove) {
+        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;
@@ -86,6 +91,15 @@ public class Contract extends AbstractGameObject {
         this.iconID = rs.getInt("iconID");
         this.vendorID = rs.getInt("vendorID");
         this.allowedBuildings = EnumBitSet.asEnumBitSet(rs.getLong("allowedBuildingTypeID"), Enum.BuildingGroup.class);
+        switch(this.contractID){
+            case 866: //banker
+            case 865: //siege engineer
+            case 899: //alchemist
+                this.allowedBuildings.add(Enum.BuildingGroup.TOL);
+        }
+        if(this.getName().toLowerCase().contains("sage")){
+            this.allowedBuildings.add(Enum.BuildingGroup.TOL);
+        }
         this.equipmentSet = rs.getInt("equipSetID");
         this.inventorySet = rs.getInt("inventorySet");
 
@@ -181,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;
     }
@@ -198,6 +494,92 @@ public class Contract extends AbstractGameObject {
     }
 
     public ArrayList<MobEquipment> getSellInventory() {
+        if(this.getObjectUUID() == 900){ //resource merchant
+            for(MobEquipment me : this.sellInventory){
+                if(me.getItemBase().getType().equals(Enum.ItemType.RESOURCE)){
+                    int amountResource = Warehouse.getSellStackSize(me.getItemBase().getUUID());
+                    me.magicValue = amountResource * me.getItemBase().getBaseValue();
+                } else{
+                    me.magicValue = 1000000;
+                }
+            }
+        }
+
+        if(this.getObjectUUID() == 1202){ //rune merchant
+            for(MobEquipment me : this.sellInventory){
+                switch(me.getItemBase().getUUID()){
+                    case 250001: //5 stats
+                    case 250010:
+                    case 250019:
+                    case 250028:
+                    case 250037:
+                        me.magicValue = 3000000;
+                        break;
+                    case 250002: //10 stats
+                    case 250011:
+                    case 250020:
+                    case 250029:
+                    case 250038:
+                        me.magicValue = 4000000;
+                        break;
+                    case 250003: //15 stats
+                    case 250012:
+                    case 250021:
+                    case 250030:
+                    case 250039:
+                        me.magicValue = 5000000;
+                        break;
+                    case 250004: //20 stats
+                    case 250013:
+                    case 250022:
+                    case 250031:
+                    case 250040:
+                        me.magicValue = 6000000;
+                        break;
+                    case 250005: //25 stats
+                    case 250014:
+                    case 250023:
+                    case 250032:
+                    case 250041:
+                        me.magicValue = 7000000;
+                        break;
+                    case 250006: //30 stats
+                    case 250015:
+                    case 250024:
+                    case 250033:
+                    case 250042:
+                        me.magicValue = 8000000;
+                        break;
+                    case 250007: //35 stats
+                    case 250016:
+                    case 250025:
+                    case 250034:
+                    case 250043:
+                        me.magicValue = 9000000;
+                        break;
+                    default:
+                        me.magicValue = 10000000;
+                        break;
+                }
+            }
+        }
+
+        if(this.getObjectUUID() == 1201){ //disc merchant
+            for(MobEquipment me : this.sellInventory){
+                if(me.getItemBase().getName().equals("Prospector")){
+                    me.magicValue = 500000;
+                }else{
+                    me.magicValue = 10000000;
+                }
+            }
+        }
+
+        if(this.getObjectUUID() == 1502041) {//noob helper{
+            for(MobEquipment me : this.sellInventory){
+                me.magicValue = 1;
+            }
+        }
+
         return this.sellInventory;
     }
 

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

@@ -9,6 +9,7 @@
 
 package engine.objects;
 
+import engine.Enum;
 import engine.Enum.TargetColor;
 import engine.gameManager.ZoneManager;
 import engine.math.Vector3fImmutable;
@@ -117,6 +118,11 @@ public class Experience {
             159932666, // Level 74
             169707808, // Level 75
             179921247, // Level 76
+            190585732,  // Level 77
+            201714185,  // Level 78
+            213319687,  // Level 79
+            225415457,   // Level 80
+            238014819   // Level 81
 
     };
 
@@ -214,7 +220,14 @@ public class Experience {
             235166.21f, // Level 72
             246039.34f, // Level 73
             257240.58f, // Level 74
-            1 // 268774.71 //Level 75
+            268774.71f, //Level 75
+            280647.69f, // Level 76
+            292865.22f, // Level 77
+            305433.33f, // Level 78
+            318358.08f, // Level 79
+
+            // R8
+            1 //331645.74f // Level 80
 
     };
     // Used to calcuate the amount of experience a monster grants in the
@@ -268,8 +281,8 @@ public class Experience {
         if (level < 1)
             level = 1;
 
-        if (level > 75)
+        if (level > MBServerStatics.LEVELCAP)
-            level = 75;
+            level = MBServerStatics.LEVELCAP;
 
         return MaxExpPerLevel[level];
     }
@@ -279,17 +292,17 @@ public class Experience {
 
         switch (TargetColor.getCon(pc, mob)) {
             case Red:
-                return 1.25;
+                return 1.1;
             case Orange:
                 return 1.15;
             case Yellow:
-                return 1.05;
+                return 1.2;
             case Blue:
-                return 1;
+                return 1.25;
             case Cyan:
-                return 0.8;
+                return 0.9;
             case Green:
-                return 0.5;
+                return 0.7;
             default:
                 return 0;
         }
@@ -333,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
@@ -383,10 +402,14 @@ public class Experience {
                 if (playerCharacter.getLevel() >= MBServerStatics.LEVELCAP)
                     continue;
 
+                if(playerCharacter.level >= 75 && !mob.getObjectType().equals(Enum.GameObjectType.PlayerCharacter))
+                    continue; // cannot PVE higher than level 75
+
                 // Sets Max XP with server exp mod taken into account.
 
                 grantedExperience = (double) LOOTMANAGER.NORMAL_EXP_RATE * maxXPPerKill(playerCharacter.getLevel());
 
+                grantedExperience *= (1/ giveEXPTo.size()+0.9);
                 // Adjust XP for Mob Level
 
                 grantedExperience *= getConMod(playerCharacter, mob);
@@ -428,12 +451,15 @@ public class Experience {
             }
 
         } else { // Give EXP to a single character
-            if (!killer.isAlive()) // Skip if the player is dead.
+            //if (!killer.isAlive()) // Skip if the player is dead.
-                return;
+             //   return;
 
             if (killer.getLevel() >= MBServerStatics.LEVELCAP)
                 return;
 
+            if(killer.level >= 75 && !mob.getObjectType().equals(Enum.GameObjectType.PlayerCharacter))
+                return;
+
             // Get XP and adjust for Mob Level with world xp modifier taken into account
             grantedExperience = (double) LOOTMANAGER.NORMAL_EXP_RATE * maxXPPerKill(killer.getLevel());
             grantedExperience *= getConMod(killer, mob);

src/engine/objects/Guild.java

@@ -521,6 +521,10 @@ public class Guild extends AbstractWorldObject {
     public void setICMOTD(String value) {
         this.icmotd = value;
     }
+    public void setNMOTD(String value) {
+        this.nmotd = value;
+    }
+    public String getNMOTD(){return nmotd;}
 
     public boolean isNPCGuild() {
 
@@ -752,9 +756,9 @@ public class Guild extends AbstractWorldObject {
                 canSub = false;
         }
         City nationCap = City.getCity(nation.cityUUID);
-        if (nation.getSubGuildList().size() >= nationCap.getRank()) {
+        //if (nation.getSubGuildList().size() >= nationCap.getRank()) {
-            canSub = false;
+        //    canSub = false;
-        }
+        //}
         return canSub;
     }
 

src/engine/objects/Item.java

@@ -23,6 +23,7 @@ import engine.net.client.ClientConnection;
 import engine.net.client.msg.DeleteItemMsg;
 import engine.powers.EffectsBase;
 import engine.powers.effectmodifiers.AbstractEffectModifier;
+import engine.powers.effectmodifiers.WeaponProcEffectModifier;
 import engine.powers.poweractions.AbstractPowerAction;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
@@ -233,7 +234,6 @@ public class Item extends AbstractWorldObject {
         this.value = rs.getInt("item_value");
         this.customName = rs.getString("item_name");
 
-
     }
 
     public static void _serializeForClientMsg(Item item, ByteBufferWriter writer)
@@ -303,7 +303,7 @@ public class Item extends AbstractWorldObject {
             writer.putString(item.customName); // Unknown. pad?
         writer.put((byte) 1); // End Datablock byte
 
-        writer.putFloat((float) item.durabilityMax);
+        writer.putFloat((float) item.getDurabilityMax());
         writer.putFloat((float) item.durabilityCurrent);
 
         writer.put((byte) 1); // End Datablock byte
@@ -609,7 +609,7 @@ public class Item extends AbstractWorldObject {
         writer.putIntAt(serialized, indexPosition);
     }
 
-    public static Item createItemForPlayer(PlayerCharacter pc, ItemBase ib) {
+    public static Item createItemForPlayer(PlayerCharacter pc, ItemBase ib, boolean fromNoob) {
         Item item = null;
         byte charges = 0;
 
@@ -817,8 +817,29 @@ public class Item extends AbstractWorldObject {
         return ownerID;
     }
 
+    public void stripCastableEnchants(){
+        ArrayList<String> keys =new ArrayList<>();
+
+        for(String eff : this.effects.keySet()){
+            for(AbstractEffectModifier mod : this.effects.get(eff).getEffectsBase().getModifiers()){
+                if(mod.modType.equals(ModType.WeaponProc)){
+                    keys.add(eff);
+                }
+            }
+        }
+
+        for(String eff : keys){
+            try {
+                this.effects.get(eff).endEffect();
+                this.effects.remove(eff);
+            }catch(Exception e){
+
+            }
+        }
+    }
     //Only to be used for trading
     public void setOwnerID(int ownerID) {
+        this.stripCastableEnchants();
         this.ownerID = ownerID;
     }
 
@@ -842,6 +863,7 @@ public class Item extends AbstractWorldObject {
     public boolean setOwner(AbstractGameObject owner) {
         if (owner == null)
             return false;
+        this.stripCastableEnchants();
         if (owner.getObjectType().equals(GameObjectType.NPC))
             this.ownerType = OwnerType.Npc;
         else if (owner.getObjectType().equals(GameObjectType.PlayerCharacter))
@@ -885,7 +907,15 @@ public class Item extends AbstractWorldObject {
     }
 
     public short getDurabilityMax() {
-        return durabilityMax;
+        int extra = 0;
+        for(Effect eff : this.effects.values()){
+            for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                if(mod.modType.equals(ModType.Durability)){
+                    extra += mod.getMaxMod();
+                }
+            }
+        }
+        return (short)(durabilityMax + extra);
     }
 
     public boolean isCanDestroy() {
@@ -948,6 +978,7 @@ public class Item extends AbstractWorldObject {
     }
 
     public boolean isID() {
+        this.flags |= 1;
         return ((this.flags & 1) > 0);
     }
 
@@ -1054,6 +1085,7 @@ public class Item extends AbstractWorldObject {
         this.ownerID = pc.getObjectUUID();
         this.ownerType = OwnerType.PlayerCharacter;
         this.containerType = ItemContainerType.INVENTORY;
+        this.stripCastableEnchants();
         return true;
     }
 
@@ -1074,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;
     }
 
@@ -1091,6 +1124,7 @@ public class Item extends AbstractWorldObject {
         this.ownerID = 0;
         this.ownerType = null;
         this.containerType = Enum.ItemContainerType.INVENTORY;
+        this.stripCastableEnchants();
         return true;
     }
 
@@ -1193,10 +1227,14 @@ 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() {
+
         if (this.getItemBase() != null)
             return this.getItemBase().getBaseValue();
         return 0;
@@ -1240,7 +1278,9 @@ public class Item extends AbstractWorldObject {
                     continue;
                 }
                 AbstractPowerAction apa = PowersManager.getPowerActionByIDString(effect.getIDString());
-                apa.applyBakedInStatsForItem(this, this.getItemBase().getBakedInStats().get(token));
+
+                if(apa != null)
+                    apa.applyBakedInStatsForItem(this, this.getItemBase().getBakedInStats().get(token));
             }
     }
 
@@ -1452,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

@@ -75,7 +75,8 @@ public class ItemBase {
     private boolean isStrBased;
     private ArrayList<Integer> animations = new ArrayList<>();
     private ArrayList<Integer> offHandAnimations = new ArrayList<>();
-    private boolean autoID = false;
+
+    public float dexReduction = 0.0f;
 
     /**
      * ResultSet Constructor
@@ -145,8 +146,6 @@ public class ItemBase {
 
         }
 
-        this.autoIDItemsCheck();
-
         try {
             DbManager.ItemBaseQueries.LOAD_ANIMATIONS(this);
         } catch (Exception e) {
@@ -154,7 +153,7 @@ public class ItemBase {
         }
         initBakedInStats();
         initializeHashes();
-
+        initDexReduction();
     }
 
     public static void addToCache(ItemBase itemBase) {
@@ -232,7 +231,79 @@ public class ItemBase {
         AnniverseryGifts.add(5101060);
         AnniverseryGifts.add(5101080);
 
-
+        //fate peddler presents
+        AnniverseryGifts.add(971012);
+        AnniverseryGifts.add(971013);
+        AnniverseryGifts.add(971014);
+        AnniverseryGifts.add(971015);
+        AnniverseryGifts.add(971016);
+        AnniverseryGifts.add(971017);
+        AnniverseryGifts.add(971018);
+        AnniverseryGifts.add(971019);
+        AnniverseryGifts.add(971020);
+        AnniverseryGifts.add(971021);
+        AnniverseryGifts.add(971022);
+        AnniverseryGifts.add(971023);
+    }
+
+    public static int getDiscPrice(int uuid) {
+        if(uuid == 3040)
+            return 500000;
+        else return 10000000;
+    }
+
+    public static int getStatPrice(int uuid) {
+        switch(uuid){
+            case 250001: //5 stats
+            case 250010:
+            case 250019:
+            case 250028:
+            case 250037:
+                return 3000000;
+            case 250002: //10 stats
+            case 250011:
+            case 250020:
+            case 250029:
+            case 250038:
+                return 4000000;
+            case 250003: //15 stats
+            case 250012:
+            case 250021:
+            case 250030:
+            case 250039:
+                return 5000000;
+            case 250004: //20 stats
+            case 250013:
+            case 250022:
+            case 250031:
+            case 250040:
+                return 6000000;
+            case 250005: //25 stats
+            case 250014:
+            case 250023:
+            case 250032:
+            case 250041:
+                return 7000000;
+            case 250006: //30 stats
+            case 250015:
+            case 250024:
+            case 250033:
+            case 250042:
+                return 8000000;
+            case 250007: //35 stats
+            case 250016:
+            case 250025:
+            case 250034:
+            case 250043:
+                return 9000000;
+            case 250008: //40 stats
+            case 250017:
+            case 250026:
+            case 250035:
+            case 250044:
+                return 10000000;
+        }
+        return 10000000;
     }
 
     /*
@@ -250,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;
@@ -372,74 +447,10 @@ public class ItemBase {
         return modTable;
     }
 
-    public int getVendorType() {
-        return vendorType;
-    }
-
-    public void setVendorType(int vendorType) {
-        this.vendorType = vendorType;
-    }
-
     public int getHashID() {
         return hashID;
     }
 
-    public void setHashID(int hashID) {
-        this.hashID = hashID;
-    }
-
-    private void autoIDItemsCheck() {
-        //AUto ID Vorg and Glass
-        switch (uuid) {
-
-            case 27550:
-            case 27560:
-            case 27580:
-            case 27590:
-            case 188500:
-            case 188510:
-            case 188520:
-            case 188530:
-            case 188540:
-            case 188550:
-            case 189100:
-            case 189110:
-            case 189120:
-            case 189130:
-            case 189140:
-            case 189150:
-            case 189510:
-            case 27600:
-            case 181840:
-            case 188700:
-            case 188720:
-            case 189550:
-            case 189560:
-            case 7000100:
-            case 7000110:
-            case 7000120:
-            case 7000130:
-            case 7000140:
-            case 7000150:
-            case 7000160:
-            case 7000170:
-            case 7000180:
-            case 7000190:
-            case 7000200:
-            case 7000210:
-            case 7000220:
-            case 7000230:
-            case 7000240:
-            case 7000250:
-            case 7000270:
-            case 7000280:
-                this.autoID = true;
-                break;
-            default:
-                this.autoID = false;
-        }
-    }
-
     public boolean validForSkills(ConcurrentHashMap<String, CharacterSkill> skills) {
 
         CharacterSkill characterSkill;
@@ -906,12 +917,4 @@ public class ItemBase {
     public void setOffHandAnimations(ArrayList<Integer> offHandAnimations) {
         this.offHandAnimations = offHandAnimations;
     }
-
-    public boolean isAutoID() {
-        return autoID;
-    }
-
-    public void setAutoID(boolean autoID) {
-        this.autoID = autoID;
-    }
 }

src/engine/objects/ItemFactory.java

@@ -73,7 +73,7 @@ public class ItemFactory {
         itemManager.updateInventory();
     }
 
-    public static Item fillForge(NPC npc, PlayerCharacter pc, int itemsToRoll, int itemID, int pToken, int sToken, String customName) {
+    public static Item ResourceRoll(NPC npc, PlayerCharacter pc, int itemsToRoll, int itemID, int pToken, int sToken, String customName) {
 
         String prefixString = "";
         String suffixString = "";
@@ -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;
             }
 
@@ -707,7 +707,7 @@ public class ItemFactory {
 
         if (rollPrefix < 80) {
 
-            int randomPrefix = LootManager.TableRoll(vendor.getLevel(), false);
+            int randomPrefix = TableRoll(vendor.getLevel());
             prefixEntry = ModTableEntry.rollTable(prefixTypeTable.modTableID, randomPrefix);
 
             if (prefixEntry != null)
@@ -722,7 +722,7 @@ public class ItemFactory {
 
         if (rollSuffix < 80 || prefixEntry == null) {
 
-            int randomSuffix = LootManager.TableRoll(vendor.getLevel(), false);
+            int randomSuffix = TableRoll(vendor.getLevel());
             suffixEntry = ModTableEntry.rollTable(suffixTypeTable.modTableID, randomSuffix);
 
             if (suffixEntry != null)
@@ -774,6 +774,43 @@ public class ItemFactory {
         return toRoll;
     }
 
+    public static int TableRoll(int vendorLevel) {
+        // Calculate min and max based on mobLevel
+        int min = 60;
+        int max = 120;
+        switch(vendorLevel){
+            case 20:
+                min = 70;
+                max = 140;
+                break;
+            case 30:
+                min = 80;
+                max = 160;
+                break;
+            case 40:
+                min = 90;
+                max = 180;
+                break;
+            case 50:
+                min = 100;
+                max = 200;
+                break;
+            case 60:
+                min = 175;
+                max = 260;
+                break;
+            case 70:
+                min = 220;
+                max = 320;
+                break;
+        }
+
+        int roll = ThreadLocalRandom.current().nextInt(min, max + 1);
+
+        return roll;
+    }
+
+
     public static MobLoot produceRandomRoll(NPC npc, PlayerCharacter pc, String prefixString, String suffixString, int itemID) {
 
         boolean useWarehouse = false;
@@ -885,8 +922,8 @@ public class ItemFactory {
 
             ItemBase goldIB = ItemBase.getGoldItemBase();
 
-            int baseCost = ib.getBaseValue();
+            //int baseCost = ib.getBaseValue();
-            int total = (int) (baseCost + baseCost * .10);
+            int total = ib.getBaseValue();
 
             EffectsBase suffix = null;
 
@@ -899,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

@@ -10,11 +10,11 @@
 package engine.objects;
 
 import engine.Enum;
+import engine.InterestManagement.InterestManager;
 import engine.InterestManagement.WorldGrid;
-import engine.gameManager.BuildingManager;
+import engine.gameManager.*;
-import engine.gameManager.ChatManager;
+import engine.math.Vector3f;
-import engine.gameManager.DbManager;
+import engine.math.Vector3fImmutable;
-import engine.gameManager.ZoneManager;
 import engine.net.ByteBufferWriter;
 import engine.net.client.msg.ErrorPopupMsg;
 import engine.server.MBServerStatics;
@@ -25,6 +25,9 @@ import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.concurrent.ConcurrentHashMap;
 
 import static engine.gameManager.DbManager.MineQueries;
@@ -51,20 +54,48 @@ public class Mine extends AbstractGameObject {
     private int buildingID;
     private MineProduction mineType;
 
+    public int openHour;
+    public int openMinute;
+    public int capSize;
+    public LocalDateTime liveTime;
+    public final HashSet<Integer> _playerMemory = new HashSet<>();
+    public ArrayList<PlayerCharacter> affectedPlayers = new ArrayList<>();
+
+    //stronghold stuff
+    public boolean isStronghold = false;
+    public ArrayList<Mob> strongholdMobs;
+    public HashMap<Integer,Integer> oldBuildings;
+
     /**
      * ResultSet Constructor
      */
     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);
+        if(ZoneManager.getZoneByUUID(parent) != null) {
-        this.zoneName = this.parentZone.getParent().getName();
+            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;
@@ -90,7 +121,15 @@ public class Mine extends AbstractGameObject {
 
         this.production = Resource.valueOf(rs.getString("mine_resource"));
         this.lastClaimer = null;
-
+        this.openHour = rs.getInt("mineLiveHour");
+        this.openMinute = rs.getInt("mineLiveMinute");
+        this.capSize = rs.getInt("capSize");
+        this.liveTime = LocalDateTime.now().withHour(this.openHour).withMinute(this.openMinute);
+        Building tower = BuildingManager.getBuildingFromCache(this.buildingID);
+        if(tower != null){
+            tower.setMaxHitPoints(5000f * this.capSize);
+            tower.setCurrentHitPoints(tower.healthMax);
+        }
     }
 
     public static void releaseMineClaims(PlayerCharacter playerCharacter) {
@@ -143,8 +182,10 @@ public class Mine extends AbstractGameObject {
             ArrayList<Mine> serverMines = MineQueries.GET_ALL_MINES_FOR_SERVER();
 
             for (Mine mine : serverMines) {
-                Mine.mineMap.put(mine, mine.buildingID);
+                if(mine.capSize != 0) {
-                Mine.towerMap.put(mine.buildingID, mine);
+                    Mine.mineMap.put(mine, mine.buildingID);
+                    Mine.towerMap.put(mine.buildingID, mine);
+                }
             }
 
         } catch (Exception e) {
@@ -161,56 +202,58 @@ public class Mine extends AbstractGameObject {
     }
 
     public static void serializeForClientMsg(Mine mine, ByteBufferWriter writer) {
-        writer.putInt(mine.getObjectType().ordinal());
+        try {
-        writer.putInt(mine.getObjectUUID());
+            writer.putInt(mine.getObjectType().ordinal());
-        writer.putInt(mine.getObjectUUID()); //actually a hash of mine
+            writer.putInt(mine.getObjectUUID());
-        writer.putString(mine.mineType.name);
+            writer.putInt(mine.getObjectUUID()); //actually a hash of mine
-        writer.putString(mine.zoneName);
+            if(mine.isStronghold){
-        writer.putInt(mine.production.hash);
+                writer.putString("STRONGHOLD");
-        writer.putInt(mine.production.baseProduction);
+                writer.putString("");
-        writer.putInt(mine.getModifiedProductionAmount()); //TODO calculate range penalty here
+            }else {
-        writer.putInt(3600); //window in seconds
+                writer.putString(mine.mineType.name);
-
+                writer.putString(mine.capSize + " Man ");
-        // Errant mines are currently open.  Set time to now.
+            }
-
+            //writer.putString(mine.zoneName + " " + mine.capSize + " Man ");
-        LocalDateTime mineOpenTime = LocalDateTime.now().withMinute(0).withSecond(0).withNano(0);
+
-
+            writer.putInt(mine.production.hash);
-        // Mine times are those of the nation not individual guild.
+            writer.putInt(mine.production.baseProduction);
-
+            writer.putInt(mine.getModifiedProductionAmount()); //TODO calculate range penalty here
-        Guild mineNatonGuild = mine.getOwningGuild().getNation();
+            writer.putInt(3600); //window in seconds
-
+
-        // Adjust the serialized mine time based upon whether
+            LocalDateTime mineOpenTime = LocalDateTime.now().withHour(mine.openHour).withMinute(mine.openMinute).withSecond(0).withNano(0);
-        // the Guild's mine window has passed or not and if it was claimed.
+
-        // If a mine is active serialize current datetime irrespective
+            writer.putLocalDateTime(mineOpenTime);
-        // of any claim.
+            writer.putLocalDateTime(mineOpenTime.plusMinutes(30));
-
+            writer.put(mine.isActive ? (byte) 0x01 : (byte) 0x00);
-        if (mineNatonGuild.isEmptyGuild() == false && mine.isActive == false) {
+
-
+            Building mineTower = BuildingManager.getBuilding(mine.buildingID);
-            int guildWOO = mineNatonGuild.getNation().getMineTime();
+            if (mineTower != null) {
-            LocalDateTime guildMineTime = mineOpenTime.withHour(guildWOO);
+                writer.putFloat(mineTower.getLoc().x);
-
+                writer.putFloat(mineTower.getParentZone().getLoc().y);
-            if (mineOpenTime.isAfter(guildMineTime) || mine.wasClaimed == true)
+                writer.putFloat(mineTower.getLoc().z);
-                mineOpenTime = guildMineTime.plusDays(1);
+            } else {
-            else
+                writer.putFloat(mine.parentZone.getLoc().x);
-                mineOpenTime = guildMineTime;
+                writer.putFloat(mine.parentZone.getLoc().y);
+                writer.putFloat(mine.parentZone.getLoc().z);
+                Logger.error("Mine Tower Was Null For Mine: " + mine.getObjectUUID());
+            }
 
+            writer.putInt(mine.isExpansion() ? mine.mineType.xpacHash : mine.mineType.hash);
+
+            if (mine.isStronghold) {
+                writer.putString("");
+                GuildTag._serializeForDisplay(Guild.getErrantGuild().getGuildTag(), writer);
+                writer.putString("");
+                GuildTag._serializeForDisplay(Guild.getErrantGuild().getGuildTag(), writer);
+            }else {
+                writer.putString(mine.guildName);
+                GuildTag._serializeForDisplay(mine.guildTag, writer);
+                writer.putString(mine.nationName);
+                GuildTag._serializeForDisplay(mine.nationTag, writer);
+            }
+        } catch (Exception e) {
+            Logger.error("Failed TO Serialize Mine Because: " + e.getMessage());
         }
-
-        writer.putLocalDateTime(mineOpenTime);
-        writer.putLocalDateTime(mineOpenTime.plusHours(1));
-        writer.put(mine.isActive ? (byte) 0x01 : (byte) 0x00);
-
-        Building mineTower = BuildingManager.getBuilding(mine.buildingID);
-        writer.putFloat(mineTower.getLoc().x);
-        writer.putFloat(mineTower.getParentZone().getLoc().y);
-        writer.putFloat(mineTower.getLoc().z);
-
-        writer.putInt(mine.isExpansion() ? mine.mineType.xpacHash : mine.mineType.hash);
-
-        writer.putString(mine.guildName);
-        GuildTag._serializeForDisplay(mine.guildTag, writer);
-        writer.putString(mine.nationName);
-        GuildTag._serializeForDisplay(mine.nationTag, writer);
     }
 
     public static ArrayList<Mine> getMinesForGuild(int guildID) {
@@ -220,8 +263,7 @@ public class Mine extends AbstractGameObject {
         // Only inactive mines are returned.
 
         for (Mine mine : Mine.mineMap.keySet()) {
-            if (mine.owningGuild.getObjectUUID() == guildID &&
+            if (mine.owningGuild.getObjectUUID() == guildID)
-                    mine.isActive == false)
                 mineList.add(mine);
         }
         return mineList;
@@ -290,24 +332,18 @@ public class Mine extends AbstractGameObject {
         if (treeRank < 1)
             return false;
 
-        if (guildUnderMineLimit(playerGuild.getNation(), treeRank) == false) {
-            ErrorPopupMsg.sendErrorMsg(playerCharacter, "Your nation cannot support another mine.");
-            return false;
-        }
-
         return true;
     }
 
-    private static boolean guildUnderMineLimit(Guild playerGuild, int tolRank) {
+    public static ArrayList<Mine> getMinesToTeleportTo(PlayerCharacter player) {
-
+        ArrayList<Mine> mines = new ArrayList<>();
-        int mineCnt = 0;
+        for(Mine mine : Mine.getMines())
+            if(!mine.isActive)
+                if(mine.getOwningGuild() != null)
+                  if(mine.getOwningGuild().getNation().equals(player.getGuild().getNation()))
+                         mines.add(mine);
 
-        mineCnt += Mine.getMinesForGuild(playerGuild.getObjectUUID()).size();
+        return mines;
-
-        for (Guild guild : playerGuild.getSubGuildList())
-            mineCnt += Mine.getMinesForGuild(guild.getObjectUUID()).size();
-
-        return mineCnt <= tolRank;
     }
 
     public boolean changeProductionType(Resource resource) {
@@ -378,12 +414,24 @@ public class Mine extends AbstractGameObject {
         Building building = BuildingManager.getBuildingFromCache(this.buildingID);
         if (building != null && !this.isActive)
             building.isDeranking.compareAndSet(true, false);
+
+        if(!isAc){
+            for(PlayerCharacter player : this.affectedPlayers){
+                try {
+                    player.ZergMultiplier = 1.0f;
+                } catch(Exception e){
+                    //something went wrong resetting zerg multiplier, maybe player was deleted?
+                }
+            }
+        }
     }
 
     public boolean validForMine(Resource r) {
-        if (this.mineType == null)
+        if (this.mineType == null) {
+            Logger.error("Mine Was Null Setting Resources for Mine: " + this.getObjectUUID());
             return false;
-        return this.mineType.validForMine(r, this.isExpansion());
+        }
+        return this.mineType.validForMine(r);
     }
 
     public void serializeForMineProduction(ByteBufferWriter writer) {
@@ -394,10 +442,10 @@ public class Mine extends AbstractGameObject {
         writer.putString(this.mineType.name);
         writer.putString(this.zoneName);
         writer.putInt(this.production.hash);
-        writer.putInt(this.production.baseProduction);
+        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
@@ -538,41 +586,236 @@ public class Mine extends AbstractGameObject {
     }
 
     public int getModifiedProductionAmount() {
-        //TODO Calculate Distance modifications.
+        ItemBase resourceBase = ItemBase.getItemBase(this.production.UUID);
-
+        if(resourceBase == null)
-        //calculate base values.
+            return 0;
-        int baseProduction = this.production.baseProduction;
+        int value = resourceBase.getBaseValue();
-        float baseModValue = this.production.baseProduction * .1f;
+
-        float rankModValue = this.production.baseProduction * .0143f;
+        int amount = 0;
-        float totalModded = 0;
+        switch(this.capSize){
-
+            case 3:
-        //get Mine Building.
+                amount = 1800000;
-        Building mineBuilding = BuildingManager.getBuilding(this.buildingID);
+                break;
-        if (mineBuilding == null)
+            case 5:
-            return this.production.baseProduction;
+                amount = 3000000;
-        for (AbstractCharacter harvester : mineBuilding.getHirelings().keySet()) {
+                break;
-            totalModded += baseModValue;
+            case 10:
-            totalModded += rankModValue * harvester.getRank();
+                amount = 6000000;
+                break;
+            case 20:
+                amount = 12000000;
+                break;
         }
-        //add base production on top;
+        if(this.production.UUID == 7)
-        totalModded += baseProduction;
+            value = 1;
-        //skip distance check for expansion.
+
-        if (this.isExpansion())
+        amount = amount / value;
-            return (int) totalModded;
+
-
+        return amount;
-        if (this.owningGuild.isEmptyGuild() == false) {
+    }
-            if (this.owningGuild.getOwnedCity() != null) {
+    public void onEnter() {
-                float distanceSquared = this.owningGuild.getOwnedCity().getLoc().distanceSquared2D(mineBuilding.getLoc());
+
-
+        Building tower = BuildingManager.getBuildingFromCache(this.buildingID);
-                if (distanceSquared > sqr(10000 * 3))
+        if(tower == null)
-                    totalModded *= .25f;
+            return;
-                else if (distanceSquared > sqr(10000 * 2))
+
-                    totalModded *= .50f;
+        // Gather current list of players within the zone bounds
-                else if (distanceSquared > sqr(10000))
+
-                    totalModded *= .75f;
+        HashSet<AbstractWorldObject> currentPlayers = WorldGrid.getObjectsInRangePartial(tower.loc, Enum.CityBoundsType.GRID.extents, MBServerStatics.MASK_PLAYER);
+        HashMap<Guild,ArrayList<PlayerCharacter>> charactersByNation = new HashMap<>();
+        ArrayList<Guild> updatedNations = new ArrayList<>();
+        for (AbstractWorldObject playerObject : currentPlayers) {
+
+            if (playerObject == null)
+                continue;
+
+            PlayerCharacter player = (PlayerCharacter) playerObject;
+
+            if(this.affectedPlayers.contains(player) == false)
+                this.affectedPlayers.add(player);
+
+            if(!this._playerMemory.contains(player.getObjectUUID())){
+                this._playerMemory.add(player.getObjectUUID());
+            }
+            Guild nation = player.guild.getNation();
+            if(charactersByNation.containsKey(nation)){
+                if(!charactersByNation.get(nation).contains(player)) {
+                    charactersByNation.get(nation).add(player);
+                    if(!updatedNations.contains(nation)){
+                        updatedNations.add(nation);
+                    }
+                }
+            }else{
+                ArrayList<PlayerCharacter> players = new ArrayList<>();
+                players.add(player);
+                charactersByNation.put(nation,players);
+                if(!updatedNations.contains(nation)){
+                    updatedNations.add(nation);
+                }
             }
         }
-        return (int) totalModded;
+        for(Guild nation : updatedNations){
+            float multiplier = ZergManager.getCurrentMultiplier(charactersByNation.get(nation).size(),this.capSize);
+            for(PlayerCharacter player : charactersByNation.get(nation)){
+                player.ZergMultiplier = multiplier;
+            }
+        }
+        try
+        {
+            this.onExit(this._playerMemory);
+        }
+        catch(Exception ignored){
+
+        }
+    }
+
+    private void onExit(HashSet<Integer> currentMemory) {
+
+        Building tower = BuildingManager.getBuildingFromCache(this.buildingID);
+        if(tower == null)
+            return;
+        ArrayList<Integer>toRemove = new ArrayList<>();
+        HashSet<AbstractWorldObject> currentPlayers = WorldGrid.getObjectsInRangePartial(tower.loc, Enum.CityBoundsType.GRID.extents, MBServerStatics.MASK_PLAYER);
+        for(Integer id : currentMemory){
+            PlayerCharacter pc = PlayerCharacter.getPlayerCharacter(id);
+            if(currentPlayers.contains(pc) == false){
+                toRemove.add(id);
+                pc.ZergMultiplier = 1.0f;
+            }
+        }
+
+        // Remove players from city memory
+
+        _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/MineProduction.java

@@ -13,21 +13,19 @@ import java.util.HashMap;
 
 public enum MineProduction {
 
-    LUMBER("Lumber Camp", new HashMap<>(), Resource.WORMWOOD, 1618637196, 1663491950),
+    LUMBER("Lumber Camp", new HashMap<>(), 1618637196, 1663491950),
-    ORE("Ore Mine", new HashMap<>(), Resource.OBSIDIAN, 518103023, -788976428),
+    ORE("Ore Mine", new HashMap<>(), 518103023, -788976428),
-    GOLD("Gold Mine", new HashMap<>(), Resource.GALVOR, -662193002, -1227205358),
+    MAGIC("Magic Mine", new HashMap<>(), 504746863, -1753567069),
-    MAGIC("Magic Mine", new HashMap<>(), Resource.BLOODSTONE, 504746863, -1753567069);
+    GOLDMINE("Gold Mine", new HashMap<>(), -662193002, -1227205358);
 
     public final String name;
     public final HashMap<Integer, Resource> resources;
-    public final Resource xpac;
     public final int hash;
     public final int xpacHash;
 
-    MineProduction(String name, HashMap<Integer, Resource> resources, Resource xpac, int hash, int xpacHash) {
+    MineProduction(String name, HashMap<Integer, Resource> resources,int hash, int xpacHash) {
         this.name = name;
         this.resources = resources;
-        this.xpac = xpac;
         this.hash = hash;
         this.xpacHash = xpacHash;
     }
@@ -39,6 +37,7 @@ public enum MineProduction {
             MineProduction.LUMBER.resources.put(1580005, Resource.OAK);
             MineProduction.LUMBER.resources.put(1580006, Resource.BRONZEWOOD);
             MineProduction.LUMBER.resources.put(1580007, Resource.MANDRAKE);
+            MineProduction.LUMBER.resources.put(1580018, Resource.WORMWOOD);
         }
         if (MineProduction.ORE.resources.size() == 0) {
             MineProduction.ORE.resources.put(7, Resource.GOLD);
@@ -46,14 +45,16 @@ public enum MineProduction {
             MineProduction.ORE.resources.put(1580001, Resource.TRUESTEEL);
             MineProduction.ORE.resources.put(1580002, Resource.IRON);
             MineProduction.ORE.resources.put(1580003, Resource.ADAMANT);
+            MineProduction.ORE.resources.put(1580019, Resource.OBSIDIAN);
         }
-        if (MineProduction.GOLD.resources.size() == 0) {
+        if (MineProduction.GOLDMINE.resources.size() == 0) {
-            MineProduction.GOLD.resources.put(7, Resource.GOLD);
+            MineProduction.GOLDMINE.resources.put(7, Resource.GOLD);
-            MineProduction.GOLD.resources.put(1580000, Resource.STONE);
+            MineProduction.GOLDMINE.resources.put(1580000, Resource.STONE);
-            MineProduction.GOLD.resources.put(1580008, Resource.COAL);
+            MineProduction.GOLDMINE.resources.put(1580008, Resource.COAL);
-            MineProduction.GOLD.resources.put(1580009, Resource.AGATE);
+            MineProduction.GOLDMINE.resources.put(1580009, Resource.AGATE);
-            MineProduction.GOLD.resources.put(1580010, Resource.DIAMOND);
+            MineProduction.GOLDMINE.resources.put(1580010, Resource.DIAMOND);
-            MineProduction.GOLD.resources.put(1580011, Resource.ONYX);
+            MineProduction.GOLDMINE.resources.put(1580011, Resource.ONYX);
+            MineProduction.GOLDMINE.resources.put(1580017, Resource.GALVOR);
         }
         if (MineProduction.MAGIC.resources.size() == 0) {
             MineProduction.MAGIC.resources.put(7, Resource.GOLD);
@@ -62,27 +63,25 @@ public enum MineProduction {
             MineProduction.MAGIC.resources.put(1580014, Resource.ANTIMONY);
             MineProduction.MAGIC.resources.put(1580015, Resource.SULFUR);
             MineProduction.MAGIC.resources.put(1580016, Resource.QUICKSILVER);
+            MineProduction.MAGIC.resources.put(1580020, Resource.BLOODSTONE);
         }
     }
 
     public static MineProduction getByName(String name) {
-        if (name.toLowerCase().equals("lumber"))
+        if (name.equalsIgnoreCase("lumber"))
             return MineProduction.LUMBER;
-        else if (name.toLowerCase().equals("ore"))
+        else if (name.equalsIgnoreCase("ore"))
             return MineProduction.ORE;
-        else if (name.toLowerCase().equals("gold"))
+        else if (name.equalsIgnoreCase("gold"))
-            return MineProduction.GOLD;
+            return MineProduction.GOLDMINE;
         else
             return MineProduction.MAGIC;
     }
 
-    public boolean validForMine(Resource r, boolean isXpac) {
+    public boolean validForMine(Resource r) {
         if (r == null)
             return false;
-        if (this.resources.containsKey(r.UUID))
+        return this.resources.containsKey(r.UUID);
-            return true;
-        else
-            return isXpac && r.UUID == this.xpac.UUID;
     }
 
 

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.*;
@@ -48,6 +49,7 @@ import static engine.net.client.msg.ErrorPopupMsg.sendErrorPopup;
 
 public class Mob extends AbstractIntelligenceAgent {
 
+    public static ArrayList<Mob> discDroppers = new ArrayList<>();
     private static final ReentrantReadWriteLock createLock = new ReentrantReadWriteLock();
     private static final ConcurrentHashMap<Integer, Mob> mobMapByDBID = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW);
     // Variables NOT to be stored in db
@@ -100,6 +102,14 @@ public class Mob extends AbstractIntelligenceAgent {
     private DeferredPowerJob weaponPower;
     private DateTime upgradeDateTime = null;
     private boolean lootSync = false;
+    public boolean StrongholdCommander = false;
+
+    public boolean StrongholdGuardian = false;
+
+    public Mine stronghold = null;
+
+    public boolean StrongholdEpic = false;
+    public boolean isDropper = false;
 
 
     /**
@@ -264,7 +274,7 @@ public class Mob extends AbstractIntelligenceAgent {
             this.notEnemy = EnumBitSet.asEnumBitSet(rs.getLong("notEnemy"), Enum.MonsterType.class);
             this.enemy = EnumBitSet.asEnumBitSet(rs.getLong("enemy"), Enum.MonsterType.class);
             this.firstName = rs.getString("mob_name");
-
+            this.isDropper = rs.getInt("is_dropper") == 1;
             if (this.firstName.isEmpty())
                 this.firstName = this.mobBase.getFirstName();
 
@@ -288,6 +298,12 @@ public class Mob extends AbstractIntelligenceAgent {
             Logger.error("Mobile:" + this.dbID + ": " + e);
         }
 
+        if(this.firstName.toLowerCase().equals("guardian commander") || this.firstName.toLowerCase().equals("elite guardian")|| this.firstName.toLowerCase().equals("guardian")|| this.firstName.toLowerCase().equals("commander")){
+            this.despawn();
+            this.removeFromCache();
+            DbManager.MobQueries.DELETE_MOB(this);
+        }
+
     }
 
     public static void serializeMobForClientMsgOtherPlayer(Mob mob, ByteBufferWriter writer) throws SerializationException {
@@ -560,6 +576,32 @@ public class Mob extends AbstractIntelligenceAgent {
         return mob;
     }
 
+    public static Mob createStrongholdMob(int loadID, Vector3fImmutable spawn, Guild guild, boolean isMob, Zone parent, Building building, int contractID, String pirateName, int level) {
+
+        // Create a new Mob instance
+        Mob mobWithoutID = new Mob(pirateName, "", (short) 0, (short) 0, (short) 0, (short) 0, (short) 0, (short) 1, 0, false, false, false, spawn, spawn, Vector3fImmutable.ZERO, (short) 1, (short) 1, (short) 1, guild, (byte) 0, loadID, isMob, parent, building, contractID);
+
+        // Check if mobBase is null
+        if (mobWithoutID.mobBase == null)
+            return null;
+
+        // Set mob level
+        mobWithoutID.level = (short) level;
+
+        // Set the parent zone and parentZoneID
+        mobWithoutID.parentZone = parent;
+        mobWithoutID.parentZoneID = parent.getObjectUUID();
+
+        // If the mob is in a building, bind it to zero position
+        if (mobWithoutID.building != null)
+            mobWithoutID.bindLoc = Vector3fImmutable.ZERO;
+
+        // Avoid database actions and directly return the created mobWithoutID
+        mobWithoutID.setObjectTypeMask(MBServerStatics.MASK_MOB | mobWithoutID.getTypeMasks());
+
+        return mobWithoutID;
+    }
+
     public static Mob createPet(int loadID, Guild guild, Zone parent, PlayerCharacter owner, short level) {
         MobBase mobBase = MobBase.getMobBase(loadID);
         Mob mob = null;
@@ -574,11 +616,11 @@ public class Mob extends AbstractIntelligenceAgent {
             mob = new Mob(mobBase, guild, parent, level, owner, 0);
             if (mob.mobBase == null)
                 return null;
-            mob.runAfterLoad();
+
-            Vector3fImmutable loc = owner.getLoc();
             DbManager.addToCache(mob);
             mob.setPet(owner, true);
             mob.setWalkMode(false);
+            mob.runAfterLoad();
 
         } catch (Exception e) {
             Logger.error(e);
@@ -1215,6 +1257,10 @@ public class Mob extends AbstractIntelligenceAgent {
     @Override
     public void killCharacter(AbstractCharacter attacker) {
 
+        if(this.StrongholdGuardian || this.StrongholdCommander) {
+            ChatManager.chatSystemChannel(this.parentZone.getParent().getName() + "'s Stronghold Is Under Attack!");
+            StrongholdManager.CheckToEndStronghold(this.stronghold);
+        }
 
         this.stopMovement(this.getMovementLoc());
 
@@ -1267,7 +1313,7 @@ public class Mob extends AbstractIntelligenceAgent {
         }
 
         setLoc(newLoc);
-        this.region = AbstractWorldObject.GetRegionByWorldObject(this);
+        this.region = Regions.GetRegionForTeleport(this.loc);//AbstractWorldObject.GetRegionByWorldObject(this);
         //Next update will be end Loc, lets stop him here.
 
     }
@@ -1281,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;
@@ -1362,6 +1406,8 @@ public class Mob extends AbstractIntelligenceAgent {
             Logger.error(e);
         }
         this.updateLocation();
+        //resync corpses
+        InterestManager.setObjectDirty(this);
     }
 
     public void respawn() {
@@ -1396,6 +1442,9 @@ public class Mob extends AbstractIntelligenceAgent {
             loadInventory();
 
         this.updateLocation();
+        this.stopPatrolTime = 0;
+        this.lastPatrolPointIndex = 0;
+        InterestManager.setObjectDirty(this);
     }
 
     public void despawn() {
@@ -1404,6 +1453,10 @@ public class Mob extends AbstractIntelligenceAgent {
 
         WorldGrid.RemoveWorldObject(this);
         this.charItemManager.clearInventory();
+
+        if(this.StrongholdEpic && this.stronghold != null && this.stronghold.isActive)
+            this.stronghold.isActive = false;
+            //StrongholdManager.EndStronghold(this.stronghold);
     }
 
     @Override
@@ -1465,11 +1518,31 @@ public class Mob extends AbstractIntelligenceAgent {
         } catch (Exception e) {
             Logger.error(e.getMessage());
         }
-
+        if(this.StrongholdCommander || this.StrongholdGuardian || this.StrongholdEpic){
-        Resists.calculateResists(this);
+            this.setResists(new Resists("Elite"));
+        }else if(Mob.discDroppers.contains(this)) {
+            this.setResists(new Resists("Dropper"));
+        } else if(this.isDropper){
+            this.setResists(new Resists("Dropper"));
+        } else{
+            this.setResists(new Resists());
+        }
+        this.resists.calculateResists(this, false);
     }
 
     public void calculateMaxHealthManaStamina() {
+
+        if(this.StrongholdCommander){
+            this.healthMax = 50000;
+            return;
+        } else if(this.StrongholdGuardian){
+            this.healthMax  = 12500;
+            return;
+        } else if(this.StrongholdEpic){
+            this.healthMax = 250000;
+            return;
+        }
+
         float h;
         float m;
         float s;
@@ -1527,82 +1600,151 @@ public class Mob extends AbstractIntelligenceAgent {
 
     public void calculateAtrDefenseDamage() {
 
-        if (this.charItemManager == null || this.equip == null) {
+        if(this.StrongholdCommander){
-            Logger.error("Player " + currentID + " missing skills or equipment");
+            this.maxDamageHandOne = 3500;
-            defaultAtrAndDamage(true);
+            this.minDamageHandOne = 1500;
-            defaultAtrAndDamage(false);
+            int atr = 3500;
-            this.defenseRating = 0;
+            int defense = 3500;
+            if (this.bonuses != null) {
+
+                defense = GetDefense(defense, this);
+                atr = GetAttackRating(atr, this);
+            }
+            this.defenseRating = defense;
+            this.atrHandOne = atr;
+                return;
+        } else if(this.StrongholdGuardian){
+            this.maxDamageHandOne = 1550;
+            this.minDamageHandOne = 750;
+            int atr = 1800;
+            int defense = 2200;
+            if (this.bonuses != null) {
+
+                defense = GetDefense(defense, this);
+                atr = GetAttackRating(atr, this);
+            }
+            this.defenseRating = defense;
+            this.atrHandOne = atr;
             return;
-        }
+        } else if(this.StrongholdEpic){
+            this.maxDamageHandOne = 5000;
+            this.minDamageHandOne = 2500;
+            int atr = 5000;
+            int defense = 3500;
+            if (this.bonuses != null) {
 
-        try {
+                defense = GetDefense(defense, this);
-            calculateAtrDamageForWeapon(this.equip.get(MBServerStatics.SLOT_MAINHAND), true);
+                atr = GetAttackRating(atr, this);
-        } catch (Exception e) {
+            }
+            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;
+            }
 
-            this.atrHandOne = (short) this.mobBase.getAttackRating();
+            try {
-            this.minDamageHandOne = (short) this.mobBase.getMinDmg();
+                calculateAtrDamageForWeapon(this.equip.get(MBServerStatics.SLOT_MAINHAND), true);
-            this.maxDamageHandOne = (short) this.mobBase.getMaxDmg();
+            } catch (Exception e) {
-            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 {
+                this.atrHandOne = GetAttackRating(this.mobBase.getAttackRating(), this);
-            calculateAtrDamageForWeapon(this.equip.get(MBServerStatics.SLOT_OFFHAND), false);
+                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());
+            }
 
-        } catch (Exception e) {
+            try {
+                calculateAtrDamageForWeapon(this.equip.get(MBServerStatics.SLOT_OFFHAND), false);
 
-            this.atrHandTwo = (short) this.mobBase.getAttackRating();
+            } catch (Exception e) {
-            this.minDamageHandTwo = (short) this.mobBase.getMinDmg();
+
-            this.maxDamageHandTwo = (short) this.mobBase.getMaxDmg();
+                this.atrHandTwo = GetAttackRating(this.mobBase.getAttackRating(), this);
-            this.rangeHandTwo = 6.5f;
+                this.minDamageHandTwo = (short) this.mobBase.getDamageMin();
-            this.speedHandTwo = 20;
+                this.maxDamageHandTwo = (short) this.mobBase.getDamageMax();
-            Logger.info("Mobbase ID " + this.getMobBaseID() + " returned an error. setting to default ATR and Damage." + e.getMessage());
+                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.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 {
+    public static int GetDefense(int defense, Mob mob){
-            float defense = this.mobBase.getDefenseRating();
+        // add any bonuses
-            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) {
 
-                // add any bonuses
+        defense += (short) mob.bonuses.getFloat(ModType.DCV, SourceType.None);
 
-                defense += (short) this.bonuses.getFloat(ModType.DCV, SourceType.None);
+        // Finally, multiply any percent modifiers. DO THIS LAST!
 
-                // Finally, multiply any percent modifiers. DO THIS LAST!
+        float pos_Bonus = 1 + mob.bonuses.getFloatPercentPositive(ModType.DCV, SourceType.None);
 
-                float pos_Bonus = 1 + this.bonuses.getFloatPercentPositive(ModType.DCV, SourceType.None);
 
+        defense = (short) (defense * pos_Bonus);
 
-                defense = (short) (defense * pos_Bonus);
+        //Lucky rune applies next
 
-                //Lucky rune applies next
+        float neg_Bonus = mob.bonuses.getFloatPercentNegative(ModType.DCV, SourceType.None);
+        return (int) (defense * (1 + neg_Bonus));
+    }
 
-                float neg_Bonus = this.bonuses.getFloatPercentNegative(ModType.DCV, SourceType.None);
+    public static int GetAttackRating(int attackRating, Mob mob){
-                defense = (short) (defense * (1 + neg_Bonus));
+        // add any bonuses
 
+        attackRating += (short) mob.bonuses.getFloat(ModType.OCV, SourceType.None);
 
-            } else
+        // Finally, multiply any percent modifiers. DO THIS LAST!
-                Logger.error("Error: missing bonuses");
+
+        float pos_Bonus = 1 + mob.bonuses.getFloatPercentPositive(ModType.OCV, SourceType.None);
 
-            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
-    }
 
+        attackRating = (short) (attackRating * pos_Bonus);
+
+        //Lucky rune applies next
+
+        float neg_Bonus = mob.bonuses.getFloatPercentNegative(ModType.OCV, SourceType.None);
+        return (int) (attackRating * (1 + neg_Bonus));
+    }
     private float getWeaponDefense(HashMap<Integer, MobEquipment> equipped) {
 
         MobEquipment weapon = equipped.get(MBServerStatics.SLOT_MAINHAND);
@@ -1701,168 +1843,46 @@ public class Mob extends AbstractIntelligenceAgent {
 
     private void calculateAtrDamageForWeapon(MobEquipment weapon, boolean mainHand) {
 
-        int baseStrength = 0;
+        if(mainHand){
-
+            int min = (int)this.mobBase.getDamageMin();
-        float skillPercentage, masteryPercentage;
+            int max = (int)this.mobBase.getDamageMax();
-        float mastDam;
+            int atr = this.mobBase.getAtr();
-
+            if(this.bonuses != null){
-        // make sure weapon exists
+                min *= 1 + this.bonuses.getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
-
+                max *= 1 + this.bonuses.getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
-        boolean noWeapon = false;
+                atr *= 1 + this.bonuses.getFloatPercentAll(ModType.OCV,SourceType.None);
-        ItemBase wb = null;
+                atr += this.bonuses.getFloat(ModType.OCV,SourceType.None);
-
+            }
-        if (weapon == null)
+            this.minDamageHandOne = min;
-            noWeapon = true;
+            this.maxDamageHandOne = max;
-
+            this.atrHandOne = atr;
-        else {
+            if(weapon == null){
-
-            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)
                 this.rangeHandOne = this.mobBase.getAttackRange();
-            else
+                this.speedHandTwo = 20.0f;
-                this.rangeHandTwo = -1; // set to do not attack
+            }else{
-
+                this.rangeHandOne = weapon.getItemBase().getRange();
-            skillPercentage = getModifiedAmount(this.skills.get("Unarmed Combat"));
+                this.speedHandTwo = weapon.getItemBase().getSpeed();
-            masteryPercentage = getModifiedAmount(this.skills.get("Unarmed Combat Mastery"));
+            }
-
+        }else{
-            if (masteryPercentage == 0f)
+            int min = (int)this.mobBase.getDamageMin();
-                mastDam = CharacterSkill.getQuickMastery(this, "Unarmed Combat Mastery");
+            int max = (int)this.mobBase.getDamageMax();
-            else
+            int atr = this.mobBase.getAtr();
-                mastDam = masteryPercentage;
+            if(this.bonuses != null){
-
+                min *= 1 + this.bonuses.getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
-            // TODO Correct these
+                max *= 1 + this.bonuses.getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
-            min = this.mobBase.getMinDmg();
+                atr *= 1 + this.bonuses.getFloatPercentAll(ModType.OCV,SourceType.None);
-            max = this.mobBase.getMaxDmg();
+                atr += this.bonuses.getFloat(ModType.OCV,SourceType.None);
-        } else {
+            }
-
+            this.minDamageHandTwo = min;
-            if (mainHand)
+            this.maxDamageHandTwo = max;
-                this.rangeHandOne = weapon.getItemBase().getRange() * (1 + (baseStrength / 600.0f));
+            this.atrHandTwo = atr;
-            else
+            if(weapon == null){
-                this.rangeHandTwo = weapon.getItemBase().getRange() * (1 + (baseStrength / 600.0f));
+                this.rangeHandTwo = this.mobBase.getAttackRange();
-
+                this.speedHandTwo = 20.0f;
-            skillPercentage = getModifiedAmount(this.skills.get(wb.getSkillRequired()));
+            }else{
-            masteryPercentage = getModifiedAmount(this.skills.get(wb.getMastery()));
+                this.rangeHandTwo = weapon.getItemBase().getRange();
-
+                this.speedHandTwo = weapon.getItemBase().getSpeed();
-            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;
         }
     }
 
@@ -1929,6 +1949,13 @@ public class Mob extends AbstractIntelligenceAgent {
 
         this.charItemManager = new CharacterItemManager(this);
         this.loadInventory();
+        if(this.isDropper){
+            this.setLevel((short)65);
+            this.setResists(new Resists("Dropper"));
+            this.atrHandOne *= 2;
+            this.atrHandTwo *= 2;
+
+        }
         try {
             if (this.equipmentSetID != 0)
                 this.equip = MobBase.loadEquipmentSet(this.equipmentSetID);
@@ -1969,6 +1996,7 @@ public class Mob extends AbstractIntelligenceAgent {
 
         try {
             NPCManager.applyRuneSetEffects(this);
+            MobBase.applyMobbaseEffects(this);
             recalculateStats();
             this.setHealth(this.healthMax);
 
@@ -2020,6 +2048,7 @@ public class Mob extends AbstractIntelligenceAgent {
                 }
 
             this.deathTime = 0;
+            InterestManager.setObjectDirty(this);
         } catch (Exception e) {
             Logger.error(e.getMessage());
         }
@@ -2263,5 +2292,9 @@ public class Mob extends AbstractIntelligenceAgent {
             }
         }
     }
-
+        public static void AddDiscDropper(Mob mob){
+        discDroppers.add(mob);
+        mob.setLevel((short)65);
+        mob.setResists(new Resists("Dropper"));
+        }
 }

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/MobEquipment.java

@@ -34,7 +34,8 @@ public class MobEquipment extends AbstractGameObject {
     private AbstractPowerAction suffix;
     private int pValue;
     private int sValue;
-    private int magicValue;
+    int magicValue;
+    public boolean fromNoob = false;
 
     private float dropChance = 0;
 
@@ -106,7 +107,6 @@ public class MobEquipment extends AbstractGameObject {
 
     public static void serializeForVendor(MobEquipment mobEquipment, ByteBufferWriter writer, float percent) throws SerializationException {
         _serializeForClientMsg(mobEquipment, writer, false);
-        int baseValue = mobEquipment.itemBase.getBaseValue() + mobEquipment.itemBase.getMagicValue();
         writer.putInt(mobEquipment.magicValue);
         writer.putInt(mobEquipment.magicValue);
     }

src/engine/objects/MobLoot.java

@@ -77,7 +77,7 @@ public final class MobLoot extends Item {
             this.setNumOfItems(quantity);
 
         this.noSteal = noSteal;
-        this.setIsID(this.getItemBase().isAutoID());
+        this.setIsID(true);
 
         // Class is 'final'; passing 'this' should be okay at the end of the constructor
 

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.
@@ -122,7 +122,11 @@ public class NPC extends AbstractCharacter {
             // this.buyPercent = rs.getFloat("npc_buyPercent");
 
             this.buyPercent = .33f;
-            this.sellPercent = 1;
+            if(ZoneManager.findSmallestZone(this.loc) != null && ZoneManager.findSmallestZone(this.loc).getSafeZone() == 1){
+                this.sellPercent = 0;
+            }else{
+                this.sellPercent = 1;
+            }
 
             this.setRot(new Vector3f(0, rs.getFloat("npc_rotation"), 0));
 
@@ -149,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();
@@ -189,6 +199,18 @@ public class NPC extends AbstractCharacter {
         serializeForClientMsgOtherPlayer(npc, writer);
     }
 
+    public boolean isInSafeZone() {
+
+        Zone zone = ZoneManager.findSmallestZone(this.getLoc());
+
+        if (zone != null) {
+            return zone.getSafeZone() == (byte) 1;
+        }
+
+        return false;
+        //return this.safeZone;
+    }
+
     public static void serializeForClientMsgOtherPlayer(NPC npc, ByteBufferWriter writer)
             throws SerializationException {
 
@@ -782,7 +804,7 @@ public class NPC extends AbstractCharacter {
 
     @Override
     public void updateDatabase() {
-        DbManager.NPCQueries.updateDatabase(this);
+        DbManager.NPCQueries.updateSpecialPricing(this);
     }
 
     public int getSymbol() {
@@ -1180,7 +1202,7 @@ public class NPC extends AbstractCharacter {
             }
 
             // Cannot roll items without a warehouse.
-            // Due to the fact fillForge references the
+            // Due to the fact ResourceRoll references the
             // warehouse and early exits.  *** Refactor???
 
             serverZone = this.building.getParentZone();
@@ -1214,7 +1236,7 @@ public class NPC extends AbstractCharacter {
             if (isRandom)
                 item = ItemFactory.randomRoll(this, player, amount, itemID);
             else
-                item = ItemFactory.fillForge(this, player, amount, itemID, pToken, sToken, customName);
+                item = ItemFactory.ResourceRoll(this, player, amount, itemID, pToken, sToken, customName);
 
             if (item == null)
                 return null;
@@ -1274,12 +1296,13 @@ public class NPC extends AbstractCharacter {
         return name;
     }
 
-    public int getRepairCost() {
+    public int getSpecialPrice() {
-        return repairCost;
+        return specialPrice;
     }
 
-    public void setRepairCost(int repairCost) {
+    public void setSpecialPrice(int specialPrice) {
-        this.repairCost = repairCost;
+        this.specialPrice = specialPrice;
+        DbManager.NPCQueries.updateSpecialPricing(this);
     }
 
     public void processUpgradeNPC(PlayerCharacter player) {
@@ -1347,4 +1370,100 @@ public class NPC extends AbstractCharacter {
         }
     }
 
+    public ArrayList<MobEquipment> getSellInventorySteward() {
+
+        ArrayList<MobEquipment> smallList = new ArrayList<>();
+        for (MobEquipment me : this.contract.getSellInventory()) {
+            int rankRequired = 0;
+            if (me.getItemBase().getType().equals(Enum.ItemType.CONTRACT)) {
+                switch (me.getItemBase().getUUID()) {
+                    case 866:
+                    case 889:
+                    case 860:
+                    case 850:
+                    case 892:
+                    case 1502003:
+                    case 890:
+                    case 896:
+                        rankRequired = 1;
+                        break;
+                    case 899:
+                    case 801:
+                    case 803:
+                    case 802:
+                    case 821:
+                    case 810:
+                    case 806:
+                    case 818:
+                    case 800:
+                        rankRequired = 2;
+                        break;
+
+                    case 840:
+                    case 848:
+                    case 813:
+                    case 805:
+                    case 804:
+                    case 838:
+                        rankRequired = 3;
+                        break;
+                    case 815:
+                        rankRequired = 4;
+                        break;
+                    case 847:
+                    case 830:
+                    case 820:
+                        rankRequired = 6;
+                        break;
+                    case 865:
+                    case 252637:
+                        rankRequired = 7;
+                        break;
+                    case 1502002: // harvesters don't need to exist but might one day
+                    case 1502001: //mine guards don't need to exist but might one day
+                        continue;
+                }
+                if(me.getItemBase().getName().toLowerCase().contains("trainer") || me.getItemBase().getName().toLowerCase().contains("refiner")){
+                    rankRequired = 5;
+                }
+                if (this.getRank() >= rankRequired)
+                    smallList.add(me);
+            }
+        }
+        return smallList;
+    }
+
+    public ArrayList<MobEquipment> getSellInventoryBuilder() {
+
+        ArrayList<MobEquipment> smallList = new ArrayList<>();
+        int maxValue = 0;
+        switch(this.getRank()){
+            case 1:
+                maxValue = 300000;
+                break;
+            case 2:
+                maxValue = 450000;
+                break;
+            case 3:
+                maxValue = 550000;
+                break;
+            case 4:
+                maxValue = 650000;
+                break;
+            case 5:
+                maxValue = 1000000;
+                break;
+            case 6:
+            case 7:
+                maxValue = 999999999;
+                break;
+
+        }
+        for(MobEquipment me : this.contract.getSellInventory()){
+            if(me.getItemBase().getBaseValue() <= maxValue)
+                smallList.add(me);
+        }
+        return smallList;
+    }
+
 }

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/PromotionClass.java

@@ -150,6 +150,7 @@ public class PromotionClass extends AbstractGameObject {
                 return true;
             }
         }
+
         return false;
     }
 

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

@@ -34,6 +34,24 @@ public class Resists {
     private int protectionTrains = 0;
     private boolean immuneToAll;
 
+    public Resists() {
+        this.immuneToAll = false;
+        this.resists.put(DamageType.Slash, 0f);
+        this.resists.put(DamageType.Crush, 0f);
+        this.resists.put(DamageType.Pierce, 0f);
+        this.resists.put(DamageType.Magic, 0f);
+        this.resists.put(DamageType.Bleed, 0f);
+        this.resists.put(DamageType.Poison, 0f);
+        this.resists.put(DamageType.Mental, 0f);
+        this.resists.put(DamageType.Holy, 0f);
+        this.resists.put(DamageType.Unholy, 0f);
+        this.resists.put(DamageType.Lightning, 0f);
+        this.resists.put(DamageType.Fire, 0f);
+        this.resists.put(DamageType.Cold, 0f);
+        this.resists.put(DamageType.Healing, 0f);
+        this.immuneTo.put(DamageType.Siege, true);
+
+    }
     /**
      * Generic Constructor
      */
@@ -46,6 +64,12 @@ public class Resists {
             case "Mine":
                 setMineResists();
                 break;
+            case "Dropper":
+                setDropperResists();
+                break;
+            case "Elite":
+                setEliteResists();
+                break;
             default:
                 setGenericResists();
                 break;
@@ -231,6 +255,42 @@ public class Resists {
         this.resists.put(DamageType.Siege, 0f);
     }
 
+    public final void setDropperResists() {
+        this.immuneToAll = false;
+        this.resists.put(DamageType.Slash, 50f);
+        this.resists.put(DamageType.Crush, 50f);
+        this.resists.put(DamageType.Pierce, 50f);
+        this.resists.put(DamageType.Magic, 50f);
+        this.resists.put(DamageType.Bleed, 50f);
+        this.resists.put(DamageType.Poison, 50f);
+        this.resists.put(DamageType.Mental, 50f);
+        this.resists.put(DamageType.Holy, 50f);
+        this.resists.put(DamageType.Unholy, 50f);
+        this.resists.put(DamageType.Lightning, 50f);
+        this.resists.put(DamageType.Fire, 50f);
+        this.resists.put(DamageType.Cold, 50f);
+        this.resists.put(DamageType.Healing, 0f);
+        this.immuneTo.put(DamageType.Siege, true);
+    }
+
+    public final void setEliteResists() {
+        this.immuneToAll = false;
+        this.resists.put(DamageType.Slash, 75f);
+        this.resists.put(DamageType.Crush, 75f);
+        this.resists.put(DamageType.Pierce, 75f);
+        this.resists.put(DamageType.Magic, 75f);
+        this.resists.put(DamageType.Bleed, 75f);
+        this.resists.put(DamageType.Poison, 75f);
+        this.resists.put(DamageType.Mental, 75f);
+        this.resists.put(DamageType.Holy, 75f);
+        this.resists.put(DamageType.Unholy, 75f);
+        this.resists.put(DamageType.Lightning, 75f);
+        this.resists.put(DamageType.Fire, 75f);
+        this.resists.put(DamageType.Cold, 75f);
+        this.resists.put(DamageType.Healing, 0f);
+        this.immuneTo.put(DamageType.Siege, true);
+    }
+
     /**
      * Create generic resists
      */
@@ -394,10 +454,12 @@ public class Resists {
      */
     public float getResistedDamage(AbstractCharacter source, AbstractCharacter target, DamageType type, float damage, int trains) {
         //handle fortitudes
-        damage = handleFortitude(target, type, damage);
+        //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
@@ -417,6 +479,7 @@ public class Resists {
             }
             target.cancelOnTakeDamage(type, (damageAfterResists));
         }
+        damageAfterResists = handleFortitude(target, type, damageAfterResists);
         return damageAfterResists;
     }
 
@@ -426,6 +489,38 @@ public class Resists {
         // get resists for runes
         PlayerBonuses rb = ac.getBonuses();
         float slash = 0f, crush = 0f, pierce = 0f, magic = 0f, bleed = 0f, mental = 0f, holy = 0f, unholy = 0f, poison = 0f, lightning = 0f, fire = 0f, cold = 0f, healing = 0f;
+        if(ac.getObjectType().equals(Enum.GameObjectType.Mob)){
+            Mob mob = (Mob)ac;
+            if(mob.StrongholdEpic || mob.StrongholdCommander || mob.StrongholdGuardian) {
+                slash = 75f;
+                crush = 75f;
+                pierce = 75f;
+                magic = 75f;
+                bleed = 75f;
+                mental = 75f;
+                holy = 75f;
+                unholy = 75f;
+                poison = 75f;
+                lightning = 75f;
+                fire = 75f;
+                cold = 75f;
+                healing = 0f;
+            } else if(Mob.discDroppers.contains(mob) || mob.isDropper) {
+                slash = 200f;
+                crush = 200f;
+                pierce = 200f;
+                magic = 200f;
+                bleed = 200f;
+                mental = 200f;
+                holy = 200f;
+                unholy = 200f;
+                poison = 200f;
+                lightning = 200f;
+                fire = 200f;
+                cold = 200f;
+                healing = 0f;
+            }
+        }
 
         if (rb != null) {
             // Handle immunities
@@ -465,19 +560,6 @@ public class Resists {
             cold += rb.getFloat(ModType.Resistance, SourceType.Cold);
             healing += rb.getFloat(ModType.Resistance, SourceType.Healing); // DamageType.Healing.name());
 
-            //HHO
-
-//			String protectionString = rb.getString("protection");
-//
-//			if (protectionString.isEmpty())
-//				this.protection = null;
-//			else try {
-//				this.protection = DamageType.valueOf(rb.getString("protection"));
-//			} catch (IllegalArgumentException e) {
-//				Logger.error( "No enum for: " + protectionString);
-//				this.protection = null;
-//			}
-//			this.protectionTrains = rb.getFloat("protection");
         }
 
         // get resists from equipment

src/engine/objects/Shrine.java

@@ -43,7 +43,7 @@ public class Shrine extends AbstractWorldObject implements Comparable<Shrine> {
 
     public static boolean canTakeFavor(PlayerCharacter grantee, Shrine shrine) {
 
-        if (shrine.shrineType.isRace())
+        if (shrine.shrineType.isRace()) {
             switch (grantee.getRaceID()) {
                 case 2000:
                 case 2001:
@@ -96,6 +96,7 @@ public class Shrine extends AbstractWorldObject implements Comparable<Shrine> {
 
                 case 2025:
                 case 2026:
+                case 1999:
                     if (shrine.shrineType == ShrineType.Nephilim)
                         return true;
                     break;
@@ -106,7 +107,7 @@ public class Shrine extends AbstractWorldObject implements Comparable<Shrine> {
                     break;
 
             }
-        else
+        }else {
             switch (grantee.getPromotionClassID()) {
                 case 2504:
                     if (shrine.shrineType == ShrineType.Assassin)
@@ -197,7 +198,7 @@ public class Shrine extends AbstractWorldObject implements Comparable<Shrine> {
                         return true;
                     break;
             }
-
+        }
         return false;
     }
 
@@ -226,26 +227,6 @@ public class Shrine extends AbstractWorldObject implements Comparable<Shrine> {
 
     }
 
-    public void decay() {
-
-        if (this.getFavors() == 0)
-            return;
-
-        int decayAmount = (int) (this.getFavors() - (this.getFavors() * .10f));
-
-        if (decayAmount < 0)
-            decayAmount = 0;
-
-        if (!DbManager.ShrineQueries.updateFavors(this, decayAmount, this.getFavors())) {
-            Logger.error("Shrine Decay", "Error writing to DB. UUID: " + this.getObjectUUID());
-            return;
-        }
-        this.favors = decayAmount;
-
-        Logger.info(shrineType.name() + " uuid:" + this.getObjectUUID() + " Amount: " + this.getFavors() * .10f);
-
-    }
-
     public synchronized boolean addFavor(PlayerCharacter boonOwner, Item boonItem) {
 
         if (boonOwner == null)

src/engine/objects/Warehouse.java

@@ -281,6 +281,84 @@ public class Warehouse extends AbstractWorldObject {
 
     }
 
+    public static int getCostForResource(int id){
+        int newCost = 1;
+        switch(id){
+            case 1580000://stone
+                newCost = 3000;
+                break;
+            case 1580001://truesteel
+                newCost = 50000;
+                break;
+            case 1580002://iron
+                newCost = 50000;
+                break;
+            case 1580003://adamant
+                newCost = 100000;
+                break;
+            case 1580004://lumber
+                newCost = 3000;
+                break;
+            case 1580005://oak
+                newCost = 30000;
+                break;
+            case 1580006://bronzewood
+                newCost = 30000;
+                break;
+            case 1580007://mandrake
+                newCost = 100000;
+                break;
+            case 1580008://coal
+                newCost = 30000;
+                break;
+            case 1580009://agate
+                newCost = 50000;
+                break;
+            case 1580010://diamond
+                newCost = 50000;
+                break;
+            case 1580011://onyx
+                newCost = 100000;
+                break;
+            case 1580012://azoth
+                newCost = 50000;
+                break;
+            case 1580013://orichalk
+                newCost = 30000;
+                break;
+            case 1580014://antimony
+                newCost = 100000;
+                break;
+            case 1580015://sulfur
+                newCost = 100000;
+                break;
+            case 1580016://quicksilver
+                newCost = 100000;
+                break;
+            case 1580017://galvor
+                newCost = 300000;
+                break;
+            case 1580018://wormwood
+                newCost = 300000;
+                break;
+            case 1580019://obsidian
+                newCost = 200000;
+                break;
+            case 1580020://bloodstone
+                newCost = 200000;
+                break;
+            case 1705032:
+                newCost = 100000;
+                break;
+        }
+        return newCost;
+    }
+    public static int getSellStackSize(int id){
+        if(id == 1705032)
+            return 10;
+        return 3000000 / getCostForResource(id);
+    }
+
     public ConcurrentHashMap<ItemBase, Integer> getResources() {
         return resources;
     }

src/engine/objects/Zone.java

@@ -101,7 +101,6 @@ public class Zone extends AbstractGameObject {
         if (hash == null)
             setHash();
 
-
     }
 
     public static void serializeForClientMsg(Zone zone, ByteBufferWriter writer) {
@@ -113,8 +112,8 @@ public class Zone extends AbstractGameObject {
 
         if (zone.playerCityID > 0) {
             writer.put((byte) 1); // Player City - True
-            writer.putFloat(Enum.CityBoundsType.ZONE.extents);
+            writer.putFloat(Enum.CityBoundsType.GRID.extents + 128);
-            writer.putFloat(Enum.CityBoundsType.ZONE.extents);
+            writer.putFloat(Enum.CityBoundsType.GRID.extents + 128);
         } else
             writer.put((byte) 0); // Player City - False