mob ai work

This reverts commit 685297171c.

src/engine/Enum.java

@@ -9,15 +9,13 @@
 package engine;
 
 import ch.claude_martin.enumbitset.EnumBitSetHelper;
+import engine.gameManager.BuildingManager;
 import engine.gameManager.ConfigManager;
 import engine.gameManager.PowersManager;
 import engine.gameManager.ZoneManager;
 import engine.math.Vector2f;
 import engine.math.Vector3fImmutable;
-import engine.objects.AbstractCharacter;
-import engine.objects.ItemBase;
-import engine.objects.Shrine;
-import engine.objects.Zone;
+import engine.objects.*;
 import engine.powers.EffectsBase;
 import org.pmw.tinylog.Logger;
 
@@ -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),
-        IREKEIFEMALE(2014, MonsterType.Irekei, RunSpeed.STANDARD, CharacterSex.FEMALE, 1.1f),
+        IREKEIMALE(2013, MonsterType.Irekei, RunSpeed.IREKEI, CharacterSex.MALE, 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
-                    spawnLocation = Vector3fImmutable.getRandomPointOnCircle(ruinZone.getLoc()
-                            .add(new Vector3fImmutable(-196.016f, 2.812f, 203.621f)), 30);
+                }else {
+                    //spawnLocation = Vector3fImmutable.getRandomPointOnCircle(ruinZone.getLoc()
+                    //.add(new Vector3fImmutable(-196.016f, 2.812f, 203.621f)), 30);
+                        spawnLocation = Vector3fImmutable.getRandomPointOnCircle(BuildingManager.getBuilding(27977).loc,30f);
+
+                }
             }
 
 
@@ -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),
-        ZONE(875),
-        PLACEMENT(876);
+        GRID(544),
+        ZONE(672),
+        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.LoadStructureMsg;
-import engine.net.client.msg.MoveToPointMsg;
-import engine.net.client.msg.UnloadObjectsMsg;
+import engine.net.client.msg.*;
 import engine.objects.*;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
@@ -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.objects.Building;
-import engine.objects.City;
-import engine.objects.PlayerCharacter;
+import engine.gameManager.ZoneManager;
+import engine.math.Vector3fImmutable;
+import engine.objects.*;
 import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
 
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
+import java.sql.*;
 
 public class dbBaneHandler extends dbHandlerBase {
 
@@ -89,6 +85,139 @@ public class dbBaneHandler extends dbHandlerBase {
         return true;
     }
 
+    public boolean SET_BANE_TIME_NEW(int hour, int cityUUID) {
+        hour += 12; // Adjust hour
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement getStatement = connection.prepareStatement("SELECT `placementDate`, `liveDate` FROM `dyn_banes` WHERE `cityUUID`=?");
+             PreparedStatement updateStatement = connection.prepareStatement("UPDATE `dyn_banes` SET `liveDate`=?, `time_set`=? WHERE `cityUUID`=?")) {
+
+            // Retrieve placementDate and liveDate
+            getStatement.setInt(1, cityUUID);
+            try (ResultSet rs = getStatement.executeQuery()) {
+                if (rs.next()) {
+                    DateTime placementDate = new DateTime(rs.getTimestamp("placementDate").getTime());
+                    Timestamp liveDateTimestamp = rs.getTimestamp("liveDate");
+
+                    // Explicitly check if liveDate is null
+                    DateTime toSet;
+                    if (liveDateTimestamp == null) {
+                        // If liveDate is null, default to placementDate
+                        toSet = placementDate;
+                    } else {
+                        // If liveDate is not null, use it
+                        DateTime liveDate = new DateTime(liveDateTimestamp.getTime());
+                        toSet = liveDate;
+                    }
+
+                    // Adjust the time
+                    toSet = toSet.withHourOfDay(hour).withMinuteOfHour(0).withSecondOfMinute(0).withMillisOfSecond(0);
+
+                    // Update liveDate and time_set flag
+                    updateStatement.setTimestamp(1, new java.sql.Timestamp(toSet.getMillis()));
+                    updateStatement.setInt(2, 1); // time_set flag
+                    updateStatement.setInt(3, cityUUID);
+
+                    updateStatement.execute();
+                    return true;
+                }
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+    public boolean SET_BANE_DAY_NEW(int dayOffset, int cityUUID) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement getStatement = connection.prepareStatement("SELECT `placementDate`, `liveDate` FROM `dyn_banes` WHERE `cityUUID`=?");
+             PreparedStatement updateStatement = connection.prepareStatement("UPDATE `dyn_banes` SET `liveDate`=?, `day_set`=? WHERE `cityUUID`=?")) {
+
+            // Retrieve placementDate and liveDate
+            getStatement.setInt(1, cityUUID);
+            try (ResultSet rs = getStatement.executeQuery()) {
+                if (rs.next()) {
+                    DateTime placementDate = new DateTime(rs.getTimestamp("placementDate").getTime());
+                    Timestamp liveDateTimestamp = rs.getTimestamp("liveDate");
+
+                    // Explicitly check if liveDate is null
+                    DateTime liveDate;
+                    if (liveDateTimestamp == null) {
+                        // If liveDate is null, default to placementDate
+                        liveDate = placementDate;
+                    } else {
+                        // If liveDate is not null, use it
+                        liveDate = new DateTime(liveDateTimestamp.getTime());
+                    }
+
+                    // Calculate the new liveDate while preserving the time component
+                    DateTime updatedDate = placementDate.plusDays(dayOffset)
+                            .withHourOfDay(liveDate.getHourOfDay())
+                            .withMinuteOfHour(liveDate.getMinuteOfHour())
+                            .withSecondOfMinute(liveDate.getSecondOfMinute())
+                            .withMillisOfSecond(liveDate.getMillisOfSecond());
+
+                    // Update liveDate and day_set flag
+                    updateStatement.setTimestamp(1, new java.sql.Timestamp(updatedDate.getMillis()));
+                    updateStatement.setInt(2, 1); // day_set flag
+                    updateStatement.setInt(3, cityUUID);
+
+                    updateStatement.execute();
+                    return true;
+                }
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return false;
+    }
+
+
+
+
+    public boolean SET_BANE_CAP_NEW(int count, int cityUUID) {
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_banes` SET `cap_size`=? WHERE `cityUUID`=?")) {
+
+            preparedStatement.setInt(1, count);
+            preparedStatement.setLong(2, cityUUID);
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_banes` SET `cap_set`=? WHERE `cityUUID`=?")) {
+
+            preparedStatement.setInt(1, 1);
+            preparedStatement.setLong(2, cityUUID);
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_banes` SET `cap_size`=? WHERE `cityUUID`=?")) {
+
+            preparedStatement.setInt(1, count);
+            preparedStatement.setLong(2, cityUUID);
+
+            preparedStatement.execute();
+
+        } catch (SQLException e) {
+            Logger.error(e);
+            return false;
+        }
+        return true;
+    }
+
     public boolean REMOVE_BANE(Bane bane) {
 
         if (bane == null)
@@ -107,4 +236,25 @@ public class dbBaneHandler extends dbHandlerBase {
 
         return true;
     }
+
+    public DateTime getLiveDate(int cityUUID) {
+        try (Connection connection = DbManager.getConnection();
+             PreparedStatement statement = connection.prepareStatement("SELECT `liveDate` FROM `dyn_banes` WHERE `cityUUID`=?")) {
+
+            statement.setInt(1, cityUUID);
+
+            try (ResultSet rs = statement.executeQuery()) {
+                if (rs.next()) {
+                    Timestamp liveDateTimestamp = rs.getTimestamp("liveDate");
+                    if (liveDateTimestamp != null) {
+                        return new DateTime(liveDateTimestamp.getTime());
+                    }
+                }
+            }
+
+        } catch (SQLException e) {
+            Logger.error(e);
+        }
+        return null; // Return null if liveDate is not found or an error occurs
+    }
 }

src/engine/db/handlers/dbCityHandler.java

@@ -11,10 +11,7 @@ package engine.db.handlers;
 
 import engine.Enum;
 import engine.gameManager.DbManager;
-import engine.objects.AbstractGameObject;
-import engine.objects.Building;
-import engine.objects.City;
-import engine.objects.Zone;
+import engine.objects.*;
 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();
-             PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_contract_selltype` WHERE `contractID` = ?;")) {
+        if(!contract.getName().contains("Sage")) {
+            try (Connection connection = DbManager.getConnection();
+                 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_contract_selltype` WHERE `contractID` = ?;")) {
 
-            preparedStatement.setInt(1, contract.getObjectUUID());
+                preparedStatement.setInt(1, contract.getObjectUUID());
 
-            ResultSet rs = preparedStatement.executeQuery();
+                ResultSet rs = preparedStatement.executeQuery();
 
-            while (rs.next()) {
+                while (rs.next()) {
 
-                int type = rs.getInt("type");
-                int value = rs.getInt("value");
+                    int type = rs.getInt("type");
+                    int value = rs.getInt("value");
 
-                switch (type) {
-                    case 1:
-                        contract.getBuyItemType().add(value);
-                        break;
-                    case 2:
+                    switch (type) {
+                        case 1:
+                            contract.getBuyItemType().add(value);
+                            break;
+                        case 2:
+                            contract.getBuySkillToken().add(value);
+                            break;
+                        case 3:
+                            contract.getBuyUnknownToken().add(value);
+                            break;
+                    }
+                }
+            } catch (SQLException e) {
+                Logger.error(e);
+            }
+        }else{
+            try (Connection connection = DbManager.getConnection();
+                 PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_contract_selltype`;")) {
+
+                ResultSet rs = preparedStatement.executeQuery();
+
+                while (rs.next()) {
+                    int value = rs.getInt("value");
+                    if(!contract.getBuySkillToken().contains(value))
                         contract.getBuySkillToken().add(value);
-                        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/dbItemHandler.java

@@ -134,9 +134,13 @@ public class dbItemHandler extends dbHandlerBase {
 
             ResultSet rs = preparedStatement.executeQuery();
 
-            if (rs.next())
-                worked = rs.getBoolean("result");
-
+            if (rs.next()) {
+                try {
+                    worked = rs.getBoolean("result");
+                }catch(Exception e){
+                    worked = false;
+                }
+            }
         } catch (SQLException e) {
             Logger.error(e);
         }
@@ -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;
-                BuildingManager.addHirelingForWorld(parentBuilding, pc, parentBuilding.getLoc(), parentBuilding.getParentZone(), contract, level);
-                return;
+                building = (Building)target;
             }
-
-        NPC npc = NPC.createNPC(name, contractID,
-                pc.getLoc(), null, zone, (short) level, null);
-
-        if (npc != null) {
-            WorldGrid.addObject(npc, pc);
-            ChatManager.chatSayInfo(pc,
-                    "NPC with ID " + npc.getDBID() + " added");
-            this.setResult(String.valueOf(npc.getDBID()));
-        } else {
-            throwbackError(pc, "Failed to create npc of contract type "
-                    + contractID);
-            Logger.error(
-                    "Failed to create npc of contract type " + contractID);
+        NPC created;
+        Guild guild = null;
+        Vector3fImmutable loc;
+        if(building != null){
+            guild = building.getGuild();
+            loc = building.loc;
+        } else{
+            loc = pc.loc;
+        }
+        created = NPC.createNPC(name, contractID, loc, guild, zone, (short)level, building);
+        created.bindLoc = loc;
+        if(building != null) {
+            created.buildingUUID = building.getObjectUUID();
+            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

@@ -18,6 +18,7 @@ import engine.gameManager.BuildingManager;
 import engine.gameManager.SessionManager;
 import engine.math.Vector3fImmutable;
 import engine.objects.*;
+import engine.server.MBServerStatics;
 import engine.util.StringUtils;
 
 import java.text.DecimalFormat;
@@ -337,7 +338,8 @@ public class InfoCmd extends AbstractDevCmd {
                 output += "Swimming : " + targetPC.isSwimming();
                 output += newline;
                 output += "isMoving : " + targetPC.isMoving();
-
+                output += newline;
+                output += "Zerg Multiplier : " + targetPC.ZergMultiplier;
                 break;
 
             case NPC:
@@ -529,6 +531,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.*;
 
@@ -72,6 +73,10 @@ public class PrintStatsCmd extends AbstractDevCmd {
         out += "Main Hand: atr: " + tar.getAtrHandOne() + ", damage: " + tar.getMinDamageHandOne() + " to " + tar.getMaxDamageHandOne() + ", speed: " + tar.getSpeedHandOne() + newline;
         out += "Off Hand:  atr: " + tar.getAtrHandTwo() + ", damage: " + tar.getMinDamageHandTwo() + " to " + tar.getMaxDamageHandTwo() + ", speed: " + tar.getSpeedHandTwo() + newline;
         out += "isAlive: " + tar.isAlive() + ", Combat: " + tar.isCombat() + newline;
+        out += "Move Speed: " + tar.getSpeed() + newline;
+        out += "Health Regen: " + tar.getRegenModifier(Enum.ModType.HealthRecoverRate) + newline;
+        out += "Mana Regen: " + tar.getRegenModifier(Enum.ModType.ManaRecoverRate) + newline;
+        out += "Stamina Regen: " + tar.getRegenModifier(Enum.ModType.StaminaRecoverRate) + newline;
         throwbackInfo(pc, out);
     }
 

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

@@ -646,24 +646,25 @@ public enum CombatManager {
 
             //Get hit chance
 
-            int chance;
+            //int chance;
             float dif = atr - defense;
 
-            if (dif > 100)
-                chance = 94;
-            else if (dif < -100)
-                chance = 4;
-            else
-                chance = (int) ((0.45 * dif) + 49);
+            //if (dif > 100)
+            //    chance = 94;
+            //else if (dif < -100)
+            //    chance = 4;
+            //else
+            //    chance = (int) ((0.45 * dif) + 49);
 
             errorTrack = 5;
 
             //calculate hit/miss
 
-            int roll = ThreadLocalRandom.current().nextInt(100);
             DeferredPowerJob dpj = null;
 
-            if (roll < chance) {
+
+
+            if (LandHit((int)atr,(int)defense)) {
 
                 if (ac.getObjectType().equals(GameObjectType.PlayerCharacter))
                     updateAttackTimers((PlayerCharacter) ac, target, true);
@@ -1054,6 +1055,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 +1242,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 +1330,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 +1453,17 @@ public enum CombatManager {
             ((AbstractCharacter) awo).getCharItemManager().damageRandomArmor(1);
     }
 
+    public static boolean LandHit(int C5, int D5){
+
+        float chance = (C5-((C5+D5)*.315f)) / ((D5-((C5+D5)*.315f)) + (C5-((C5+D5)*.315f)));
+        int convertedChance = Math.round(chance * 100);
+        //convertedChance = Math.max(5, Math.min(95, convertedChance));
+
+        int roll = ThreadLocalRandom.current().nextInt(101);
+
+        if(roll < 5)//always 5% chance ot miss
+            return false;
+
+        return roll <= convertedChance;
+    }
 }

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,23 @@ public enum DevCmdManager {
 
         //kill any commands not available to everyone on production server
         //only admin level can run dev commands on production
-
-        if (a.status.equals(Enum.AccountStatus.ADMIN) == false) {
+        boolean playerAllowed = 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":
+                    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;
@@ -67,41 +75,111 @@ public enum LootManager {
     }
 
     public static void GenerateMobLoot(Mob mob) {
-
         //determine if mob is in hotzone
-        boolean inHotzone = ZoneManager.inHotZone(mob.getLoc());
+        boolean inHotzone = false;
 
         //iterate the booty sets
 
-        if (mob.getMobBase().bootySet != 0 && _bootySetMap.containsKey(mob.getMobBase().bootySet) == true)
+        if(mob.mobBase == null || mob.getMobBaseID() == 253003){
+            int i = 0;
+        }
+
+        if (mob.getMobBase().bootySet != 0 && _bootySetMap.containsKey(mob.getMobBase().bootySet))
             RunBootySet(_bootySetMap.get(mob.getMobBase().bootySet), mob, inHotzone);
 
-        if (mob.bootySet != 0 && _bootySetMap.containsKey(mob.bootySet) == true)
+        if (mob.bootySet != 0 && _bootySetMap.containsKey(mob.bootySet)) {
             RunBootySet(_bootySetMap.get(mob.bootySet), mob, inHotzone);
+        }else if(mob.bootySet != 0 && ItemBase.getItemBase(mob.bootySet) != null){
+            MobLoot specialDrop = null;
+            specialDrop = new MobLoot(mob,ItemBase.getItemBase(mob.bootySet),true);
+            if(specialDrop != null) {
+                ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + mob.getParentZone().getName() + " has found the " + specialDrop.getName() + ". Are you tough enough to take it?");
+                chatMsg.setMessageType(10);
+                chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+                DispatchMessage.dispatchMsgToAll(chatMsg);
+                mob.getCharItemManager().addItemToInventory(specialDrop);
+                mob.setResists(new Resists("Dropper"));
+                if(!Mob.discDroppers.contains(mob))
+                    Mob.AddDiscDropper(mob);
+            }
 
-        //lastly, check mobs inventory for godly or disc runes to send a server announcement
-            for (Item it : mob.getInventory()) {
+        }
 
-                ItemBase ib = it.getItemBase();
-                if(ib == null)
-                    break;
-                if (ib.isDiscRune() || ib.getName().toLowerCase().contains("of the gods")) {
-                    ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + mob.getParentZone().getName() + " has found the " + ib.getName() + ". Are you tough enough to take it?");
-                    chatMsg.setMessageType(10);
-                    chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
-                    DispatchMessage.dispatchMsgToAll(chatMsg);
-                }
+        //lastly, check mobs inventory for godly or disc runes to send a server announcement
+        for (Item it : mob.getInventory()) {
+
+            ItemBase ib = it.getItemBase();
+            if (ib == null)
+                break;
+            if (ib.isDiscRune() || ib.getName().toLowerCase().contains("of the gods")) {
+                ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + mob.getParentZone().getName() + " has found the " + ib.getName() + ". Are you tough enough to take it?");
+                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));
+            }
+
+            // 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
 
+        // Iterate all entries in this bootySet and process accordingly
         for (BootySetEntry bse : entries) {
             switch (bse.bootyType) {
                 case "GOLD":
@@ -109,8 +187,10 @@ public enum LootManager {
                     break;
                 case "LOOT":
 
-                    if (mob.getSafeZone() == false)
-                        dropRate = LootManager.NORMAL_DROP_RATE;
+                    if (mob.getSafeZone())
+                        return; // no loot to drop in safezones
+
+                    dropRate = LootManager.NORMAL_DROP_RATE;
 
                     if (inHotzone == true)
                         dropRate = LootManager.HOTZONE_DROP_RATE;
@@ -135,6 +215,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 +339,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 +354,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 +388,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 +414,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 +446,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 +461,36 @@ public enum LootManager {
         return inItem;
     }
 
-    public static int TableRoll(int mobLevel, Boolean inHotzone) {
-
-        if (mobLevel > 65)
-            mobLevel = 65;
-
-        int max = (int) (4.882 * mobLevel + 127.0);
-
-        if (max > 319)
-            max = 319;
-
-        int min = (int) (4.469 * mobLevel - 3.469);
-
-        if (min < 70)
-            min = 70;
-
-        if (inHotzone)
-            min += mobLevel;
+    public static int TableRoll(int mobLevel) {
+
+        int rank = (int)(mobLevel * 0.1f);
+        int min = 50;
+        int max = 100;
+        switch(rank){
+            case 1:
+                min = 200;
+                max = 250;
+                break;
+            case 2:
+                min = 210;
+                max = 275;
+                break;
+            case 3:
+                min = 220;
+                max = 300;
+                break;
+            case 4:
+                min = 230;
+                max = 320;
+                break;
+            case 5:
+            case 6:
+            case 7:
+            case 8:
+                min = 240;
+                max = 320;
+                break;
+        }
 
         int roll = ThreadLocalRandom.current().nextInt(min, max + 1);
 
@@ -299,12 +510,7 @@ public enum LootManager {
 
         int high = bse.highGold;
         int low = bse.lowGold;
-        int gold = ThreadLocalRandom.current().nextInt(low, high + 1);
-
-        if (inHotzone == true)
-            gold = (int) (gold * HOTZONE_GOLD_RATE);
-        else
-            gold = (int) (gold * NORMAL_GOLD_RATE);
+        int gold = (int) (ThreadLocalRandom.current().nextInt(low, high + 1) * NORMAL_GOLD_RATE);
 
         if (gold > 0) {
             MobLoot goldAmount = new MobLoot(mob, gold);
@@ -315,45 +521,63 @@ public enum LootManager {
 
     public static void GenerateLootDrop(Mob mob, int tableID, Boolean inHotzone) {
 
-        try {
-
-            MobLoot toAdd = getGenTableItem(tableID, mob, inHotzone);
-
-            if (toAdd != null)
-                mob.getCharItemManager().addItemToInventory(toAdd);
-
-        } catch (Exception e) {
-            //TODO chase down loot generation error, affects roughly 2% of drops
-            int i = 0;
+        MobLoot toAdd = getGenTableItem(tableID, mob, inHotzone);
+        if(toAdd != null){
+            ItemBase ib = toAdd.getItemBase();
+            switch(ib.getType()){
+                case CONTRACT:
+                case RUNE:
+                case RESOURCE:
+                    return;
+            }
+            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.setDurabilityCurrent((short) (ml.getDurabilityCurrent() - ThreadLocalRandom.current().nextInt(5) + 1));
-                    mob.getCharItemManager().addItemToInventory(ml);
-                    dropCount = 1;
-                    //break; // Exit on first successful roll.
-                }
+                ml.setIsID(true);
+                ml.setDurabilityCurrent((short) (ml.getDurabilityCurrent() - ThreadLocalRandom.current().nextInt(5) + 1));
+                mob.getCharItemManager().addItemToInventory(ml);
             }
+        }
     }
 
     public static void GenerateInventoryDrop(Mob mob, BootySetEntry bse) {
@@ -367,8 +591,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 +619,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 +640,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)
-            return;
+            if (winnings == null)
+                return;
 
-        //early exit if the inventory of the player will not old the item
+            //early exit if the inventory of the player will not hold the item
 
-        if (itemMan.hasRoomInventory(winnings.getItemBase().getWeight()) == false) {
-            ErrorPopupMsg.sendErrorPopup(playerCharacter, 21);
-            return;
+            if (itemMan.hasRoomInventory(winnings.getItemBase().getWeight()) == false) {
+                ErrorPopupMsg.sendErrorPopup(playerCharacter, 21);
+                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){
-            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);
+    public static ItemBase getRandomVorg(ItemBase itemBase){
+        int roll = 0;
+        if(vorg_ha_uuids.contains(itemBase.getUUID())) {
+            roll = ThreadLocalRandom.current().nextInt(0, 10);
+            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){
-            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);
+        if(vorg_la_uuids.contains(itemBase.getUUID())) {
+            roll = ThreadLocalRandom.current().nextInt(0, 10);
+            switch (roll) {
+                case 1:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(0));
+                case 2:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(1));
+                case 3:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(2));
+                case 4:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(3));
+                case 5:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(4));
+                case 6:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(5));
+                case 7:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(6));
+                default:
+                    return ItemBase.getItemBase(vorg_la_uuids.get(7));
+            }
         }
-        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);
-        itemMan.addItemToInventory(playerWinnings);
-        itemMan.updateInventory();
+        int multiplier = 1;
+        if (commander)
+            multiplier = 2;
+        if(epic)
+            multiplier = 10;
+
+        int high = 125000;
+        int low = 50000;
+        int gold = ThreadLocalRandom.current().nextInt(low, high + 1) * multiplier;
+
+        if (gold > 0) {
+            MobLoot goldAmount = new MobLoot(mob, gold);
+            mob.getCharItemManager().addItemToInventory(goldAmount);
+        }
+
+        //present drop chance for all
+        if (ThreadLocalRandom.current().nextInt(100) < 35)
+            DropPresent(mob);
+
+        //random contract drop chance for all
+        if (ThreadLocalRandom.current().nextInt(100) < 40) {
+            int contractTableID = 250;
+            contractTableID += ThreadLocalRandom.current().nextInt(0, 11);
+            if (contractTableID > 259)
+                contractTableID = 659;
+
+                int id = rollRandomItem(contractTableID);
+                ItemBase ib = ItemBase.getItemBase(id);
+                if (ib != null) {
+                    MobLoot contract = new MobLoot(mob, ib, true);
+
+                    if (contract != null)
+                        mob.getCharItemManager().addItemToInventory(contract);
+                }
+        }
+
+        //special commander drop chances
+        if (commander)
+            GenerateCommanderLoot(mob,false);
+
+        //special epic drop chances
+        if (epic) {
+            GenerateCommanderLoot(mob, true);
+            GenerateCommanderLoot(mob,false);
+        }
+    }
+
+    public static void GenerateCommanderLoot(Mob mob, boolean epic){
+        //present chance
+        if (ThreadLocalRandom.current().nextInt(100) < 25)
+            DropPresent(mob);
+
+        //present chance
+        if (ThreadLocalRandom.current().nextInt(100) < 25)
+            DropPresent(mob);
+
+        //chance for glass
+        if (ThreadLocalRandom.current().nextInt(100) < 75) {
+            int glassID = rollRandomItem(126);
+            ItemBase glassItem = ItemBase.getItemBase(glassID);
+            if (glassItem != null) {
+                MobLoot toAdd2 = new MobLoot(mob, glassItem, true);
+
+                if (toAdd2 != null)
+                    mob.getCharItemManager().addItemToInventory(toAdd2);
+            }
+        }
+
+        //chance for disc
+        if (ThreadLocalRandom.current().nextInt(100) < 75) {
+            int discID = rollRandomItem(3202);
+            ItemBase discItem = ItemBase.getItemBase(discID);
+            if (discItem != null) {
+                MobLoot toAdd3 = new MobLoot(mob, discItem, true);
+
+                if (toAdd3 != null)
+                    mob.getCharItemManager().addItemToInventory(toAdd3);
+            }
+        }
+
+        //chance for stat rune
+        if (ThreadLocalRandom.current().nextInt(100) < 75) {
+            int runeID = rollRandomItem(3201);
+            ItemBase runeItem = ItemBase.getItemBase(runeID);
+            if (runeItem != null) {
+                MobLoot toAdd4 = new MobLoot(mob, runeItem, true);
+
+                if (toAdd4 != null)
+                    mob.getCharItemManager().addItemToInventory(toAdd4);
+            }
+        }
+        if(epic){
+            int contractTableID = 250;
+            contractTableID += ThreadLocalRandom.current().nextInt(0, 11);
+            if (contractTableID > 259)
+                contractTableID = 659;
+
+            int id = rollRandomItem(contractTableID);
+            ItemBase ib = ItemBase.getItemBase(id);
+            if (ib != null) {
+                MobLoot contract = new MobLoot(mob, ib, true);
+
+                if (contract != null)
+                    mob.getCharItemManager().addItemToInventory(contract);
+            }
+        }
     }
 }

src/engine/gameManager/MaintenanceManager.java

@@ -24,7 +24,7 @@ public enum MaintenanceManager {
 
     public static void setMaintDateTime(Building building, LocalDateTime maintDate) {
 
-        building.maintDateTime = maintDate;
+        building.maintDateTime = maintDate.withHour(1).withMinute(0).withSecond(0);
         DbManager.BuildingQueries.updateMaintDate(building);
 
     }
@@ -49,19 +49,15 @@ public enum MaintenanceManager {
 
             if (chargeUpkeep(building) == false)
                 derankList.add(building);
+            else
+                setMaintDateTime(building, LocalDateTime.now().plusDays(7));
         }
-        // Reset maintenance dates for these buildings
 
-        for (Building building : maintList) {
-            setMaintDateTime(building, LocalDateTime.now().plusDays(7));
-
-        }
-        // Derak or destroy buildings that did not
-        // have funds available.
-
-        for (Building building : derankList)
+        for (Building building : derankList) {
             building.destroyOrDerank(null);
-
+            if(building.getRank() > 0)
+                setMaintDateTime(building, LocalDateTime.now().plusDays(1));
+        }
         Logger.info("Structures: " + buildingList.size() + " Maint: " + maintList.size() + " Derank: " + derankList.size());
     }
 
@@ -98,6 +94,10 @@ public enum MaintenanceManager {
                 continue;
             }
 
+            //only ToL pays maintenance
+            if(building.getBlueprint().getBuildingGroup() != null && !building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.TOL))
+                continue;
+
             // No maintenance on banestones omfg
 
             if (building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.BANESTONE))
@@ -122,9 +122,9 @@ public enum MaintenanceManager {
 
 
             //no maintenance if day of week doesnt match
-            if (LocalDateTime.now().getDayOfWeek().ordinal() != building.maintDateTime.getDayOfWeek().ordinal()) {
-                continue;
-            }
+            //if (LocalDateTime.now().getDayOfWeek().ordinal() != building.maintDateTime.getDayOfWeek().ordinal()) {
+            //    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)
-            Logger.error("No available slot for NPC: " + abstractCharacter.getObjectUUID());
+        //if (buildingSlot == -1)
+            //Logger.error("No available slot for NPC: " + abstractCharacter.getObjectUUID());
 
         abstractCharacter.building.getHirelings().put(abstractCharacter, buildingSlot);
 

src/engine/gameManager/PowersManager.java

@@ -163,6 +163,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 +179,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);
@@ -205,6 +210,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 +281,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 +293,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 +349,12 @@ public enum PowersManager {
             msg.setNumTrains(trains);
         }
 
+        switch(pb.token){
+            case 429420458: // BH eyes
+                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 +446,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 +568,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 +594,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,7 +602,9 @@ public enum PowersManager {
         }
 
         // update cast (use skill) fail condition
-        playerCharacter.cancelOnCast();
+        if(pb.token != 429396028) {
+            playerCharacter.cancelOnCast();
+        }
 
         // update castSpell (use spell) fail condition if spell
         if (pb.isSpell())
@@ -535,13 +617,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);
@@ -706,8 +787,19 @@ public enum PowersManager {
         if (playerCharacter == null || msg == null)
             return;
 
+        //if((msg.getPowerUsedID() == 429495514 || msg.getPowerUsedID() == 429407306) && playerCharacter.getRace().getName().toLowerCase().contains("shade")){
+        //    //use sneak instead of hide
+        //    PowersBase pb = PowersManager.getPowerByToken(429397210);
+        //    int offsetTrains = (40 - msg.getNumTrains()) ;
+        //    applyPower(playerCharacter,playerCharacter,playerCharacter.loc,429397210,msg.getNumTrains(),false);
+        //    applyPower(playerCharacter,playerCharacter,playerCharacter.loc,427857146,offsetTrains,false);
+        //}
+        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 +901,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);
-                    return;
+                        sendPowerMsg(playerCharacter, 8, msg);
+                        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 +1326,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 +1430,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 +1565,17 @@ public enum PowersManager {
         }
 
         // create list of characters
-        HashSet<AbstractCharacter> trackChars = RangeBasedAwo.getTrackList(
-                allTargets, playerCharacter, maxTargets);
+        HashSet<AbstractCharacter> trackChars;
+        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 +1588,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 +2325,7 @@ public enum PowersManager {
 
         // set player is not casting for regens
         if (pc.isCasting()) {
-            pc.update();
+            pc.update(false);
         }
         pc.setIsCasting(false);
 
@@ -2241,28 +2377,26 @@ public enum PowersManager {
             defense = 0f;
         // Get hit chance
 
-        if (pc.getDebug(16)) {
-            String smsg = "ATR: " + atr + ", Defense: " + defense;
-            ChatManager.chatSystemInfo(pc, smsg);
-        }
+        //if (pc.getDebug(16)) {
+        //    String smsg = "ATR: " + atr + ", Defense: " + defense;
+         //   ChatManager.chatSystemInfo(pc, smsg);
+        //}
 
-        int chance;
+        //int chance;
 
-        if (atr > defense || defense == 0)
-            chance = 94;
-        else {
-            float dif = atr / defense;
-            if (dif <= 0.8f)
-                chance = 4;
-            else
-                chance = ((int) (450 * (dif - 0.8f)) + 4);
-        }
+        //if (atr > defense || defense == 0)
+        //    chance = 94;
+        //else {
+        //    float dif = atr / defense;
+        //    if (dif <= 0.8f)
+        //        chance = 4;
+        //    else
+        //        chance = ((int) (450 * (dif - 0.8f)) + 4);
+        //}
 
         // calculate hit/miss
-        int roll = ThreadLocalRandom.current().nextInt(100);
 
-        boolean disable = true;
-        if (roll < chance) {
+        if (CombatManager.LandHit((int)atr,(int)defense)) {
             // Hit, check if dodge kicked in
             if (awo instanceof AbstractCharacter) {
                 AbstractCharacter tarAc = (AbstractCharacter) awo;
@@ -2562,7 +2696,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) {

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.City;
-import engine.objects.PlayerCharacter;
-import engine.objects.Runegate;
+import engine.objects.*;
 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)
-                    && (System.currentTimeMillis() > _cityPulseTime))
-                pulseCities();
+            if ((_cityPulseTime != 0) && (System.currentTimeMillis() > _cityPulseTime)) {
+                try {
+                    pulseCities();
+                }catch(Exception e){
+
+                }
+                try {
+                    ArenaManager.pulseArenas();
+                }catch(Exception e){
+
+                }
+            }
         } catch (Exception e) {
             Logger.error(
                     "Fatal error in City Pulse: DISABLED. Error Message : "
@@ -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/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);
-            return;
-        }
+        //    PowersManager.finishRecycleTime(428523680, this.source, false);
+        //    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/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)
-            if (roll >= iteration.minRoll && roll <= iteration.maxRoll)
-                itemTableEntry = iteration;
+        itemTableEntryList = LootManager._itemTables.get(itemTable);
 
-        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);
-
-        for (ModTableEntry iteration : itemTableEntryList)
-            if (roll >= iteration.minRoll && roll <= iteration.maxRoll)
-                modTableEntry = iteration;
-
+        if(itemTableEntryList != null) {
+            for (ModTableEntry iteration : itemTableEntryList)
+                if (roll >= iteration.minRoll && roll <= iteration.maxRoll)
+                    modTableEntry = iteration;
+        }
         return modTableEntry;
     }
 }

src/engine/math/Bounds.java

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

src/engine/mobileAI/MobAI.java

@@ -82,6 +82,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());
         }
@@ -156,9 +166,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 +179,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 +208,11 @@ public class MobAI {
                 mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
             }
 
-            if (mob.isSiege()) {
-                PowerProjectileMsg ppm = new PowerProjectileMsg(mob, target);
-                ppm.setRange(50);
-                DispatchMessage.dispatchMsgToInterestArea(mob, ppm, DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
-            }
+            //if (mob.isSiege()) {
+            //    PowerProjectileMsg ppm = new PowerProjectileMsg(mob, target);
+            //    ppm.setRange(50);
+            //    DispatchMessage.dispatchMsgToInterestArea(mob, ppm, DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
+            //}
 
         } catch (Exception e) {
             Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackBuilding" + " " + e.getMessage());
@@ -400,7 +413,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 {
@@ -589,6 +602,26 @@ public class MobAI {
             if (mob == null)
                 return;
 
+            boolean continueExecution = false;
+            switch(mob.BehaviourType){
+                case GuardCaptain:
+                case GuardMinion:
+                case Pet1:
+                case GuardWallArcher:
+                case HamletGuard:
+                case SimpleStandingGuard:
+                    continueExecution = true;
+                    break;
+            }
+            if(!continueExecution) {
+                MobAi2.runAI(mob);
+                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 +658,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 +676,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,16 +887,14 @@ 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();
@@ -874,9 +902,15 @@ public class MobAI {
                         }
                     }
                 }
-            } 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 (System.currentTimeMillis() > (aiAgent.deathTime + (aiAgent.spawnTime * 1000L))) {
+                if (!Zone.respawnQue.contains(aiAgent)) {
                     Zone.respawnQue.add(aiAgent);
                 }
             }
@@ -911,7 +945,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 +970,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());
@@ -945,7 +990,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 +998,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());
@@ -1006,7 +1052,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 +1075,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 +1115,8 @@ public class MobAI {
     public static void GuardMinionLogic(Mob mob) {
 
         try {
+            checkToDropGuardAggro(mob);
+
             boolean isComanded = mob.npcOwner.isAlive();
             if (!isComanded) {
                 GuardCaptainLogic(mob);
@@ -1076,6 +1137,8 @@ public class MobAI {
     public static void GuardWallArcherLogic(Mob mob) {
 
         try {
+            checkToDropGuardAggro(mob);
+
             if (mob.getCombatTarget() == null)
                 CheckForPlayerGuardAggro(mob);
             else
@@ -1351,21 +1414,24 @@ 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)
-            mob.getTimestamps().put("HEALTHRECOVERED", System.currentTimeMillis());
-
-        if (mob.isSit() && mob.getTimeStamp("HEALTHRECOVERED") < System.currentTimeMillis() + 3000)
-            if (mob.getHealth() < mob.getHealthMax()) {
+            if (mob.isSit() && mob.getTimeStamp("HEALTHRECOVERED") < System.currentTimeMillis() + 3000)
+                if (mob.getHealth() < mob.getHealthMax()) {
 
-                float recoveredHealth = mob.getHealthMax() * ((1 + mob.getBonuses().getFloatPercentAll(Enum.ModType.HealthRecoverRate, Enum.SourceType.None)) * 0.01f);
-                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);
+                    mob.setHealth(mob.getHealth() + recoveredHealth);
+                    mob.getTimestamps().put("HEALTHRECOVERED", System.currentTimeMillis());
 
-                if (mob.getHealth() > mob.getHealthMax())
-                    mob.setHealth(mob.getHealthMax());
-            }
+                    if (mob.getHealth() > mob.getHealthMax())
+                        mob.setHealth(mob.getHealthMax());
+                }
+        } catch (Exception e) {
+            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: RecoverHealth" + " " + e.getMessage());
+        }
     }
 }

src/engine/mobileAI/MobAi2.java

@@ -0,0 +1,360 @@
+package engine.mobileAI;
+
+import engine.Enum;
+import engine.InterestManagement.WorldGrid;
+import engine.gameManager.*;
+import engine.mobileAI.Threads.MobAIThread;
+import engine.mobileAI.utilities.CombatUtilities;
+import engine.mobileAI.utilities.MovementUtilities;
+import engine.objects.*;
+import engine.server.MBServerStatics;
+import org.pmw.tinylog.Logger;
+
+import java.util.HashSet;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class MobAi2 {
+
+    public enum State
+    {
+        Idle,
+        Patrolling,
+        Attacking,
+        Dead
+    }
+
+    public static boolean Agressive(Mob mob){
+        return mob.BehaviourType.name().contains("Aggro");
+    }
+
+    public static boolean Caster(Mob mob){
+        return mob.BehaviourType.name().contains("Power");
+    }
+
+    public static boolean HelpResponder(Mob mob){
+        return mob.BehaviourType.name().contains("Helpee");
+    }
+
+    public static State getState(Mob mob){
+
+        if(!mob.isAlive())
+            return State.Dead;
+
+        if(mob.playerAgroMap.isEmpty())
+            return State.Idle;
+
+        if(mob.combatTarget != null)
+            return State.Attacking;
+
+        return State.Patrolling;
+    }
+
+    public static void runAI(Mob mob){
+
+        //these will be handled in special conditions later
+        switch(mob.BehaviourType){
+            case GuardCaptain:
+            case GuardMinion:
+            case Pet1:
+            case GuardWallArcher:
+            case HamletGuard:
+            case SimpleStandingGuard:
+                return;
+        }
+        switch(getState(mob)){
+            case Idle:
+                if(mob.isMoving())
+                    mob.stopMovement(mob.loc);
+                if(mob.combatTarget != null) {
+                    mob.setCombatTarget(null);
+                    mob.setCombat(false);
+                }
+                return;
+            case Dead:
+                respawn(mob);
+                break;
+            case Patrolling:
+                patrol(mob);
+                break;
+            case Attacking:
+                attack(mob);
+                break;
+        }
+    }
+
+    //handles respawning and de-spawning for mobs and their corpses
+    public static void respawn(Mob mob){
+
+        //if mob doesn't have a death time somehow, set it to now
+        if (mob.deathTime == 0)
+            mob.setDeathTime(System.currentTimeMillis());
+
+        //only execute this logic is the mob hasn't de-spawned yet
+        if (!mob.despawned) {
+
+            //if the inventory is empty, the mob can disappear
+            if(mob.getInventory(true).isEmpty() && System.currentTimeMillis() > mob.deathTime + 10000L) {
+                mob.despawn();
+                mob.deathTime = System.currentTimeMillis();
+                return;
+            }
+
+            //if the mob has been dead for 10 seconds it can disappear
+            if (System.currentTimeMillis() > mob.deathTime + 10000L) {
+                mob.despawn();
+                mob.deathTime = System.currentTimeMillis();
+                return;
+            }
+        }
+
+        //disc dropper respawns are handled elsewhere
+        if(Mob.discDroppers.contains(mob))
+            return;
+
+        //if mob isn't queued for respawn, do so now
+        if (!Zone.respawnQue.contains(mob)) {
+            if (System.currentTimeMillis() > (mob.deathTime + (mob.spawnTime * 1000L))) {
+                Zone.respawnQue.add(mob);
+            }
+        }
+    }
+
+    //handles patrolling and looking for potential combat targets
+    public static void patrol(Mob mob){
+        if(Agressive(mob) && mob.combatTarget == null) {
+            HashSet<AbstractWorldObject> potentialTargets = WorldGrid.getObjectsInRangePartial(mob.loc, 50, MBServerStatics.MASK_PLAYER);
+            for (AbstractWorldObject awo : potentialTargets) {
+                PlayerCharacter target = (PlayerCharacter) awo;
+                if (mob.canSee(target))
+                    mob.setCombatTarget(target);
+                if (mob.combatTarget != null) {
+                    return;
+                }
+            }
+        }
+        if(mob.isMoving() || !mob.BehaviourType.canRoam)
+            return;
+
+        int patrolDelay = ThreadLocalRandom.current().nextInt((int) (MobAIThread.AI_PATROL_DIVISOR * 0.5f), MobAIThread.AI_PATROL_DIVISOR) + MobAIThread.AI_PATROL_DIVISOR;
+
+        if (mob.stopPatrolTime + (patrolDelay * 1000L) > System.currentTimeMillis())
+            return;
+
+        if (mob.lastPatrolPointIndex > mob.patrolPoints.size() - 1)
+            mob.lastPatrolPointIndex = 0;
+
+        mob.destination = mob.patrolPoints.get(mob.lastPatrolPointIndex);
+        mob.lastPatrolPointIndex += 1;
+        MovementUtilities.aiMove(mob, mob.destination, true);
+    }
+
+    public static void attack(Mob mob){
+        AbstractWorldObject target = mob.combatTarget;
+
+        if (target == null || !target.isAlive()) {
+            mob.setCombatTarget(null);
+            return;
+        }
+
+        if(!mob.isCombat())
+            mob.setCombat(true);
+
+        if (!CombatUtilities.inRangeToAttack(mob, target) && mob.BehaviourType.canRoam) {
+            if(mob.nextChaseUpdate < System.currentTimeMillis()) {
+                mob.nextChaseUpdate = System.currentTimeMillis() + 2500L;
+                MovementUtilities.aiMove(mob, target.loc, false);
+            }
+            return;
+        }
+
+        switch (target.getObjectType()) {
+            case PlayerCharacter:
+                PlayerCharacter targetPlayer = (PlayerCharacter) target;
+                AttackPlayer(mob, targetPlayer);
+                break;
+            case Building:
+                Building targetBuilding = (Building) target;
+                AttackBuilding(mob, targetBuilding);
+                break;
+            case Mob:
+                Mob targetMob = (Mob) target;
+                AttackMob(mob, targetMob);
+                break;
+        }
+    }
+
+    public static void AttackPlayer(Mob mob, PlayerCharacter target) {
+
+        try {
+
+            if (!mob.canSee(target)) {
+                mob.setCombatTarget(null);
+                return;
+            }
+
+            if (mob.BehaviourType.callsForHelp)
+                MobCallForHelp(mob);
+
+            if (!MovementUtilities.inRangeDropAggro(mob, target)) {
+                mob.setCombatTarget(null);
+                return;
+            }
+
+            if (CombatUtilities.inRange2D(mob, target, mob.getRange())) {
+
+                //no weapons, default mob attack speed 3 seconds.
+
+                if (System.currentTimeMillis() < mob.getLastAttackTime())
+                    return;
+
+                // ranged mobs can't attack while running. skip until they finally stop.
+
+                if (mob.isMoving() && mob.getRange() > 20)
+                    return;
+
+                // add timer for last attack.
+
+                ItemBase mainHand = mob.getWeaponItemBase(true);
+                ItemBase offHand = mob.getWeaponItemBase(false);
+
+                if (mainHand == null && offHand == null) {
+                    CombatUtilities.combatCycle(mob, target, true, null);
+                    int delay = 3000;
+                    if (mob.isSiege())
+                        delay = 11000;
+                    mob.setLastAttackTime(System.currentTimeMillis() + delay);
+                } else if (mob.getWeaponItemBase(true) != null) {
+                    int delay = 3000;
+                    if (mob.isSiege())
+                        delay = 11000;
+                    CombatUtilities.combatCycle(mob, target, true, mob.getWeaponItemBase(true));
+                    mob.setLastAttackTime(System.currentTimeMillis() + delay);
+                } else if (mob.getWeaponItemBase(false) != null) {
+                    int attackDelay = 3000;
+                    if (mob.isSiege())
+                        attackDelay = 11000;
+                    CombatUtilities.combatCycle(mob, target, false, mob.getWeaponItemBase(false));
+                    mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
+                }
+            }
+
+            if (target.getPet() != null)
+                if (target.getPet().getCombatTarget() == null && target.getPet().assist)
+                    target.getPet().setCombatTarget(mob);
+
+        } catch (Exception e) {
+            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackPlayer" + " " + e.getMessage());
+        }
+
+    }
+
+    public static void AttackBuilding(Mob mob, Building target) {
+
+        try {
+
+            if(mob == null || target == null)
+                return;
+
+            if (target.getRank() == -1 || !target.isVulnerable() || BuildingManager.getBuildingFromCache(target.getObjectUUID()) == null) {
+                mob.setCombatTarget(null);
+                return;
+            }
+
+            City playerCity = ZoneManager.getCityAtLocation(mob.getLoc());
+
+            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() != null && mob.getGuild() != null && !guard.getGuild().equals(mob.getGuild()))
+                            guard.setCombatTarget(mob);
+
+            if (mob.isSiege())
+                MovementManager.sendRWSSMsg(mob);
+
+            ItemBase mainHand = mob.getWeaponItemBase(true);
+            ItemBase offHand = mob.getWeaponItemBase(false);
+
+            if (mainHand == null && offHand == null) {
+                CombatUtilities.combatCycle(mob, target, true, null);
+                int delay = 3000;
+                if (mob.isSiege())
+                    delay = 15000;
+                mob.setLastAttackTime(System.currentTimeMillis() + delay);
+            } else if (mob.getWeaponItemBase(true) != null) {
+                int attackDelay = 3000;
+                if (mob.isSiege())
+                    attackDelay = 15000;
+                CombatUtilities.combatCycle(mob, target, true, mob.getWeaponItemBase(true));
+                mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
+            } else if (mob.getWeaponItemBase(false) != null) {
+                int attackDelay = 3000;
+                if (mob.isSiege())
+                    attackDelay = 15000;
+                CombatUtilities.combatCycle(mob, target, false, mob.getWeaponItemBase(false));
+                mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
+            }
+
+        } catch (Exception e) {
+            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackBuilding" + " " + e.getMessage());
+        }
+    }
+
+    public static void AttackMob(Mob mob, Mob target) {
+
+        try {
+
+            if (mob.getRange() >= 30 && mob.isMoving())
+                return;
+
+            //no weapons, default mob attack speed 3 seconds.
+
+            ItemBase mainHand = mob.getWeaponItemBase(true);
+            ItemBase offHand = mob.getWeaponItemBase(false);
+
+            if (mainHand == null && offHand == null) {
+                CombatUtilities.combatCycle(mob, target, true, null);
+                int delay = 3000;
+                if (mob.isSiege())
+                    delay = 11000;
+                mob.setLastAttackTime(System.currentTimeMillis() + delay);
+            } else if (mob.getWeaponItemBase(true) != null) {
+                int attackDelay = 3000;
+                if (mob.isSiege())
+                    attackDelay = 11000;
+                CombatUtilities.combatCycle(mob, target, true, mob.getWeaponItemBase(true));
+                mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
+            } else if (mob.getWeaponItemBase(false) != null) {
+                int attackDelay = 3000;
+                if (mob.isSiege())
+                    attackDelay = 11000;
+                CombatUtilities.combatCycle(mob, target, false, mob.getWeaponItemBase(false));
+                mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
+                if (target.getCombatTarget() == null) {
+                    target.setCombatTarget(mob);
+                }
+            }
+        } catch (Exception e) {
+            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackMob" + " " + e.getMessage());
+        }
+    }
+
+    public static void MobCallForHelp(Mob mob) {
+
+            if (mob.nextCallForHelp == 0)
+                mob.nextCallForHelp = System.currentTimeMillis();
+
+            if (mob.nextCallForHelp > System.currentTimeMillis())
+                return;
+
+            Zone mobCamp = mob.getParentZone();
+
+            for (Mob helper : mobCamp.zoneMobSet) {
+                if (HelpResponder(helper)) {
+                    helper.setCombatTarget(mob.getCombatTarget());
+                    break;
+                }
+            }
+
+            mob.nextCallForHelp = System.currentTimeMillis() + 30000L;
+    }
+}

src/engine/mobileAI/Threads/MobRespawnThread.java

@@ -8,6 +8,8 @@
 
 
 package engine.mobileAI.Threads;
+import engine.InterestManagement.InterestManager;
+import engine.InterestManagement.WorldGrid;
 import engine.gameManager.ZoneManager;
 import engine.objects.Mob;
 import engine.objects.Zone;
@@ -49,6 +51,8 @@ public class MobRespawnThread implements Runnable {
                         respawner.respawn();
                         zone.respawnQue.remove(respawner);
                         zone.lastRespawn = System.currentTimeMillis();
+                        WorldGrid.updateObject(respawner);
+                        InterestManager.setObjectDirty(respawner);
                     }
                 }
             } catch (Exception e) {

src/engine/mobileAI/utilities/CombatUtilities.java

@@ -139,37 +139,22 @@ public class CombatUtilities {
     }
 
     public static boolean triggerDefense(Mob agent, AbstractWorldObject target) {
-        int defenseScore = 0;
-        int attackScore = agent.getAtrHandOne();
+        int defense = 0;
+        int atr = agent.getAtrHandOne();
         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;
         }
-
-        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;
+        return !CombatManager.LandHit(atr,defense);
     }
 
     public static boolean triggerBlock(Mob agent, AbstractWorldObject ac) {

src/engine/net/NetMsgFactory.java

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

src/engine/net/client/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())
-            if (itemManager.delete(i) == true) {
+        //cannot delete gold
+        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 (profit < 1)
-                                profit = 1;
-
+                            if(npc.isInSafeZone())
+                                profit = 0;
+                            else
+                                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 (!itemMan.buyFromNPC(b, cost, buildingDeposit)) {
+                            }if(npc.getContractID() == 1502041){
+                                me.fromNoob = true;
+                            } else if (!itemMan.buyFromNPC(b, cost, buildingDeposit)) {
                                 // chatMan.chatSystemInfo(pc, "" + "You Failed to buy the item.");
+                                ChatManager.chatSystemError(sourcePlayer, "Failed To Buy Item");
                                 return;
                             }
-
-                            buy = Item.createItemForPlayer(sourcePlayer, ib);
-
-                            if (buy != null) {
-                                me.transferEnchants(buy);
-                                itemMan.addItemToInventory(buy);
-                                //itemMan.updateInventory();
+                            if(me.getItemBase().getType().equals(ItemType.RESOURCE) && npc.getContractID() == 900){
+                                handleResourcePurchase(me,itemMan,sourcePlayer,ib);
+                            }else {
+                                buy = Item.createItemForPlayer(sourcePlayer, ib, me.fromNoob);
+                                if (buy != null) {
+                                    me.transferEnchants(buy);
+                                    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()) {
+                    if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold() && !b.isOwnerIsNPC()) {
                         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()) {
+                    if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold() && !b.isOwnerIsNPC()) {
                         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/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() ||
-                mine.getOwningGuild().getObjectUUID() != playerCharacter.getGuild().getObjectUUID())
+        if (mine.getOwningGuild().isEmptyGuild() || 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

@@ -47,13 +47,16 @@ public class ChangeAltitudeHandler extends AbstractClientMsgHandler {
         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 +70,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 +135,7 @@ public class ChangeAltitudeHandler extends AbstractClientMsgHandler {
         }
 
         if (msg.up()) {
-            pc.update();
+            pc.update(false);
             pc.setDesiredAltitude(targetAlt);
             pc.setTakeOffTime(System.currentTimeMillis());
         } else {
@@ -158,7 +161,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);
-            return;
+            //remove old boon to apply new one, allows boon refreshing
+            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();
-        //R8 trees always get atleast rank 2 boons. rank uses index, where 0 is first place, 1 is second, etc...
-        if (shrineBuilding.getCity() != null && shrineBuilding.getCity().getTOL() != null && shrineBuilding.getCity().getTOL().getRank() == 8)
-            if (rank != 0)
-                rank = 1;
-        int trains = 40 - (rank * 10);
-        if (trains < 0)
-            trains = 0;
+        int trains = 0;
+        switch(npc.getRank()){
+            case 1:
+                trains = 10;
+                break;
+            case 2:
+                trains = 15;
+                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)
-            return;
-
-        //verify level required to teleport or repledge
+        if (targetCity == null){
+            Mine mineTele = null;
+            for(Mine mine : Mine.getMinesToTeleportTo(player)){
+                if(mine.getObjectUUID() == msg.getCityID()){
+                    mineTele = mine;
+                }
+            }
+            if(mineTele == null){
+                return;
+            }else {
+                int time = MBServerStatics.TELEPORT_TIME_IN_SECONDS;
+                msg.setTeleportTime(time);
+                Building tower = Mine.getTower(mineTele);
+                if (tower == null)
+                    return;
+                Vector3fImmutable teleportLoc = Vector3fImmutable.getRandomPointOnCircle(tower.getLoc(), 10);
+                ChatManager.chatSystemInfo(player, "You Will Teleport To " + mineTele.getParentZone().getParent().getName() + "'s Mine In " + time +  " Seconds.");
+                if (time > 0) {
+                    //TODO add timer to teleport
+                    TeleportJob tj = new TeleportJob(player, npc, teleportLoc, origin, true);
+                    JobScheduler.getInstance().scheduleJob(tj, time * 1000);
+                }
+            }
+        }else{
+            //finish porting to a city
+            //verify level required to teleport or repledge
 
-        Guild toGuild = targetCity.getGuild();
+            Guild toGuild = targetCity.getGuild();
 
-        if (toGuild != null)
-            if (isTeleport) {
-                if (player.getLevel() < toGuild.getTeleportMin() || player.getLevel() > toGuild.getTeleportMax())
+            if (toGuild != null)
+                if (isTeleport) {
+                    if (player.getLevel() < toGuild.getTeleportMin() || player.getLevel() > toGuild.getTeleportMax())
+                        return;
+                } else if (player.getLevel() < toGuild.getRepledgeMin() || player.getLevel() > toGuild.getRepledgeMax())
                     return;
-            } 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)
-            joinedGuild = GuildManager.joinGuild(player, targetCity.getGuild(), targetCity.getObjectUUID(), GuildHistoryType.JOIN);
+            if (!isTeleport)
+                joinedGuild = GuildManager.joinGuild(player, targetCity.getGuild(), targetCity.getObjectUUID(), GuildHistoryType.JOIN);
 
-        int time;
+            int time;
 
-        if (!isTeleport) //repledge
-            time = MBServerStatics.REPLEDGE_TIME_IN_SECONDS;
-        else
-            time = MBServerStatics.TELEPORT_TIME_IN_SECONDS;
+            if (!isTeleport) //repledge
+                time = MBServerStatics.REPLEDGE_TIME_IN_SECONDS;
+            else
+                time = MBServerStatics.TELEPORT_TIME_IN_SECONDS;
 
-        //resend message
-        msg.setTeleportTime(time);
+            //resend message
+            msg.setTeleportTime(time);
 
-        if ((!isTeleport && joinedGuild) || (isTeleport)) {
+            if ((!isTeleport && joinedGuild) || (isTeleport)) {
 
-            dispatch = Dispatch.borrow(player, msg);
-            DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
-        }
+                dispatch = Dispatch.borrow(player, msg);
+                DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
+            }
 
-        //teleport player to city
+            //teleport player to city
 
-        Vector3fImmutable teleportLoc;
+            Vector3fImmutable teleportLoc;
 
-        if (targetCity.getTOL().getRank() == 8)
-            teleportLoc = targetCity.getTOL().getStuckLocation();
-        else
-            teleportLoc = Vector3fImmutable.getRandomPointOnCircle(targetCity.getTOL().getLoc(), MBServerStatics.TREE_TELEPORT_RADIUS);
-
-        if (time > 0) {
-            //TODO add timer to teleport
-            TeleportJob tj = new TeleportJob(player, npc, teleportLoc, origin, true);
-            JobScheduler.getInstance().scheduleJob(tj, time * 1000);
-        } else if (joinedGuild) {
-            player.teleport(teleportLoc);
-            player.setSafeMode();
+            if (targetCity.getTOL().getRank() == 8)
+                teleportLoc = targetCity.getTOL().getStuckLocation();
+            else
+                teleportLoc = Vector3fImmutable.getRandomPointOnCircle(targetCity.getTOL().getLoc(), MBServerStatics.TREE_TELEPORT_RADIUS);
+
+            if (time > 0) {
+                //TODO add timer to teleport
+                TeleportJob tj = new TeleportJob(player, npc, teleportLoc, origin, true);
+                JobScheduler.getInstance().scheduleJob(tj, time * 1000);
+            } else if (joinedGuild) {
+                player.teleport(teleportLoc);
+                player.setSafeMode();
+            }
         }
+
+
     }
 
     private static PowersBase getPowerforHermit(NPC npc) {
@@ -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/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) {
-            int raceID = playerCharacter.getRaceID();
-            boolean valid = false;
-            for (int validID : races.keySet()) {
-                if (validID == raceID) {
-                    valid = true;
-                    break;
+        if(runeID != 3007 && runeID != 3014) {//bounty hunter and huntsman
+            if (races.size() > 0) {
+                boolean valid = false;
+                for (int validID : races.keySet()) {
+                    if (validID == raceID) {
+                        valid = true;
+                        break;
+                    }
                 }
-            }
-            if (!valid) {
-                return false;
-            }
-        }
+                if(runeID == 3040)
+                    valid = true;
 
-        //Check base class is met
-        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) {
+                if(runeID == 3049)
                     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) {
-                return false;
+            //Check base class is met
+            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();
-        if (promotionClasses.size() > 0) {
-            int promotionClassID = playerCharacter.getPromotionClassID();
-            boolean valid = false;
-            for (int validID : promotionClasses.keySet()) {
-                if (validID == promotionClassID) {
+            //Check promotion class is met
+            ConcurrentHashMap<Integer, Boolean> promotionClasses = rb.getPromotionClass();
+            if (promotionClasses.size() > 0) {
+                int promotionClassID = playerCharacter.getPromotionClassID();
+                int baseClassID = playerCharacter.getBaseClassID();
+                boolean valid = false;
+                for (int validID : promotionClasses.keySet()) {
+                    if (validID == promotionClassID) {
+                        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,7 +198,6 @@ public class ApplyRuneMsg extends ClientNetMsg {
                 }
             }
         }
-
         int discCount = 0;
         for (CharacterRune cr : runes) {
             int runeBaseID = cr.getRuneBaseID();
@@ -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,64 @@ 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;
         }
-
-        //if discipline, check number applied
-        if (isDiscipline(runeID)) {
-            if (playerCharacter.getLevel() < 70) {
-                if (discCount > 2) {
-                    return false;
+        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":
+                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 {
-                if (discCount > 3) {
-                    return false;
+                break;
+            case "Scion of the Dar Khelegeur":
+            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
+        if (isDiscipline(runeID)) {
+            switch(playerCharacter.getRank()){
+                case 1:
+                case 2:
+                case 3:
+                case 4:
+                case 5:
+                case 6:
+                    if(discCount > 3)
+                        return false;
+                    break;
+                case 7:
+                case 8:
+                    if(discCount > 5)
+                        return false;
+                    break;
             }
         }
-
         //Everything succeeded. Let's apply the rune
         //Attempt add rune to database
         CharacterRune runeWithoutID = new CharacterRune(rb, playerCharacter.getObjectUUID());
@@ -258,7 +362,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 +370,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 +399,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)
-            Mine.serializeForClientMsg(mine, temp);
+        for (Mine mine : mineList) {
+            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)
-                    Mine.serializeForClientMsg(mine, writer);
+                for (Mine mine : mineList) {
+                    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()))
-                writer.put((byte) 1); //canSetTime
-            else
+            //if (!bane.isAccepted() && this.assetManager.getGuild() == banedCity.getGuild() && GuildStatusController.isInnerCouncil(this.assetManager.getGuildStatus()))
+            //    writer.put((byte) 1); //canSetTime
+            //else
                 writer.put((byte) 0);
 
             DateTime placedOn = bane.getLiveDate();
@@ -485,36 +485,19 @@ public class ManageCityAssetsMsg extends ClientNetMsg {
 
             writer.putInt(building.getRank());
 
-            // Maintenance costs include resource if
-            // this structure is an R8 tree
-
-            if (building.getRank() == 8)
-                writer.putInt(5); // Resources included
-            else
-                writer.putInt(1); // Gold only
+            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
-
-            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
-            }
+                writer.putInt(building.getBlueprint().getMaintCost()); //  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)
-            writer.putInt(0); //Land Rush
-        else if (LoginServer.population < MBServerStatics.NORMAL_POPULATION)
-            writer.putInt(1); //Low pop
-        else if (LoginServer.population < MBServerStatics.HIGH_POPULATION)
-            writer.putInt(2); //Normal pop
-        else if (LoginServer.population < MBServerStatics.VERY_OVERPOPULATED_POPULATION)
-            writer.putInt(3); //High Pop
-        else if (LoginServer.population < MBServerStatics.FULL_POPULATION)
-            writer.putInt(4); //Very overpopulated pop
-        else
-            writer.putInt(5); //Full pop
+        int TotalTrees = 21;
+        int currentR8Trees = DbManager.CityQueries.GET_CAPITAL_CITY_COUNT();
+
+        switch(currentR8Trees){
+            case 0:
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+                writer.putInt(0); //Land Rush
+                break;
+            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)
-            vd = VendorDialog.getHostileVendorDialog();
-        else if (npc.getBuilding() != null) {
-            if (BuildingManager.IsPlayerHostile(npc.getBuilding(), playerCharacter))
+            if (contract == null)
                 vd = VendorDialog.getHostileVendorDialog();
-            else
+            else if (npc.getBuilding() != null) {
+                if (npc.getBuilding() != null && BuildingManager.IsPlayerHostile(npc.getBuilding(), playerCharacter))
+                    vd = VendorDialog.getHostileVendorDialog();
+                else
+                    vd = contract.getVendorDialog();
+            } else
                 vd = contract.getVendorDialog();
-        } else
-            vd = contract.getVendorDialog();
-        if (vd == null)
-            vd = VendorDialog.getHostileVendorDialog();
-
+            if (vd == null)
+                vd = VendorDialog.getHostileVendorDialog();
         if (msg.messageType == 1 || msg.unknown03 == vd.getObjectUUID()) {
             msg.updateMessage(3, vd);
         } else {
             if (VendorDialogMsg.handleSpecialCase(msg, npc, playerCharacter, vd, origin))
                 return;
-
-            vd = VendorDialog.getVendorDialog(msg.unknown03);
+        }
+            //vd = VendorDialog.getVendorDialog(msg.unknown03);
             msg.updateMessage(3, vd);
         }
 
@@ -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())) {
-            // TODO send client promotion error
+        if(race.getRaceRuneID() == 1999) {
+            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 (promoID == 2511 && pc.isMale()) // Fury
-            return;
-        if (promoID == 2512 && pc.isMale()) // Huntress
-            return;
-        if (promoID == 2517 && !pc.isMale()) // Warlock
-            return;
-
+        if(race.getRaceRuneID() != 1999) {
+            // verify gender
+            if (promoID == 2511 && pc.isMale()) // Fury
+                return;
+            if (promoID == 2512 && pc.isMale()) // Huntress
+                return;
+            if (promoID == 2517 && !pc.isMale()) // Warlock
+                return;
+        }
         // Everything valid. Let's promote
         pc.setPromotionClass(promo.getObjectUUID());
 

src/engine/objects/AbstractCharacter.java

@@ -14,10 +14,7 @@ import engine.Enum.*;
 import engine.InterestManagement.InterestManager;
 import engine.InterestManagement.WorldGrid;
 import engine.exception.SerializationException;
-import engine.gameManager.CombatManager;
-import engine.gameManager.ConfigManager;
-import engine.gameManager.MovementManager;
-import engine.gameManager.PowersManager;
+import engine.gameManager.*;
 import engine.job.AbstractJob;
 import engine.job.JobContainer;
 import engine.job.JobScheduler;
@@ -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;
-    protected int maxDamageHandOne;
+    public int minDamageHandOne;
+    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,13 @@ 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 +761,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() {
@@ -1187,10 +1193,15 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
         }
     }
 
-    public final float modifyHealth(
-            final float value,
-            final AbstractCharacter attacker,
-            final boolean fromCost) {
+    public final float modifyHealth(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
 
         try {
 
@@ -1254,11 +1265,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 +1312,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 +1559,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 +1849,7 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
     }
 
     //updates
-    public void update() {
+    public void update(Boolean newSystem) {
     }
 
     public void updateRegen() {
@@ -1834,16 +1869,16 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
             try {
                 switch (updateType) {
                     case ALL:
-                        update();
+                        update(false);
                         break;
                     case REGEN:
                         updateRegen();
                         break;
                     case LOCATION:
-                        update();
+                        update(false);
                         break;
                     case MOVEMENTSTATE:
-                        update();
+                        update(false);
                         break;
                     case FLIGHT:
                         updateFlight();

src/engine/objects/AbstractWorldObject.java

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

src/engine/objects/Arena.java

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

src/engine/objects/Bane.java

@@ -14,19 +14,19 @@ import engine.Enum.ProtectionState;
 import engine.Enum.SiegePhase;
 import engine.Enum.SiegeResult;
 import engine.InterestManagement.HeightMap;
+import engine.InterestManagement.InterestManager;
 import engine.InterestManagement.WorldGrid;
 import engine.db.archive.BaneRecord;
 import engine.db.archive.DataWarehouse;
-import engine.gameManager.BuildingManager;
-import engine.gameManager.ChatManager;
-import engine.gameManager.DbManager;
-import engine.gameManager.ZoneManager;
+import engine.gameManager.*;
 import engine.job.JobScheduler;
 import engine.jobs.ActivateBaneJob;
 import engine.jobs.BaneDefaultTimeJob;
 import engine.math.Vector3fImmutable;
+import engine.net.Dispatch;
 import engine.net.DispatchMessage;
 import engine.net.client.ClientConnection;
+import engine.net.client.msg.CityDataMsg;
 import engine.net.client.msg.PlaceAssetMsg;
 import engine.net.client.msg.chat.ChatSystemMsg;
 import engine.server.MBServerStatics;
@@ -37,6 +37,7 @@ import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.Date;
+import java.util.HashSet;
 import java.util.concurrent.ConcurrentHashMap;
 
 public final class Bane {
@@ -48,6 +49,10 @@ public final class Bane {
     private DateTime placementDate = null;
     private DateTime liveDate = null;
     private BaneDefaultTimeJob defaultTimeJob;
+    public boolean timeSet = false;
+    public boolean daySet = false;
+    public boolean capSet = false;
+    public int capSize = 10;
 
     // Internal cache for banes
     private ActivateBaneJob activateBaneJob;
@@ -64,6 +69,12 @@ public final class Bane {
         this.ownerUUID = rs.getInt("ownerUUID");
         this.stoneUUID = rs.getInt("stoneUUID");
 
+        this.timeSet = rs.getInt("time_set") == 1;
+        this.daySet = rs.getInt("day_set") == 1;
+        this.capSet = rs.getInt("cap_set") == 1;
+        this.capSize = rs.getInt("cap_size");
+
+
         sqlDateTime = rs.getTimestamp("placementDate");
 
         if (sqlDateTime != null)
@@ -100,12 +111,11 @@ public final class Bane {
                 abtj = new ActivateBaneJob(cityUUID);
                 JobScheduler.getInstance().scheduleJob(abtj, this.liveDate.getMillis());
                 this.activateBaneJob = abtj;
-
                 break;
         }
 
-        if (this.liveDate == null)
-            setDefaultTime();
+        //add bane commander NPC
+        //summonBaneCommander(this);
     }
 
     public static boolean summonBanestone(PlayerCharacter player, ClientConnection origin, int rank) {
@@ -266,9 +276,58 @@ public final class Bane {
         BaneRecord baneRecord = BaneRecord.borrow(bane, Enum.RecordEventType.PENDING);
         DataWarehouse.pushToWarehouse(baneRecord);
 
+        //add bane commander NPC
+        summonBaneCommander(bane);
+
+        try {
+            //update map for all players online
+            for (PlayerCharacter playerCharacter : SessionManager.getAllActivePlayerCharacters()) {
+                CityDataMsg cityDataMsg = new CityDataMsg(SessionManager.getSession(playerCharacter), false);
+                cityDataMsg.updateMines(true);
+                cityDataMsg.updateCities(true);
+                Dispatch dispatch = Dispatch.borrow(playerCharacter, cityDataMsg);
+                DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
+            }
+        }catch(Exception e){
+
+        }
+
         return true;
     }
 
+    public static void summonBaneCommander(Bane bane){
+        Vector3fImmutable spawnLoc = Vector3fImmutable.getRandomPointOnCircle(bane.getStone().loc,6);
+        NPC baneCommander;
+        int commanderuuid = DbManager.NPCQueries.BANE_COMMANDER_EXISTS(bane.getStone().getObjectUUID());
+
+        if(commanderuuid == 0) {
+            //add bane commander NPC
+            int contractID = 1502042;
+            baneCommander = NPC.createNPC("Bane Commander", contractID, spawnLoc, bane.getCity().getGuild(), ZoneManager.findSmallestZone(bane.getStone().loc), (short) 70, bane.getStone());
+            try {
+                NPCManager.slotCharacterInBuilding(baneCommander);
+            }catch(Exception e){
+
+            }
+            WorldGrid.addObject(baneCommander,spawnLoc.x,spawnLoc.z);
+            WorldGrid.updateObject(baneCommander);
+        }
+        else
+        {
+            baneCommander = NPC.getNPC(commanderuuid);
+        }
+        //try {
+        //    NPCManager.slotCharacterInBuilding(baneCommander);
+        //}catch (Exception e){
+            //swallow it
+        //}
+        baneCommander.runAfterLoad();
+        //baneCommander.setLoc(spawnLoc);
+        InterestManager.setObjectDirty(baneCommander);
+
+        baneCommander.updateLocation();
+    }
+
     public static Bane getBane(int cityUUID) {
 
         Bane outBane;
@@ -381,8 +440,12 @@ public final class Bane {
         defaultTime = defaultTime.minuteOfHour().setCopy(0);
         defaultTime = defaultTime.secondOfMinute().setCopy(0);
 
-        if (currentTime.isAfter(timeToSetDefault))
-            this.setLiveDate(defaultTime);
+        if (currentTime.isAfter(timeToSetDefault)){
+            DbManager.BaneQueries.SET_BANE_CAP_NEW(20,this.getCityUUID());
+            DbManager.BaneQueries.SET_BANE_TIME_NEW(9,this.getCityUUID());
+            DbManager.BaneQueries.SET_BANE_DAY_NEW(3,this.getCityUUID());
+        }
+            //this.setLiveDate(defaultTime);
         else {
 
             if (this.defaultTimeJob != null)
@@ -448,6 +511,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 +542,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 +720,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;
-
-        maintCost = (9730 * rank) + 1890;
-
-        return maintCost;
+        return 0;
     }
 
     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,24 @@ public class Blueprint {
             return 0;
 
         // Early exit for buildings with single or no slots
-
-        if (this.maxSlots <= 1)
+        if (this.maxSlots <= 1 && !this.buildingGroup.equals(BuildingGroup.TOL))
             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 (this.maxRank == 1 && currentRank == 1)
             return getMaxSlots();
 
@@ -327,20 +371,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 +649,14 @@ public class Blueprint {
         return this.blueprintUUID;
     }
 
-    public int getMaintCost(int rank) {
+    public int getMaintCost() {
 
         int maintCost = Integer.MAX_VALUE;
 
-        switch (this.buildingGroup) {
-            case TOL:
-            case BARRACK:
-                maintCost = (61500 * rank) + 19500;
-                break;
-            case SPIRE:
-                maintCost = (4800 * rank) + 1200;
-                break;
-            default:
-                if (maxRank == 1)
-                    maintCost = 22500;
-                else
-                    maintCost = (15900 * rank) + 3300;
-                break;
+        if(this.buildingGroup.equals(BuildingGroup.TOL)){
+            return 3000000;
+        }else{
+            return 0;
         }
-
-        return maintCost;
     }
 }

src/engine/objects/Building.java

@@ -182,6 +182,22 @@ public class Building extends AbstractWorldObject {
                 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)
@@ -780,24 +796,9 @@ public class Building extends AbstractWorldObject {
 
     public int getMaintCost() {
 
-        int maintCost = 0;
-
-        // Add cost for building structure
-
-        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;
+        if(this.getBlueprint() != null && this.getBlueprint().getBuildingGroup().equals(BuildingGroup.TOL))
+            return 3000000;
+        else return 0;
     }
 
     public final void submitOpenDoorJob(int doorID) {
@@ -836,6 +837,10 @@ public class Building extends AbstractWorldObject {
         return this.meshScale;
     }
 
+    public void setMeshScale(Vector3f scale) {
+        this.meshScale = scale;
+    }
+
     public final int getMeshUUID() {
         return this.meshUUID;
     }

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

@@ -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);
-        for (Integer removalUUID : toRemove) {
+        _playerMemory.removeAll(toRemoveStandard);
+        for (Integer removalUUID : toRemoveStandard) {
             if (this.cityOutlaws.contains(removalUUID))
                 this.cityOutlaws.remove(removalUUID);
         }
+        if(this.getBane() != null){
+            //handle zerg mechanics here
+            if(this.getBane().getSiegePhase().equals(SiegePhase.WAR)){
+                this.onExitBane();
+            }
+        }
     }
 
     public int getWarehouseBuildingID() {

src/engine/objects/Contract.java

@@ -11,7 +11,12 @@ package engine.objects;
 
 import ch.claude_martin.enumbitset.EnumBitSet;
 import engine.Enum;
-import engine.gameManager.DbManager;
+import engine.gameManager.*;
+import engine.net.Dispatch;
+import engine.net.DispatchMessage;
+import engine.net.client.msg.CityDataMsg;
+import engine.net.client.msg.ErrorPopupMsg;
+import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
 
 import java.sql.ResultSet;
@@ -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)
-            level = 75;
+        if (level > MBServerStatics.LEVELCAP)
+            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,9 @@ public class Experience {
         if (killer == null || mob == null)
             return;
 
+        if(killer.equals(mob))
+            return;
+
         double grantedExperience = 0.0;
 
         if (g != null) { // Do group EXP stuff
@@ -383,10 +399,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 +448,15 @@ public class Experience {
             }
 
         } else { // Give EXP to a single character
-            if (!killer.isAlive()) // Skip if the player is dead.
-                return;
+            //if (!killer.isAlive()) // Skip if the player is dead.
+             //   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()) {
-            canSub = false;
-        }
+        //if (nation.getSubGuildList().size() >= nationCap.getRank()) {
+        //    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));
             }
     }
 

src/engine/objects/ItemBase.java

@@ -75,7 +75,6 @@ public class ItemBase {
     private boolean isStrBased;
     private ArrayList<Integer> animations = new ArrayList<>();
     private ArrayList<Integer> offHandAnimations = new ArrayList<>();
-    private boolean autoID = false;
 
     /**
      * ResultSet Constructor
@@ -145,8 +144,6 @@ public class ItemBase {
 
         }
 
-        this.autoIDItemsCheck();
-
         try {
             DbManager.ItemBaseQueries.LOAD_ANIMATIONS(this);
         } catch (Exception e) {
@@ -232,7 +229,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;
     }
 
     /*
@@ -372,74 +441,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 +911,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 total = (int) (baseCost + baseCost * .10);
+            //int baseCost = ib.getBaseValue();
+            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.ChatManager;
-import engine.gameManager.DbManager;
-import engine.gameManager.ZoneManager;
+import engine.gameManager.*;
+import engine.math.Vector3f;
+import engine.math.Vector3fImmutable;
 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);
-        this.zoneName = this.parentZone.getParent().getName();
+        if(ZoneManager.getZoneByUUID(parent) != null) {
+            this.parentZone = ZoneManager.getZoneByUUID(parent);
+            this.zoneName = this.parentZone.getParent().getName();
+        }else{
+            this.parentZone = ZoneManager.getSeaFloor();
+            if(this.parentZone.getParent() != null)
+                this.zoneName = this.parentZone.getParent().getName();
+            else
+                this.zoneName = "FAILED TO LOAD ZONE";
+            Logger.error("MINE FAILED TO LOAD PARENT: ");
+            Logger.error("MINE UID: " + rs.getInt("UID"));
+            Logger.error("MINE buildingID: " + buildingID);
+
+        }
 
         this.owningGuild = Guild.getGuild(ownerUID);
         Guild nation = null;
@@ -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);
-                Mine.towerMap.put(mine.buildingID, mine);
+                if(mine.capSize != 0) {
+                    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());
-        writer.putInt(mine.getObjectUUID());
-        writer.putInt(mine.getObjectUUID()); //actually a hash of mine
-        writer.putString(mine.mineType.name);
-        writer.putString(mine.zoneName);
-        writer.putInt(mine.production.hash);
-        writer.putInt(mine.production.baseProduction);
-        writer.putInt(mine.getModifiedProductionAmount()); //TODO calculate range penalty here
-        writer.putInt(3600); //window in seconds
-
-        // Errant mines are currently open.  Set time to now.
-
-        LocalDateTime mineOpenTime = LocalDateTime.now().withMinute(0).withSecond(0).withNano(0);
-
-        // Mine times are those of the nation not individual guild.
-
-        Guild mineNatonGuild = mine.getOwningGuild().getNation();
-
-        // Adjust the serialized mine time based upon whether
-        // the Guild's mine window has passed or not and if it was claimed.
-        // If a mine is active serialize current datetime irrespective
-        // of any claim.
-
-        if (mineNatonGuild.isEmptyGuild() == false && mine.isActive == false) {
-
-            int guildWOO = mineNatonGuild.getNation().getMineTime();
-            LocalDateTime guildMineTime = mineOpenTime.withHour(guildWOO);
-
-            if (mineOpenTime.isAfter(guildMineTime) || mine.wasClaimed == true)
-                mineOpenTime = guildMineTime.plusDays(1);
-            else
-                mineOpenTime = guildMineTime;
+        try {
+            writer.putInt(mine.getObjectType().ordinal());
+            writer.putInt(mine.getObjectUUID());
+            writer.putInt(mine.getObjectUUID()); //actually a hash of mine
+            if(mine.isStronghold){
+                writer.putString("STRONGHOLD");
+                writer.putString("");
+            }else {
+                writer.putString(mine.mineType.name);
+                writer.putString(mine.capSize + " Man ");
+            }
+            //writer.putString(mine.zoneName + " " + mine.capSize + " Man ");
+
+            writer.putInt(mine.production.hash);
+            writer.putInt(mine.production.baseProduction);
+            writer.putInt(mine.getModifiedProductionAmount()); //TODO calculate range penalty here
+            writer.putInt(3600); //window in seconds
+
+            LocalDateTime mineOpenTime = LocalDateTime.now().withHour(mine.openHour).withMinute(mine.openMinute).withSecond(0).withNano(0);
+
+            writer.putLocalDateTime(mineOpenTime);
+            writer.putLocalDateTime(mineOpenTime.plusMinutes(30));
+            writer.put(mine.isActive ? (byte) 0x01 : (byte) 0x00);
+
+            Building mineTower = BuildingManager.getBuilding(mine.buildingID);
+            if (mineTower != null) {
+                writer.putFloat(mineTower.getLoc().x);
+                writer.putFloat(mineTower.getParentZone().getLoc().y);
+                writer.putFloat(mineTower.getLoc().z);
+            } else {
+                writer.putFloat(mine.parentZone.getLoc().x);
+                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 &&
-                    mine.isActive == false)
+            if (mine.owningGuild.getObjectUUID() == guildID)
                 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) {
-
-        int mineCnt = 0;
+    public static ArrayList<Mine> getMinesToTeleportTo(PlayerCharacter player) {
+        ArrayList<Mine> mines = new ArrayList<>();
+        for(Mine mine : Mine.getMines())
+            if(!mine.isActive)
+                if(mine.getOwningGuild() != null)
+                  if(mine.getOwningGuild().getNation().equals(player.getGuild().getNation()))
+                         mines.add(mine);
 
-        mineCnt += Mine.getMinesForGuild(playerGuild.getObjectUUID()).size();
-
-        for (Guild guild : playerGuild.getSubGuildList())
-            mineCnt += Mine.getMinesForGuild(guild.getObjectUUID()).size();
-
-        return mineCnt <= tolRank;
+        return mines;
     }
 
     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.
-
-        //calculate base values.
-        int baseProduction = this.production.baseProduction;
-        float baseModValue = this.production.baseProduction * .1f;
-        float rankModValue = this.production.baseProduction * .0143f;
-        float totalModded = 0;
-
-        //get Mine Building.
-        Building mineBuilding = BuildingManager.getBuilding(this.buildingID);
-        if (mineBuilding == null)
-            return this.production.baseProduction;
-        for (AbstractCharacter harvester : mineBuilding.getHirelings().keySet()) {
-            totalModded += baseModValue;
-            totalModded += rankModValue * harvester.getRank();
+        ItemBase resourceBase = ItemBase.getItemBase(this.production.UUID);
+        if(resourceBase == null)
+            return 0;
+        int value = resourceBase.getBaseValue();
+
+        int amount = 0;
+        switch(this.capSize){
+            case 3:
+                amount = 1800000;
+                break;
+            case 5:
+                amount = 3000000;
+                break;
+            case 10:
+                amount = 6000000;
+                break;
+            case 20:
+                amount = 12000000;
+                break;
         }
-        //add base production on top;
-        totalModded += baseProduction;
-        //skip distance check for expansion.
-        if (this.isExpansion())
-            return (int) totalModded;
-
-        if (this.owningGuild.isEmptyGuild() == false) {
-            if (this.owningGuild.getOwnedCity() != null) {
-                float distanceSquared = this.owningGuild.getOwnedCity().getLoc().distanceSquared2D(mineBuilding.getLoc());
-
-                if (distanceSquared > sqr(10000 * 3))
-                    totalModded *= .25f;
-                else if (distanceSquared > sqr(10000 * 2))
-                    totalModded *= .50f;
-                else if (distanceSquared > sqr(10000))
-                    totalModded *= .75f;
+        if(this.production.UUID == 7)
+            value = 1;
+
+        amount = amount / value;
+
+        return amount;
+    }
+    public void onEnter() {
+
+        Building tower = BuildingManager.getBuildingFromCache(this.buildingID);
+        if(tower == null)
+            return;
+
+        // Gather current list of players within the zone bounds
+
+        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),
-    ORE("Ore Mine", new HashMap<>(), Resource.OBSIDIAN, 518103023, -788976428),
-    GOLD("Gold Mine", new HashMap<>(), Resource.GALVOR, -662193002, -1227205358),
-    MAGIC("Magic Mine", new HashMap<>(), Resource.BLOODSTONE, 504746863, -1753567069);
+    LUMBER("Lumber Camp", new HashMap<>(), 1618637196, 1663491950),
+    ORE("Ore Mine", new HashMap<>(), 518103023, -788976428),
+    MAGIC("Magic Mine", new HashMap<>(), 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) {
-            MineProduction.GOLD.resources.put(7, Resource.GOLD);
-            MineProduction.GOLD.resources.put(1580000, Resource.STONE);
-            MineProduction.GOLD.resources.put(1580008, Resource.COAL);
-            MineProduction.GOLD.resources.put(1580009, Resource.AGATE);
-            MineProduction.GOLD.resources.put(1580010, Resource.DIAMOND);
-            MineProduction.GOLD.resources.put(1580011, Resource.ONYX);
+        if (MineProduction.GOLDMINE.resources.size() == 0) {
+            MineProduction.GOLDMINE.resources.put(7, Resource.GOLD);
+            MineProduction.GOLDMINE.resources.put(1580000, Resource.STONE);
+            MineProduction.GOLDMINE.resources.put(1580008, Resource.COAL);
+            MineProduction.GOLDMINE.resources.put(1580009, Resource.AGATE);
+            MineProduction.GOLDMINE.resources.put(1580010, Resource.DIAMOND);
+            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"))
-            return MineProduction.GOLD;
+        else if (name.equalsIgnoreCase("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 true;
-        else
-            return isXpac && r.UUID == this.xpac.UUID;
+        return this.resources.containsKey(r.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.*;
@@ -23,6 +24,7 @@ import engine.math.Quaternion;
 import engine.math.Vector3f;
 import engine.math.Vector3fImmutable;
 import engine.mobileAI.Threads.MobAIThread;
+import engine.mobileAI.utilities.MovementUtilities;
 import engine.net.ByteBufferWriter;
 import engine.net.Dispatch;
 import engine.net.DispatchMessage;
@@ -48,6 +50,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
@@ -81,6 +84,7 @@ public class Mob extends AbstractIntelligenceAgent {
     public int lastPatrolPointIndex = 0;
     public long stopPatrolTime = 0;
     public City guardedCity;
+    public long nextChaseUpdate = 0;
     protected int dbID; //the database ID
     protected int loadID;
     protected float spawnRadius;
@@ -100,6 +104,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 +276,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 +300,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 +578,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 +618,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 +1259,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 +1315,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 +1329,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 +1408,8 @@ public class Mob extends AbstractIntelligenceAgent {
             Logger.error(e);
         }
         this.updateLocation();
+        //resync corpses
+        InterestManager.setObjectDirty(this);
     }
 
     public void respawn() {
@@ -1396,14 +1444,29 @@ public class Mob extends AbstractIntelligenceAgent {
             loadInventory();
 
         this.updateLocation();
+        reloadAgroMap(this);
+    }
+
+    private static void reloadAgroMap(Mob mob){
+        mob.playerAgroMap.clear();
+        for(AbstractWorldObject obj : WorldGrid.getObjectsInRangePartial(mob.loc,MBServerStatics.CHARACTER_LOAD_RANGE,1)){
+            if(!mob.playerAgroMap.containsKey(obj.getObjectUUID())){
+                mob.playerAgroMap.put(obj.getObjectUUID(),false);
+            }
+        }
     }
 
     public void despawn() {
 
         this.despawned = true;
 
+        this.stopPatrolTime = System.currentTimeMillis();
         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 +1528,31 @@ public class Mob extends AbstractIntelligenceAgent {
         } catch (Exception e) {
             Logger.error(e.getMessage());
         }
-
-        Resists.calculateResists(this);
+        if(this.StrongholdCommander || this.StrongholdGuardian || this.StrongholdEpic){
+            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,6 +1610,46 @@ public class Mob extends AbstractIntelligenceAgent {
 
     public void calculateAtrDefenseDamage() {
 
+        if(this.StrongholdCommander){
+            this.maxDamageHandOne = 3500;
+            this.minDamageHandOne = 1500;
+            int atr = 3500;
+            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) {
+
+                defense = GetDefense(defense, this);
+                atr = GetAttackRating(atr, this);
+            }
+            this.defenseRating = defense;
+            this.atrHandOne = atr;
+            return;
+        }
         if (this.charItemManager == null || this.equip == null) {
             Logger.error("Player " + currentID + " missing skills or equipment");
             defaultAtrAndDamage(true);
@@ -1539,7 +1662,7 @@ public class Mob extends AbstractIntelligenceAgent {
             calculateAtrDamageForWeapon(this.equip.get(MBServerStatics.SLOT_MAINHAND), true);
         } catch (Exception e) {
 
-            this.atrHandOne = (short) this.mobBase.getAttackRating();
+            this.atrHandOne = GetAttackRating(this.mobBase.getAttackRating(), this);
             this.minDamageHandOne = (short) this.mobBase.getMinDmg();
             this.maxDamageHandOne = (short) this.mobBase.getMaxDmg();
             this.rangeHandOne = 6.5f;
@@ -1552,7 +1675,7 @@ public class Mob extends AbstractIntelligenceAgent {
 
         } catch (Exception e) {
 
-            this.atrHandTwo = (short) this.mobBase.getAttackRating();
+            this.atrHandTwo = GetAttackRating(this.mobBase.getAttackRating(), this);
             this.minDamageHandTwo = (short) this.mobBase.getMinDmg();
             this.maxDamageHandTwo = (short) this.mobBase.getMaxDmg();
             this.rangeHandTwo = 6.5f;
@@ -1573,23 +1696,7 @@ public class Mob extends AbstractIntelligenceAgent {
 
             // TODO add error log here
             if (this.bonuses != null) {
-
-                // add any bonuses
-
-                defense += (short) this.bonuses.getFloat(ModType.DCV, SourceType.None);
-
-                // Finally, multiply any percent modifiers. DO THIS LAST!
-
-                float pos_Bonus = 1 + this.bonuses.getFloatPercentPositive(ModType.DCV, SourceType.None);
-
-
-                defense = (short) (defense * pos_Bonus);
-
-                //Lucky rune applies next
-
-                float neg_Bonus = this.bonuses.getFloatPercentNegative(ModType.DCV, SourceType.None);
-                defense = (short) (defense * (1 + neg_Bonus));
-
+                defense = GetDefense((int)defense, this);
 
             } else
                 Logger.error("Error: missing bonuses");
@@ -1601,8 +1708,53 @@ public class Mob extends AbstractIntelligenceAgent {
             this.defenseRating = (short) this.mobBase.getDefense();
         }
         // calculate defense for equipment
+
+        if(this.isDropper || Mob.discDroppers.contains(this)){
+            this.defenseRating *= 2;
+            this.atrHandOne *= 2;
+            this.atrHandTwo *= 2;
+            this.minDamageHandOne *= 2;
+            this.minDamageHandTwo *= 2;
+            this.maxDamageHandOne *= 2;
+            this.maxDamageHandTwo *= 2;
+        }
     }
 
+    public static int GetDefense(int defense, Mob mob){
+        // add any bonuses
+
+        defense += (short) mob.bonuses.getFloat(ModType.DCV, SourceType.None);
+
+        // Finally, multiply any percent modifiers. DO THIS LAST!
+
+        float pos_Bonus = 1 + mob.bonuses.getFloatPercentPositive(ModType.DCV, SourceType.None);
+
+
+        defense = (short) (defense * pos_Bonus);
+
+        //Lucky rune applies next
+
+        float neg_Bonus = mob.bonuses.getFloatPercentNegative(ModType.DCV, SourceType.None);
+        return (int) (defense * (1 + neg_Bonus));
+    }
+
+    public static int GetAttackRating(int attackRating, Mob mob){
+        // add any bonuses
+
+        attackRating += (short) mob.bonuses.getFloat(ModType.OCV, SourceType.None);
+
+        // Finally, multiply any percent modifiers. DO THIS LAST!
+
+        float pos_Bonus = 1 + mob.bonuses.getFloatPercentPositive(ModType.OCV, SourceType.None);
+
+
+        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);
@@ -1929,6 +2081,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);
@@ -2001,8 +2160,9 @@ public class Mob extends AbstractIntelligenceAgent {
                     Vector3fImmutable newPatrolPoint = Vector3fImmutable.getRandomPointInCircle(this.getBindLoc(), patrolRadius);
                     this.patrolPoints.add(newPatrolPoint);
 
-                    if (i == 1)
-                        MovementManager.translocate(this, newPatrolPoint, null);
+                    if (i == 1) {
+                        MovementUtilities.aiMove(this,newPatrolPoint,true);
+                    }
                 }
             }
 
@@ -2020,6 +2180,7 @@ public class Mob extends AbstractIntelligenceAgent {
                 }
 
             this.deathTime = 0;
+            InterestManager.setObjectDirty(this);
         } catch (Exception e) {
             Logger.error(e.getMessage());
         }
@@ -2263,5 +2424,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/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() {
-        return repairCost;
+    public int getSpecialPrice() {
+        return specialPrice;
     }
 
-    public void setRepairCost(int repairCost) {
-        this.repairCost = repairCost;
+    public void setSpecialPrice(int specialPrice) {
+        this.specialPrice = specialPrice;
+        DbManager.NPCQueries.updateSpecialPricing(this);
     }
 
     public void processUpgradeNPC(PlayerCharacter player) {
@@ -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/PlayerCharacter.java

@@ -175,6 +175,10 @@ public class PlayerCharacter extends AbstractCharacter {
     private boolean dirtyLoad = true;
     private final ReadWriteLock dirtyLock = new ReentrantReadWriteLock(true);
 
+    public float ZergMultiplier = 1.0f;
+
+    public boolean isBoxed = false;
+
     /**
      * No Id Constructor
      */
@@ -780,6 +784,9 @@ public class PlayerCharacter extends AbstractCharacter {
         // Verify Race
         int raceID = msg.getRace();
 
+        if(raceID == 0)
+            raceID = 1999;
+
         Race race = Race.getRace(raceID);
 
         if (race == null) {
@@ -812,33 +819,34 @@ public class PlayerCharacter extends AbstractCharacter {
             return null;
         }
 
-        // Verify HairStyle/BeardStyle/SkinColor/HairColor/BeardColor
-        int hairStyleID = msg.getHairStyle();
-        int beardStyleID = msg.getBeardStyle();
-        int skinColorID = msg.getSkinColor();
-        int hairColorID = msg.getHairColor();
-        int beardColorID = msg.getBeardColor();
+            // Verify HairStyle/BeardStyle/SkinColor/HairColor/BeardColor
+            int hairStyleID = msg.getHairStyle();
+            int beardStyleID = msg.getBeardStyle();
+            int skinColorID = msg.getSkinColor();
+            int hairColorID = msg.getHairColor();
+            int beardColorID = msg.getBeardColor();
 
-        if (!race.isValidHairStyle(hairStyleID)) {
-            Logger.info("Invalid HairStyleID: " + hairStyleID + " for race: " + race.getName());
-            return null;
-        }
+        if(raceID != 1999) {
+            if (!race.isValidHairStyle(hairStyleID)) {
+                Logger.info("Invalid HairStyleID: " + hairStyleID + " for race: " + race.getName());
+                return null;
+            }
 
-        if (!race.isValidSkinColor(skinColorID)) {
-            Logger.info("Invalid skinColorID: " + skinColorID + " for race: " + race.getName());
-            return null;
-        }
+            if (!race.isValidSkinColor(skinColorID)) {
+                Logger.info("Invalid skinColorID: " + skinColorID + " for race: " + race.getName());
+                return null;
+            }
 
-        if (!race.isValidHairColor(hairColorID)) {
-            Logger.info("Invalid hairColorID: " + hairColorID + " for race: " + race.getName());
-            return null;
-        }
+            if (!race.isValidHairColor(hairColorID)) {
+                Logger.info("Invalid hairColorID: " + hairColorID + " for race: " + race.getName());
+                return null;
+            }
 
-        if (!race.isValidBeardColor(beardColorID)) {
-            Logger.info("Invalid beardColorID: " + beardColorID + " for race: " + race.getName());
-            return null;
+            if (!race.isValidBeardColor(beardColorID)) {
+                Logger.info("Invalid beardColorID: " + beardColorID + " for race: " + race.getName());
+                return null;
+            }
         }
-
         // Get stat modifiers
         int strMod = msg.getStrengthMod();
         int dexMod = msg.getDexterityMod();
@@ -926,11 +934,12 @@ public class PlayerCharacter extends AbstractCharacter {
             }
 
             // Validate Rune against Race
-            if (!race.isAllowedRune(runeBase)) {
-                Logger.info("Trait Not valid for Race");
-                return null;
+            if(raceID != 1999) {
+                if (!race.isAllowedRune(runeBase)) {
+                    Logger.info("Trait Not valid for Race");
+                    return null;
+                }
             }
-
             // Validate BaseClass against Race
             if (!baseClass.isAllowedRune(runeBase)) {
                 Logger.info("Trait Not valid for BaseClass");
@@ -1119,9 +1128,15 @@ public class PlayerCharacter extends AbstractCharacter {
         int kitID = msg.getKit();
 
         // get the correctKit
-        int raceClassID = Kit.GetKitIDByRaceClass(raceID, baseClassID);
+        int raceClassID;
+        if(raceID != 1999){
+            raceClassID = Kit.GetKitIDByRaceClass(raceID, baseClassID);
+        }else{
+            raceClassID = Kit.GetKitIDByRaceClass(2011, baseClassID);
+        }
         ArrayList<Kit> allKits = Kit.RaceClassIDMap.get(raceClassID);
 
+
         Kit kit = null;
 
         for (Kit k : allKits) {
@@ -1151,6 +1166,13 @@ public class PlayerCharacter extends AbstractCharacter {
                         clientConnection);
                 return null;
             }
+            if(raceID == 1999){
+                hairStyleID = 0;
+                beardStyleID = 0;
+                skinColorID = 0;
+                hairColorID = 0;
+                beardColorID = 0;
+            }
 
             // Make PC
             PlayerCharacter pcWithoutID = new PlayerCharacter(firstName, lastName, (short) strMod, (short) dexMod, (short) conMod,
@@ -1278,7 +1300,7 @@ public class PlayerCharacter extends AbstractCharacter {
 
 
         if (ConfigManager.serverType.equals(ServerType.WORLDSERVER))
-            player.setLoc(player.bindLoc);
+            player.setLoc(player.getBindLoc());
         player.endLoc = Vector3fImmutable.ZERO;
 
         //get level based on experience
@@ -1825,20 +1847,20 @@ public class PlayerCharacter extends AbstractCharacter {
         //see if we shold grant xp to attacker
         boolean doPVPEXP = false;
         long lastKill = att.getLastKillOfTarget(this.getObjectUUID());
-        if ((System.currentTimeMillis() - lastKill) > MBServerStatics.PLAYER_KILL_XP_TIMER)
-            if (attacker.getLevel() > 39 && this.getLevel() > 39) {
-                Guild aN = null;
-                Guild tN = null;
-                if (attacker.getGuild() != null)
-                    aN = attacker.getGuild().getNation();
-                if (this.getGuild() != null)
-                    tN = this.getGuild().getNation();
-                if (aN == null || tN == null || aN.isEmptyGuild() || Guild.sameGuild(aN, tN) || this.isDeathShroud()) {
+        //if ((System.currentTimeMillis() - lastKill) > MBServerStatics.PLAYER_KILL_XP_TIMER)
+            //if (attacker.getLevel() > 39 && this.getLevel() > 39) {
+                //Guild aN = null;
+                //Guild tN = null;
+                //if (attacker.getGuild() != null)
+                //    aN = attacker.getGuild().getNation();
+                //if (this.getGuild() != null)
+                //    tN = this.getGuild().getNation();
+                //if (aN == null || tN == null || aN.isEmptyGuild() || Guild.sameGuild(aN, tN) || this.isDeathShroud()) {
                     //skip giving xp if same guild or attacker is errant, or target is in death shroud.
-                } else {
+                //} else {
                     doPVPEXP = true;
-                }
-            }
+                //}
+           // }
         //apply death shroud to non safeholds.
         Zone zone = ZoneManager.findSmallestZone(this.getLoc());
 
@@ -2025,7 +2047,8 @@ public class PlayerCharacter extends AbstractCharacter {
     public void respawn(boolean setAlive, boolean enterWorld, boolean makeCorpse) {
 
         // Recalculate everything
-
+        if(this.timestamps.containsKey("DeathTime"))
+            this.timestamps.remove("DeathTime");
 
         this.recalculatePlayerStats(true);
         this.setCombat(false);
@@ -2078,7 +2101,7 @@ public class PlayerCharacter extends AbstractCharacter {
         this.lastUpdateTime = System.currentTimeMillis();
         this.lastStamUpdateTime = System.currentTimeMillis();
 
-        this.update();
+        this.update(false);
 
         PowersManager.applyPower(this, this, Vector3fImmutable.ZERO, -1661758934, 40, false);
 
@@ -2183,6 +2206,10 @@ public class PlayerCharacter extends AbstractCharacter {
         if (bindLocation == null)
             bindLocation = Enum.Ruins.getRandomRuin().getLocation();
 
+        if(this.guild.getNation().equals(Guild.getErrantGuild())){
+            bindLocation = Vector3fImmutable.getRandomPointOnCircle(BuildingManager.getBuilding(27977).loc,20f);
+        }
+
         return bindLocation;
 
     }
@@ -2868,7 +2895,7 @@ public class PlayerCharacter extends AbstractCharacter {
 
         float speed;
 
-        if (this.getAltitude() > 0)
+        if (this.isFlying())
             if (this.walkMode) {
                 speed = race.getRaceType().getRunSpeed().getFlyWalk();
             } else {
@@ -2888,7 +2915,8 @@ public class PlayerCharacter extends AbstractCharacter {
                 speed = race.getRaceType().getRunSpeed().getRunStandard();
         }
 
-        float endSpeed = speed * this.speedMod;
+        float mod = this.speedMod;
+        float endSpeed = speed * mod;
 
         if (endSpeed > 41 && !this.isCSR)
             endSpeed = 41;
@@ -2897,6 +2925,21 @@ public class PlayerCharacter extends AbstractCharacter {
     }
 
     public synchronized void grantXP(int xp) {
+        if(this.promotionClass == null && this.level == 10){
+            this.setOverFlowEXP(0);
+            this.update(false);
+            this.incVer();
+            this.recalculate();
+            this.calculateMaxHealthManaStamina();
+            this.setHealth(this.healthMax);
+            this.mana.set(this.manaMax);
+            this.stamina.set(this.staminaMax);
+            //LoadJob.reloadCharacter(this);
+            DbManager.PlayerCharacterQueries.SET_PROPERTY(this, "char_experience", this.exp);
+            //			updateDatabase();
+            DbManager.AccountQueries.INVALIDATE_LOGIN_CACHE(this.getObjectUUID(), "character");
+            return;
+        }
         // Stop players from getting experience past the cap
         if (this.exp + xp >= Experience.getBaseExperience(MBServerStatics.LEVELCAP))
             xp = Experience.getBaseExperience(MBServerStatics.LEVELCAP) - this.exp + 1;
@@ -3045,7 +3088,7 @@ public class PlayerCharacter extends AbstractCharacter {
         }
 
         if (charReloadRequired) {
-            this.update();
+            this.update(false);
             this.incVer();
             this.recalculate();
             this.calculateMaxHealthManaStamina();
@@ -3118,7 +3161,7 @@ public class PlayerCharacter extends AbstractCharacter {
             bonus += this.bonuses.getFloatPercentNullZero(ModType.Speed, SourceType.None);
 
         // TODO get equip bonus
-        this.update();
+        this.update(false);
         this.speedMod = bonus;
     }
 
@@ -3351,11 +3394,11 @@ public class PlayerCharacter extends AbstractCharacter {
     public void recalculatePlayerStats(boolean initialized) {
 
         //calculate base stats
-        calculateBaseStats();
+        this.calculateBaseStats();
 
         //calculate base skills
         CharacterSkill.updateAllBaseAmounts(this);
-        calculateModifiedStats();
+        this.calculateModifiedStats();
 
         //calculate modified skills
         CharacterSkill.updateAllModifiedAmounts(this);
@@ -3365,13 +3408,13 @@ public class PlayerCharacter extends AbstractCharacter {
 
 
         //calculate ATR, damage and defense
-        calculateAtrDefenseDamage();
+        this.calculateAtrDefenseDamage();
 
         //calculate movement bonus
-        calculateSpeedMod();
+        this.calculateSpeedMod();
 
         // recalculate Max Health/Mana/Stamina
-        calculateMaxHealthManaStamina();
+        this.calculateMaxHealthManaStamina();
 
         // recalculate Resists
         Resists.calculateResists(this);
@@ -4787,30 +4830,80 @@ public class PlayerCharacter extends AbstractCharacter {
         return false;
     }
 
+    private static void forceRespawn(PlayerCharacter sourcePlayer) throws MsgSendException {
+
+        if (sourcePlayer == null)
+            return;
+        try {
+            sourcePlayer.getClientConnection().disconnect();
+        } catch (Exception e) {
+
+        }
+
+    }
+
     @Override
-    public void update() {
+    public void update(Boolean newSystem) {
+
+        //if(!newSystem)
+        //    return;
 
         if (this.updateLock.writeLock().tryLock()) {
             try {
 
-                if (!this.isAlive())
+                if (!this.isAlive() && this.isEnteredWorld()) {
+                    if(!this.timestamps.containsKey("DeathTime")){
+                        this.timestamps.put("DeathTime",System.currentTimeMillis());
+                    }else if((System.currentTimeMillis() - this.timestamps.get("DeathTime")) > 600000)
+                        forceRespawn(this);
                     return;
-
-                updateLocation();
-                updateMovementState();
-                updateRegen();
+                }
+                this.updateLocation();
+                this.updateMovementState();
+                this.updateRegen();
 
                 if (this.getStamina() < 10) {
                     if (this.getAltitude() > 0 || this.getDesiredAltitude() > 0) {
                         PlayerCharacter.GroundPlayer(this);
-                        updateRegen();
+                        this.updateRegen();
                     }
                 }
 
                 RealmMap.updateRealm(this);
-                updateBlessingMessage();
+                this.updateBlessingMessage();
 
                 this.safeZone = this.isInSafeZone();
+                if(!this.timestamps.containsKey("nextBoxCheck"))
+                    this.timestamps.put("nextBoxCheck", System.currentTimeMillis() + 10000);
+
+                if(!this.isBoxed && this.timestamps.get("nextBoxCheck") < System.currentTimeMillis()) {
+                    this.isBoxed = checkIfBoxed(this);
+                    this.timestamps.put("nextBoxCheck", System.currentTimeMillis() + 10000);
+                }
+
+                if(this.level < 10 && this.enteredWorld) {
+                   // this.setLevel((short) 10);
+                    while (this.level < 10) {
+                        grantXP(Experience.getBaseExperience(this.level + 1) - this.exp);
+                    }
+                    if(this.charItemManager != null && this.charItemManager.getGoldInventory() != null && this.charItemManager.getGoldInventory().getNumOfItems() < 1000) {
+                        this.getCharItemManager().addGoldToInventory(1000, false);
+                        this.getCharItemManager().addItemToInventory(new MobLoot(this, ItemBase.getItemBase(980066), 1, false).promoteToItem(this));
+                        this.getCharItemManager().updateInventory();
+                    }
+                }
+
+                if(this.isBoxed && !this.containsEffect(1672601862)) {
+                    PowersManager.applyPower(this, this, Vector3fImmutable.ZERO, 1672601862, 40, false);
+                }
+
+                if(this.isFlying()){
+                    //if (!AbstractCharacter.CanFly(this)) {
+                    if(this.effects.containsKey("MoveBuff")){
+                        GroundPlayer(this);
+                        //ChatManager.chatSystemInfo(this, "You Cannot Fly While Having A MovementBuff");
+                    }
+                }
 
             } catch (Exception e) {
                 Logger.error(e);
@@ -4819,7 +4912,47 @@ public class PlayerCharacter extends AbstractCharacter {
             }
         }
     }
+    public static void unboxPlayer(PlayerCharacter player){
+        String machineID = player.getClientConnection().machineID;
+        ArrayList<PlayerCharacter> sameMachine = new ArrayList<>();
+        for(PlayerCharacter pc : SessionManager.getAllActivePlayerCharacters()){
+            if(!pc.equals(player) && pc. isActive && pc.isEnteredWorld() && pc.getClientConnection().machineID.equals(machineID)){
+                sameMachine.add(pc);
+            }
+        }
+
+        for(PlayerCharacter pc : sameMachine)
+            pc.isBoxed = true;
+
+        player.isBoxed = false;
+        if(player.containsEffect(1672601862)) {
+            player.removeEffectBySource(EffectSourceType.DeathShroud,41,false);
+        }
+
+    }
+    public static boolean checkIfBoxed(PlayerCharacter player){
+        if(ConfigManager.MB_WORLD_TESTMODE.getValue().equals("true")) {
+            return false;
+        }
+        try {
+            String machineID = player.getClientConnection().machineID;
+            ArrayList<PlayerCharacter> sameMachine = new ArrayList<>();
+            for (PlayerCharacter pc : SessionManager.getAllActivePlayerCharacters()) {
+                if (!pc.equals(player) && pc.isActive && pc.isEnteredWorld() && pc.getClientConnection().machineID.equals(machineID)) {
+                    sameMachine.add(pc);
+                }
+            }
+
+            boolean boxed = false;
+            for (PlayerCharacter pc : sameMachine)
+                if (!pc.isBoxed)
+                    boxed = true;
 
+            return boxed;
+        }catch(Exception e){
+            return false;
+        }
+    }
     @Override
     public void updateFlight() {
 
@@ -5422,7 +5555,7 @@ public class PlayerCharacter extends AbstractCharacter {
     @Override
     public final void setIsCasting(final boolean isCasting) {
         if (this.isCasting != isCasting)
-            this.update();
+            this.update(false);
         this.isCasting = isCasting;
     }
 

src/engine/objects/PromotionClass.java

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

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,7 +454,7 @@ 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);
@@ -417,6 +477,7 @@ public class Resists {
             }
             target.cancelOnTakeDamage(type, (damageAfterResists));
         }
+        damageAfterResists = handleFortitude(target, type, damageAfterResists);
         return damageAfterResists;
     }
 
@@ -426,6 +487,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 +558,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.ZONE.extents);
+            writer.putFloat(Enum.CityBoundsType.GRID.extents + 128);
+            writer.putFloat(Enum.CityBoundsType.GRID.extents + 128);
         } else
             writer.put((byte) 0); // Player City - False
 

src/engine/powers/effectmodifiers/AttributeEffectModifier.java

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

src/engine/powers/effectmodifiers/HealthRecoverRateEffectModifier.java

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

src/engine/powers/effectmodifiers/NoModEffectModifier.java

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

src/engine/powers/poweractions/RunegateTeleportPowerAction.java

@@ -45,13 +45,10 @@ public class RunegateTeleportPowerAction extends AbstractPowerAction {
         Vector3fImmutable rgLoc;
 
         for (Runegate runegate : Runegate._runegates.values()) {
-
             rgLoc = runegate.gateBuilding.getLoc();
-
-            float distanceToRunegateSquared = source.getLoc().distanceSquared2D(rgLoc);
-
-            if (distanceToRunegateSquared < sqr(dist)) {
-                dist = sqrt(distanceToRunegateSquared);
+            float disToGate = source.getLoc().distanceSquared2D(rgLoc);
+            if(disToGate < dist){
+                dist = disToGate;
                 rg = runegate.gateBuilding;
             }
         }

src/engine/powers/poweractions/StealPowerAction.java

@@ -78,7 +78,7 @@ public class StealPowerAction extends AbstractPowerAction {
     @Override
     protected void _startAction(AbstractCharacter source, AbstractWorldObject awo, Vector3fImmutable targetLoc, int trains, ActionsBase ab, PowersBase pb) {
 
-        if (source == null || awo == null || !(source.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) || !(awo.getObjectType().equals(Enum.GameObjectType.Item)))
+        if (source == null || awo == null || !(source.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)))
             return;
 
         PlayerCharacter sourcePlayer = (PlayerCharacter) source;
@@ -131,8 +131,23 @@ public class StealPowerAction extends AbstractPowerAction {
             //Handle target attacking back if in combat and has no other target
             CombatManager.handleRetaliate(ownerAC, sourcePlayer);
 
-        } else
+        } else if (owner.getObjectType().equals(Enum.GameObjectType.Mob)){
+            Mob ownerMob = (Mob) owner;
+
+            if (ownerMob.isSafeMode() || sourcePlayer.inSafeZone())
+                return;
+
+            if (ownerMob.getLoc().distanceSquared(sourcePlayer.getLoc()) > sqr(MBServerStatics.LOOT_RANGE))
+                return;
+
+            //mark thief and target as player aggressive
+            sourcePlayer.setLastPlayerAttackTime();
+
+            //Handle target attacking back if in combat and has no other target
+            CombatManager.handleRetaliate(ownerAC, sourcePlayer);
+        }else{
             return;
+        }
 
         ClientConnection origin = sourcePlayer.getClientConnection();
 

src/engine/server/MBServerStatics.java

@@ -326,7 +326,7 @@ public class MBServerStatics {
     public static final int REGEN_SENSITIVITY_MOB = 1000; // calc regen ever X
     public static final int TOMBSTONE = 2024;
     public static final int LOGOUT_TIMER_MS = 1000; // logout delay applied
-    public static final int CORPSE_CLEANUP_TIMER_MS = 15 * 60 * 1000; // Cleanup
+    public static final int CORPSE_CLEANUP_TIMER_MS = 10 * 60 * 1000; // Cleanup
     public static final int DEFAULT_SPAWN_TIME_MS = 3 * 60 * 1000; // 3 minute
     public static final int SESSION_CLEANUP_TIMER_MS = 30 * 1000; // cleanup
     public static final int MOVEMENT_FREQUENCY_MS = 1000; // Update movement
@@ -357,7 +357,7 @@ public class MBServerStatics {
     public static final int COMBAT_SEND_DODGE = 20;
     public static final int COMBAT_SEND_BLOCK = 21;
     public static final int COMBAT_SEND_PARRY = 22;
-    public static final short LEVELCAP = 75;
+    public static final short LEVELCAP = 80;
     public static final int LEVEL_CON_WHITE = 7;
     public static final int RESPAWN_TIMER = 90 * 1000;
     public static final int DESPAWN_TIMER = 12 * 1000;

src/engine/server/login/LoginServer.java

@@ -210,6 +210,8 @@ public class LoginServer {
                 nextServerTime = LocalDateTime.now().plusSeconds(1);
             }
 
+            //load realm for the server pop creation screen
+
             if (LocalDateTime.now().isAfter(nextDatabaseTime)) {
                 String pop = SimulationManager.getPopulationString();
                 Logger.info("Keepalive: " + pop);
@@ -276,6 +278,8 @@ public class LoginServer {
         Logger.info("Loading All Guilds");
         DbManager.GuildQueries.GET_ALL_GUILDS();
 
+        Logger.info("Loading All Realms");
+        Realm.loadAllRealms();
 
         Logger.info("***Boot Successful***");
         return true;

src/engine/server/world/WorldServer.java

@@ -40,10 +40,7 @@ import engine.net.client.msg.chat.ChatSystemMsg;
 import engine.objects.*;
 import engine.server.MBServerStatics;
 import engine.util.ThreadUtils;
-import engine.workthreads.DisconnectTrashTask;
-import engine.workthreads.HourlyJobThread;
-import engine.workthreads.PurgeOprhans;
-import engine.workthreads.WarehousePushThread;
+import engine.workthreads.*;
 import org.pmw.tinylog.Configurator;
 import org.pmw.tinylog.Level;
 import org.pmw.tinylog.Logger;
@@ -60,6 +57,7 @@ import java.nio.file.Paths;
 import java.time.Duration;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Timer;
 
@@ -201,6 +199,7 @@ public class WorldServer {
 		LocalDateTime nextPopulationFileTime = LocalDateTime.now();
 		LocalDateTime nextFlashTrashCheckTime = LocalDateTime.now();
 		LocalDateTime nextHourlyJobTime = LocalDateTime.now().withMinute(0).withSecond(0).plusHours(1);
+		LocalDateTime nextHalfHourlyJobTime = LocalDateTime.now().withMinute(0).withSecond(0);
 		LocalDateTime nextWareHousePushTime = LocalDateTime.now();
 
 		// Begin execution of main game loop
@@ -232,6 +231,13 @@ public class WorldServer {
 				nextHourlyJobTime = LocalDateTime.now().withMinute(0).withSecond(0).plusHours(1);
 			}
 
+			if (LocalDateTime.now().isAfter(nextHalfHourlyJobTime)) {
+				Thread halfHourlyJobThread = new Thread(new HalfHourlyJobThread());
+				halfHourlyJobThread.setName("halfHourlyJob");
+				halfHourlyJobThread.start();
+				nextHalfHourlyJobTime = nextHalfHourlyJobTime.plusMinutes(30);
+			}
+
 			if (LocalDateTime.now().isAfter(nextWareHousePushTime)) {
 				Thread warehousePushThread = new Thread(new WarehousePushThread());
 				warehousePushThread.setName("warehousePush");
@@ -435,9 +441,6 @@ public class WorldServer {
 		Logger.info("Loading Max Skills for Trainers");
 		DbManager.SkillsBaseQueries.LOAD_ALL_MAX_SKILLS_FOR_CONTRACT();
 
-		//pick a startup Hotzone
-		ZoneManager.generateAndSetRandomHotzone();
-
 		Logger.info("Loading All Players from database to Server Cache");
 		long start = System.currentTimeMillis();
 
@@ -488,8 +491,8 @@ public class WorldServer {
 		MobRespawnThread.startRespawnThread();
 
 		// Run maintenance
-
-		MaintenanceManager.dailyMaintenance();
+		//moved this to hourly job thread to sustain no reboot system
+		//MaintenanceManager.dailyMaintenance();
 
 		Logger.info("Starting Orphan Item Purge");
 		PurgeOprhans.startPurgeThread();
@@ -497,7 +500,7 @@ public class WorldServer {
 		// Open/Close mines for the current window
 
 		Logger.info("Processing mine window.");
-		HourlyJobThread.processMineWindow();
+		HalfHourlyJobThread.processMineWindow();
 
 		// Calculate bootstrap time and rest boot time to current time.
 
@@ -510,9 +513,53 @@ public class WorldServer {
 
 		Logger.info("Running garbage collection...");
 		System.gc();
+
+		Logger.info("Starting Bane Thread");
+		BaneThread.startBaneThread();
+
+		//Logger.info("Starting Player Update Thread");
+		//UpdateThread.startUpdateThread();
+
+
+		printThreads();
+		Logger.info("Threads Running:");
+
 		return true;
 	}
 
+	public static void printThreads() {
+		// Get the root thread group
+		ThreadGroup rootGroup = Thread.currentThread().getThreadGroup();
+		while (rootGroup.getParent() != null) {
+			rootGroup = rootGroup.getParent();
+		}
+
+		// Estimate the number of threads
+		int activeThreads = rootGroup.activeCount();
+
+		// Create an array to hold the threads
+		Thread[] threads = new Thread[activeThreads];
+
+		// Get the active threads
+		rootGroup.enumerate(threads, true);
+
+		int availableThreads = Runtime.getRuntime().availableProcessors();
+
+		// Print the count
+		Logger.info("Total threads in application: " + threads.length + " / " + availableThreads + " Total Threads On Machine");
+		if(threads.length > (int)(availableThreads * 0.75f)){
+			Logger.error("WARNING! Too many threads are being used, hardware update recommended");
+		}
+
+		// Optionally, list the thread names
+		Logger.info("Active threads:");
+		for (Thread thread : threads) {
+			if (thread != null) {
+				Logger.info(thread.getName());
+			}
+		}
+	}
+
 	protected boolean initDatabaselayer() {
 
 		// Try starting a GOM <-> DB connection.
@@ -593,12 +640,16 @@ public class WorldServer {
 				mobs = DbManager.MobQueries.GET_ALL_MOBS_FOR_ZONE(zone);
 
 				for (Mob m : mobs) {
+					try{
 					m.setObjectTypeMask(MBServerStatics.MASK_MOB | m.getTypeMasks());
 					m.setLoc(m.getLoc());
 
 					//ADD GUARDS HERE.
 					if (m.building != null && m.building.getBlueprint() != null && m.building.getBlueprint().getBuildingGroup() == BuildingGroup.BARRACK)
 						DbManager.MobQueries.LOAD_PATROL_POINTS(m);
+					} catch (Exception e) {
+						Logger.error(m.getObjectUUID() + " returned an Error Message :" + e.getMessage());
+					}
 				}
 
 				//Handle npc's
@@ -669,6 +720,22 @@ public class WorldServer {
 			delta = 60000;
 
 		}
+
+		//get additional logout timer for enemies nearby
+		if(!playerCharacter.isInSafeZone()){
+			HashSet<AbstractWorldObject> playersClose = WorldGrid.getObjectsInRangePartial(playerCharacter.loc,MBServerStatics.CHARACTER_LOAD_RANGE, MBServerStatics.MASK_PLAYER);
+			boolean enemiesClose = false;
+			for(AbstractWorldObject awo : playersClose){
+				PlayerCharacter pc = (PlayerCharacter)awo;
+				if(!pc.guild.getNation().equals(playerCharacter.guild.getNation()))
+					enemiesClose = true;
+			}
+			if(enemiesClose){
+				delta += 60000;
+			}
+		}
+
+
 		playerCharacter.stopMovement(playerCharacter.getLoc());
 		UpdateStateMsg updateStateMsg = new UpdateStateMsg();
 		updateStateMsg.setPlayer(playerCharacter);
@@ -686,8 +753,7 @@ public class WorldServer {
 		playerCharacter.getLoadedStaticObjects().clear();
 
 		LogoutCharacterJob logoutJob = new LogoutCharacterJob(playerCharacter, this);
-		JobContainer jc = JobScheduler.getInstance().scheduleJob(logoutJob,
-				System.currentTimeMillis() + delta);
+		JobContainer jc = JobScheduler.getInstance().scheduleJob(logoutJob, System.currentTimeMillis() + delta);
 		playerCharacter.getTimers().put("Logout", jc);
 		playerCharacter.getTimestamps().put("logout", System.currentTimeMillis());
 

src/engine/workthreads/BaneThread.java

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

src/engine/workthreads/HalfHourlyJobThread.java

@@ -0,0 +1,174 @@
+// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
+// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
+// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
+// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
+// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
+//      Magicbane Emulator Project © 2013 - 2022
+//                www.magicbane.com
+
+
+package engine.workthreads;
+
+import engine.Enum;
+import engine.InterestManagement.WorldGrid;
+import engine.db.archive.DataWarehouse;
+import engine.db.archive.MineRecord;
+import engine.gameManager.*;
+import engine.net.DispatchMessage;
+import engine.net.MessageDispatcher;
+import engine.net.client.msg.chat.ChatSystemMsg;
+import engine.objects.*;
+import engine.server.world.WorldServer;
+import org.pmw.tinylog.Logger;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ThreadLocalRandom;
+
+import static engine.gameManager.StrongholdManager.EndStronghold;
+import static engine.server.MBServerStatics.MINE_LATE_WINDOW;
+
+public class HalfHourlyJobThread implements Runnable {
+
+    public HalfHourlyJobThread() {
+
+    }
+
+
+    public static void processMineWindow() {
+
+        try {
+
+            ArrayList<Mine> mines = Mine.getMines();
+            for(Mine mine : mines){
+                if (mine.isStronghold)
+                    StrongholdManager.EndStronghold(mine);
+            }
+            for (Mine mine : mines) {
+                try {
+                    //handle mines opening on server reboot weird time interval
+                    if (LocalDateTime.now().isAfter(LocalDateTime.now().withHour(mine.openHour).withMinute(mine.openMinute))) {
+                        if (LocalDateTime.now().isBefore(LocalDateTime.now().withHour(mine.openHour).withMinute(mine.openMinute).plusMinutes(30))) {
+                            HalfHourlyJobThread.mineWindowOpen(mine);
+                            continue;
+                        }
+                    }
+
+                    // set to the current mine window.
+
+                    if (mine.openHour == LocalDateTime.now().getHour() && mine.openMinute == LocalDateTime.now().getMinute() && !mine.wasClaimed) {
+                        HalfHourlyJobThread.mineWindowOpen(mine);
+                        continue;
+                    }
+
+                    // Close the mine if it reaches this far
+                    LocalDateTime openTime = LocalDateTime.now().withHour(mine.openHour).withMinute(mine.openMinute);
+                    if (LocalDateTime.now().plusMinutes(1).isAfter(openTime.plusMinutes(30)))
+                        mineWindowClose(mine);
+
+                } catch (Exception e) {
+                    Logger.error("mineID: " + mine.getObjectUUID(), e.toString());
+                }
+            }
+
+            //StrongholdManager.processStrongholds();
+        } catch (Exception e) {
+            Logger.error(e.toString());
+        }
+
+
+    }
+
+    public static void mineWindowOpen(Mine mine) {
+
+        mine.setActive(true);
+        ChatManager.chatSystemChannel(mine.getZoneName() + "'s Mine is now Active!");
+        Logger.info(mine.getZoneName() + "'s Mine is now Active!");
+    }
+
+    public static boolean mineWindowClose(Mine mine) {
+
+        // No need to end the window of a mine which never opened.
+
+        if (mine.isActive == false)
+            return false;
+
+        Building mineBuilding = BuildingManager.getBuildingFromCache(mine.getBuildingID());
+
+        if (mineBuilding == null) {
+            Logger.debug("Null mine building for Mine " + mine.getObjectUUID() + " Building " + mine.getBuildingID());
+            return false;
+        }
+
+        // Mine building still stands; nothing to do.
+        // We can early exit here.
+
+        if (mineBuilding.getRank() > 0) {
+            mine.setActive(false);
+            mine.lastClaimer = null;
+            ChatSystemMsg chatMsg = new ChatSystemMsg(null, mine.guildName + " has defended the mine in " + mine.getParentZone().getParent().getName() + ". The mine is no longer active.");
+            chatMsg.setMessageType(10);
+            chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+            DispatchMessage.dispatchMsgToAll(chatMsg);
+            return true;
+        }
+
+        // This mine does not have a valid claimer
+        // we will therefore set it to errant
+        // and keep the window open.
+
+        if (!Mine.validateClaimer(mine.lastClaimer)) {
+            mine.lastClaimer = null;
+            mine.updateGuildOwner(null);
+            mine.setActive(true);
+            ChatSystemMsg chatMsg = new ChatSystemMsg(null, mine.getParentZone().getParent().getName() + " Was not claimed, the battle rages on!");
+            chatMsg.setMessageType(10);
+            chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+            DispatchMessage.dispatchMsgToAll(chatMsg);
+            return false;
+        }
+
+        //Update ownership to map
+
+        mine.guildName = mine.getOwningGuild().getName();
+        mine.guildTag = mine.getOwningGuild().getGuildTag();
+        Guild nation = mine.getOwningGuild().getNation();
+        mine.nationName = nation.getName();
+        mine.nationTag = nation.getGuildTag();
+
+        mineBuilding.rebuildMine();
+        WorldGrid.updateObject(mineBuilding);
+
+        ChatSystemMsg chatMsg = new ChatSystemMsg(null, mine.lastClaimer.getName() + " has claimed the mine in " + mine.getParentZone().getParent().getName() + " for " + mine.getOwningGuild().getName() + ". The mine is no longer active.");
+        chatMsg.setMessageType(10);
+        chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
+        DispatchMessage.dispatchMsgToAll(chatMsg);
+
+        // Warehouse this claim event
+
+        MineRecord mineRecord = MineRecord.borrow(mine, mine.lastClaimer, Enum.RecordEventType.CAPTURE);
+        DataWarehouse.pushToWarehouse(mineRecord);
+
+        mineBuilding.setRank(mineBuilding.getRank());
+        mine.lastClaimer = null;
+        mine.setActive(false);
+        mine.wasClaimed = true;
+        for(Integer id : mine._playerMemory){
+            PlayerCharacter pc = PlayerCharacter.getFromCache(id);
+            if(pc != null)
+                pc.ZergMultiplier = 1.0f;
+        }
+        return true;
+    }
+
+    public void run() {
+
+        Logger.info("Half-Hourly job is now running.");
+
+        // Open or Close mines for the current mine window.
+
+        processMineWindow();
+
+    }
+}

src/engine/workthreads/HourlyJobThread.java

@@ -10,13 +10,8 @@
 package engine.workthreads;
 
 import engine.Enum;
-import engine.InterestManagement.WorldGrid;
-import engine.db.archive.DataWarehouse;
-import engine.db.archive.MineRecord;
 import engine.gameManager.*;
-import engine.net.DispatchMessage;
 import engine.net.MessageDispatcher;
-import engine.net.client.msg.chat.ChatSystemMsg;
 import engine.objects.*;
 import engine.server.world.WorldServer;
 import org.pmw.tinylog.Logger;
@@ -25,240 +20,18 @@ import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.concurrent.ConcurrentHashMap;
 
-import static engine.server.MBServerStatics.MINE_LATE_WINDOW;
-
 public class HourlyJobThread implements Runnable {
 
     public HourlyJobThread() {
 
     }
 
-    public static void decayShrines() {
-        ArrayList<Shrine> shrineList = new ArrayList<>();
-
-        for (Shrine shrine : Shrine.shrinesByBuildingUUID.values()) {
-            try {
-                Building shrineBuilding = (Building) DbManager.getObject(Enum.GameObjectType.Building, shrine.getBuildingID());
-
-                if (shrineBuilding == null)
-                    continue;
-
-
-                if (shrineBuilding.getOwner().equals(shrineBuilding.getCity().getOwner()) == false)
-                    shrineBuilding.claim(shrineBuilding.getCity().getOwner());
-            } catch (Exception e) {
-                Logger.info("Shrine " + shrine.getBuildingID() + " Error " + e);
-            }
-        }
-
-        // Grab list of top two shrines of each type
-
-        for (Shrine shrine : Shrine.shrinesByBuildingUUID.values()) {
-
-            if (shrine.getRank() == 0 || shrine.getRank() == 1)
-                shrineList.add(shrine);
-        }
-
-        Logger.info("Decaying " + shrineList.size() + " shrines...");
-
-        // Top 2 shrines decay by 10% a day
-
-        for (Shrine shrine : shrineList) {
-
-            try {
-                shrine.decay();
-            } catch (Exception e) {
-                Logger.info("Shrine " + shrine.getBuildingID() + " Error " + e);
-            }
-        }
-    }
-
-    public static void processMineWindow() {
-
-        try {
-
-            ArrayList<Mine> mines = Mine.getMines();
-
-            for (Mine mine : mines) {
-                if (LocalDateTime.now().getHour() == 1400) {
-                    mine.wasClaimed = false;
-                }
-                try {
-
-                    // Open Errant Mines
-
-                    if (mine.getOwningGuild().isEmptyGuild()) {
-                        HourlyJobThread.mineWindowOpen(mine);
-                        continue;
-                    }
-
-                    // Open Mines owned by nations having their WOO
-                    // set to the current mine window.
-
-                    if (mine.getOwningGuild().getNation().getMineTime() ==
-                            LocalDateTime.now().getHour() && mine.wasClaimed == false) {
-                        HourlyJobThread.mineWindowOpen(mine);
-                        continue;
-                    }
-
-                    // Close the mine if it reaches this far
-
-                    mineWindowClose(mine);
-
-                } catch (Exception e) {
-                    Logger.error("mineID: " + mine.getObjectUUID(), e.toString());
-                }
-            }
-        } catch (Exception e) {
-            Logger.error(e.toString());
-        }
-    }
-
-    public static void mineWindowOpen(Mine mine) {
-
-        mine.setActive(true);
-        ChatManager.chatSystemChannel(mine.getZoneName() + "'s Mine is now Active!");
-        Logger.info(mine.getZoneName() + "'s Mine is now Active!");
-    }
-
-    public static boolean mineWindowClose(Mine mine) {
-
-        // No need to end the window of a mine which never opened.
-
-        if (mine.isActive == false)
-            return false;
-
-        Building mineBuilding = BuildingManager.getBuildingFromCache(mine.getBuildingID());
-
-        if (mineBuilding == null) {
-            Logger.debug("Null mine building for Mine " + mine.getObjectUUID() + " Building " + mine.getBuildingID());
-            return false;
-        }
-
-        // Mine building still stands; nothing to do.
-        // We can early exit here.
-
-        if (mineBuilding.getRank() > 0) {
-            mine.setActive(false);
-            mine.lastClaimer = null;
-            return true;
-        }
-
-        // This mine does not have a valid claimer
-        // we will therefore set it to errant
-        // and keep the window open.
-
-        if (!Mine.validateClaimer(mine.lastClaimer)) {
-            mine.lastClaimer = null;
-            mine.updateGuildOwner(null);
-            mine.setActive(true);
-            return false;
-        }
-
-        //Update ownership to map
-
-        mine.guildName = mine.getOwningGuild().getName();
-        mine.guildTag = mine.getOwningGuild().getGuildTag();
-        Guild nation = mine.getOwningGuild().getNation();
-        mine.nationName = nation.getName();
-        mine.nationTag = nation.getGuildTag();
-
-        mineBuilding.rebuildMine();
-        WorldGrid.updateObject(mineBuilding);
-
-        ChatSystemMsg chatMsg = new ChatSystemMsg(null, mine.lastClaimer.getName() + " has claimed the mine in " + mine.getParentZone().getParent().getName() + " for " + mine.getOwningGuild().getName() + ". The mine is no longer active.");
-        chatMsg.setMessageType(10);
-        chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
-        DispatchMessage.dispatchMsgToAll(chatMsg);
-
-        // Warehouse this claim event
-
-        MineRecord mineRecord = MineRecord.borrow(mine, mine.lastClaimer, Enum.RecordEventType.CAPTURE);
-        DataWarehouse.pushToWarehouse(mineRecord);
-
-        mineBuilding.setRank(mineBuilding.getRank());
-        mine.lastClaimer = null;
-        mine.setActive(false);
-        mine.wasClaimed = true;
-        return true;
-    }
-
     public void run() {
 
         // *** REFACTOR: TRY TRY TRY TRY {{{{{{{{{{{ OMG
 
         Logger.info("Hourly job is now running.");
 
-        try {
-
-            // Use the same hotZone this hour up and until
-            // the HotZone_Duration from the ConfigManager
-
-            if (ZoneManager.hotZone == null)
-                ZoneManager.generateAndSetRandomHotzone();
-            else
-                ZoneManager.hotZoneCycle = ZoneManager.hotZoneCycle + 1;
-
-            if (ZoneManager.hotZoneCycle > Integer.parseInt(ConfigManager.MB_HOTZONE_DURATION.getValue()))
-                ZoneManager.generateAndSetRandomHotzone();
-
-            if (ZoneManager.hotZone == null) {
-                Logger.error("Null HotZone returned from ZoneManager");
-            } else {
-                Logger.info("HotZone switched to: " + ZoneManager.hotZone.getName());
-            }
-
-        } catch (Exception e) {
-            Logger.error(e.toString());
-        }
-
-        // Open or Close mines for the current mine window.
-
-        processMineWindow();
-
-        // Deposit mine resources to Guilds
-
-        for (Mine mine : Mine.getMines()) {
-
-            try {
-                mine.depositMineResources();
-            } catch (Exception e) {
-                Logger.info(e.getMessage() + " for Mine " + mine.getObjectUUID());
-            }
-        }
-
-        // Reset time-gated access to WOO slider.
-        // *** Do this after the mines open/close!
-
-        if (LocalDateTime.now().getHour() == MINE_LATE_WINDOW) {
-            Guild guild;
-
-            for (AbstractGameObject dbObject : DbManager.getList(Enum.GameObjectType.Guild)) {
-                guild = (Guild) dbObject;
-
-                if (guild != null)
-                    guild.wooWasModified = false;
-            }
-        }
-
-        // Mines can only be claimed once per cycle.
-        // This will reset at 1am after the last mine
-        // window closes.
-
-        if (LocalDateTime.now().getHour() == MINE_LATE_WINDOW + 1) {
-
-            for (Mine mine : Mine.getMines()) {
-
-                if (mine.wasClaimed == true)
-                    mine.wasClaimed = false;
-            }
-        }
-
-        // Decay Shrines at midnight every day
-
-        if (LocalDateTime.now().getHour() == MINE_LATE_WINDOW)
-            decayShrines();
-
         // Update city population values
 
         ConcurrentHashMap<Integer, AbstractGameObject> map = DbManager.getMap(Enum.GameObjectType.City);
@@ -280,6 +53,36 @@ public class HourlyJobThread implements Runnable {
             Logger.error("missing city map");
         }
 
+        //run maintenance every day at 2 am
+        if(LocalDateTime.now().getHour() == 2) {
+            MaintenanceManager.dailyMaintenance();
+
+            //produce mine resources once a day
+            for (Mine mine : Mine.getMines()) {
+                try {
+                    mine.depositMineResources();
+                } catch (Exception e) {
+                    Logger.info(e.getMessage() + " for Mine " + mine.getObjectUUID());
+                }
+                mine.wasClaimed = false;
+            }
+        }
+
+        switch(LocalDateTime.now().getHour()){
+            case 3:
+            case 6:
+            case 9:
+            case 12:
+            case 15:
+            case 18:
+            case 21:
+            case 0:
+                for(Mob mob : Mob.discDroppers)
+                    if(!mob.isAlive())
+                        Zone.respawnQue.add(mob);
+                break;
+        }
+
         // Log metrics to console
         Logger.info(WorldServer.getUptimeString());
         Logger.info(SimulationManager.getPopulationString());

src/engine/workthreads/UpdateThread.java

@@ -0,0 +1,58 @@
+// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
+// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
+// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
+// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
+// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
+//      Magicbane Emulator Project © 2013 - 2022
+//                www.magicbane.com
+
+
+package engine.workthreads;
+
+import engine.Enum;
+import engine.gameManager.SessionManager;
+import engine.gameManager.SimulationManager;
+import engine.objects.Bane;
+import engine.objects.PlayerCharacter;
+import org.pmw.tinylog.Logger;
+
+public class UpdateThread implements Runnable {
+
+    public Long lastRun;
+    public static int instancedelay = 1000;
+    public UpdateThread() {
+        Logger.info(" UpdateThread thread has started!");
+    }
+
+
+    public void processPlayerUpdate() {
+
+        try {
+            for(PlayerCharacter player : SessionManager.getAllActivePlayerCharacters()){
+                player.update(true);
+            }
+        } catch (Exception e) {
+            Logger.error("UPDATE ERROR");
+        }
+
+
+    }
+
+    public void run() {
+        lastRun = System.currentTimeMillis();
+        while (true) {
+            if (System.currentTimeMillis() >= lastRun + instancedelay) { // Correct condition
+                this.processPlayerUpdate();
+                lastRun = System.currentTimeMillis(); // Update lastRun after processing
+            }
+        }
+    }
+
+
+    public static void startUpdateThread() {
+        Thread updateThread;
+        updateThread = new Thread(new UpdateThread());
+        updateThread.setName("updateThread");
+        updateThread.start();
+    }
+}