fix charge bug

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

src/engine/Enum.java

@@ -979,8 +979,8 @@ public class Enum {
             try {
                 returnMod = SourceType.valueOf(modName.replace(",", ""));
             } catch (Exception e) {
-                Logger.error(modName);
-                Logger.error(e);
+                //Logger.error(modName);
+                //Logger.error(e);
                 return SourceType.None;
             }
             return returnMod;

src/engine/InterestManagement/InterestManager.java

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

src/engine/devcmd/cmds/AddGoldCmd.java

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

src/engine/devcmd/cmds/AddMobCmd.java

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

src/engine/devcmd/cmds/GimmeCmd.java

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

src/engine/devcmd/cmds/InfoCmd.java

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

src/engine/devcmd/cmds/PrintEffectsCmd.java

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

src/engine/devcmd/cmds/PrintStatsCmd.java

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

src/engine/gameManager/ChatManager.java

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

src/engine/gameManager/CombatManager.java

@@ -312,6 +312,7 @@ public enum CombatManager {
                     if(pet.combatTarget == null && pet.assist)
                         pet.setCombatTarget(attacker.combatTarget);
                 }
+
             }
 
 
@@ -431,7 +432,10 @@ public enum CombatManager {
 
             //Source can attack.
             //NOTE Don't 'return;' beyond this point until timer created
-
+            if(abstractCharacter.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                PlayerCharacter pc = (PlayerCharacter)abstractCharacter;
+                pc.updateMovementState();
+            }
             boolean attackFailure = (wb != null) && (wb.getRange() > 35f) && abstractCharacter.isMoving();
 
             //Target can't attack on move with ranged weapons.
@@ -469,16 +473,27 @@ public enum CombatManager {
 
             //Range check.
 
-            if(abstractCharacter.isMoving()){
-                range += (abstractCharacter.getSpeed() * 0.1f);
-            }
+            //if(abstractCharacter.isMoving()){
+            //    range += (abstractCharacter.getSpeed() * 0.1f); // add movement vector offset for moving attacker
+            //}
 
-            if(AbstractWorldObject.IsAbstractCharacter(target)) {
-                AbstractCharacter tarAc = (AbstractCharacter) target;
-                if(tarAc != null && tarAc.isMoving()){
-                    range += (tarAc.getSpeed() * 0.1f);
-                }
-            }
+            //if(AbstractWorldObject.IsAbstractCharacter(target)) {
+            //    AbstractCharacter tarAc = (AbstractCharacter) target;
+            //    if(tarAc != null && tarAc.isMoving()){
+            //        range += (tarAc.getSpeed() * 0.1f); // add movement vector offset for moving target
+           //     }
+            //}
+
+            //float attackerHitBox = abstractCharacter.calcHitBox(); // add attacker hitbox
+            //float targetHitBox = 0.0f;
+            //if(AbstractCharacter.IsAbstractCharacter(target)){
+            //    AbstractCharacter targetCharacter = (AbstractCharacter)target;
+            //    targetHitBox = targetCharacter.calcHitBox(); // add target hitbox
+            //}
+
+            //range += attackerHitBox + targetHitBox + 2.5f; // offset standard range to sync where client tries to stop
+
+            range += 2; //sync offset
 
             if (NotInRange(abstractCharacter, target, range)) {
 
@@ -503,6 +518,16 @@ public enum CombatManager {
                 }
             }
 
+            if(abstractCharacter.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                PlayerCharacter pc = (PlayerCharacter)abstractCharacter;
+                if(pc.isBoxed){
+                    if(target.getObjectType().equals(GameObjectType.PlayerCharacter)) {
+                        ChatManager.chatSystemInfo(pc, "You Are PvE Flagged: Cannot Attack Players.");
+                        attackFailure = true;
+                    }
+                }
+            }
+
             //TODO Verify attacker has los (if not ranged weapon).
 
             if (!attackFailure) {
@@ -929,6 +954,11 @@ public enum CombatManager {
 
                 float d = 0f;
 
+                int originalDamage = (int)damage;
+                if(ac != null && ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                    damage *= ((PlayerCharacter)ac).ZergMultiplier;
+                } // Health modifications are modified by the ZergMechanic
+
                 errorTrack = 12;
 
                 //Subtract Damage from target's health
@@ -942,9 +972,13 @@ public enum CombatManager {
                         ac.setHateValue(damage * MBServerStatics.PLAYER_COMBAT_HATE_MODIFIER);
                         ((Mob) tarAc).handleDirectAggro(ac);
                     }
-
-                    if (tarAc.getHealth() > 0)
+                    if (tarAc.getHealth() > 0) {
                         d = tarAc.modifyHealth(-damage, ac, false);
+                        if(tarAc != null && tarAc.getObjectType().equals(GameObjectType.PlayerCharacter) && ((PlayerCharacter)ac).ZergMultiplier != 1.0f){
+                            PlayerCharacter debugged = (PlayerCharacter)tarAc;
+                            ChatManager.chatSystemInfo(debugged, "ZERG DEBUG: " + ac.getName() + " Hits You For: " + (int)damage + " instead of " + originalDamage);
+                        }
+                    }
 
                     tarAc.cancelOnTakeDamage();
 
@@ -1213,10 +1247,6 @@ 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);
     }

src/engine/gameManager/DevCmdManager.java

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

src/engine/gameManager/HellgateManager.java

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

src/engine/gameManager/HotzoneManager.java

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

src/engine/gameManager/LootManager.java

@@ -17,10 +17,7 @@ import engine.objects.*;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.ThreadLocalRandom;
 
 /**
@@ -90,6 +87,13 @@ public enum LootManager {
             return;
         }
 
+        if(!mob.getSafeZone()) {
+            SpecialLootHandler.RollContract(mob);
+            SpecialLootHandler.RollGlass(mob);
+            SpecialLootHandler.RollRune(mob);
+            SpecialLootHandler.RollRacialGuard(mob);
+        }
+
         //determine if mob is in hotzone
         boolean inHotzone = false;
 
@@ -127,7 +131,10 @@ public enum LootManager {
             if (ib == null)
                 break;
             if (ib.isDiscRune() || ib.getName().toLowerCase().contains("of the gods")) {
-                ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + mob.getParentZone().getName() + " has found the " + ib.getName() + ". Are you tough enough to take it?");
+                Zone camp = mob.getParentZone();
+                Zone macro = camp.getParent();
+                String name = camp.getName() + "(" + macro.getName() + ")";
+                ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + name + " has found the " + ib.getName() + ". Are you tough enough to take it?");
                 chatMsg.setMessageType(10);
                 chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
                 DispatchMessage.dispatchMsgToAll(chatMsg);
@@ -141,59 +148,6 @@ public enum LootManager {
         boolean hotzoneWasRan = false;
         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
         Zone zone = ZoneManager.findSmallestZone(mob.loc);
         for (BootySetEntry bse : entries) {
@@ -268,32 +222,6 @@ public enum LootManager {
     }
 
     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;
-
         int roll = ThreadLocalRandom.current().nextInt(static_rune_ids.size() + 1);
         int itemId = static_rune_ids.get(0);
         try {
@@ -377,7 +305,7 @@ public enum LootManager {
         if (itemUUID == 0)
             return null;
 
-        if (ItemBase.getItemBase(itemUUID).getType().ordinal() == Enum.ItemType.RESOURCE.ordinal()) {
+        if (ItemBase.getItemBase(itemUUID).getType().equals(Enum.ItemType.RESOURCE) || ItemBase.getItemBase(itemUUID).getName().equals("Mithril")) {
             if(ThreadLocalRandom.current().nextInt(1,101) < 91)
                 return null; // cut down world drops rates of resources by 90%
             int amount = ThreadLocalRandom.current().nextInt(tableRow.minSpawn, tableRow.maxSpawn + 1);
@@ -446,8 +374,23 @@ public enum LootManager {
             return inItem;
 
         if (prefixMod.action.length() > 0) {
-            inItem.setPrefix(prefixMod.action);
-            inItem.addPermanentEnchantment(prefixMod.action, 0, prefixMod.level, true);
+            String action = prefixMod.action;
+            if(action.equals("PRE-108") || action.equals("PRE-058") || action.equals("PRE-031")){//massive, barons and avatars to be replaced by leg or warlords
+                int roll = ThreadLocalRandom.current().nextInt(1,100);
+                if(inItem.getItemBase().getRange() > 15){
+                    action = "PRE-040";
+                }else {
+                    if (roll > 50) {
+                        //set warlords
+                        action = "PRE-021";
+                    } else {
+                        //set legendary
+                        action = "PRE-040";
+                    }
+                }
+            }
+            inItem.setPrefix(action);
+            inItem.addPermanentEnchantment(action, 0, prefixMod.level, true);
         }
 
         return inItem;
@@ -574,6 +517,10 @@ public enum LootManager {
                 case RESOURCE:
                     return;
             }
+
+            if (ib.getUUID() == 1580021)//mithril
+                return;
+
             toAdd.setIsID(true);
             mob.getCharItemManager().addItemToInventory(toAdd);
         }
@@ -633,6 +580,8 @@ public enum LootManager {
         if (chanceRoll > bse.dropChance)
             return;
 
+        if(bse.itemBase == 1580021)//mithril
+            return;
         MobLoot lootItem = new MobLoot(mob, ItemBase.getItemBase(bse.itemBase), true);
 
         if (lootItem != null) {
@@ -662,17 +611,58 @@ public enum LootManager {
             return;
         switch (ib.getUUID()) {
             case 971070: //wrapped rune
-                ItemBase runeBase = null;
-                int roll = ThreadLocalRandom.current().nextInt(static_rune_ids.size() + 1);
-                int itemId = static_rune_ids.get(0);
-                try {
-                    itemId = static_rune_ids.get(roll);
-                }catch(Exception e){
+                Random random = new Random();
+                int roll = random.nextInt(100);
+                int itemId;
+                ItemBase runeBase;
+                 if (roll >= 90) {
+                //35 or 40
+                     roll = ThreadLocalRandom.current().nextInt(HellgateManager.static_rune_ids_high.size() + 1);
+                     itemId = HellgateManager.static_rune_ids_high.get(0);
+                    try {
+                        itemId = HellgateManager.static_rune_ids_high.get(roll);
+                   } catch (Exception e) {
 
-                }
-                runeBase = ItemBase.getItemBase(itemId);
-                if(runeBase != null) {
-                    winnings = new MobLoot(playerCharacter, runeBase, 1, false);
+                    }
+                  runeBase = ItemBase.getItemBase(itemId);
+                   if (runeBase != null) {
+                       MobLoot rune = new MobLoot(playerCharacter, runeBase, true);
+
+                       if (rune != null)
+                           playerCharacter.getCharItemManager().addItemToInventory(rune);
+                   }
+                } else if (roll >= 65 && roll <= 89) {
+                //30,35 or 40
+                    roll = ThreadLocalRandom.current().nextInt(HellgateManager.static_rune_ids_mid.size() + 1);
+                    itemId = HellgateManager.static_rune_ids_mid.get(0);
+                    try {
+                        itemId = HellgateManager.static_rune_ids_mid.get(roll);
+                   } catch (Exception e) {
+
+                    }
+                    runeBase = ItemBase.getItemBase(itemId);
+                    if (runeBase != null) {
+                        MobLoot rune = new MobLoot(playerCharacter, runeBase, true);
+
+                        if (rune != null)
+                            playerCharacter.getCharItemManager().addItemToInventory(rune);
+                    }
+                 } else {
+                //5-30
+                     roll = ThreadLocalRandom.current().nextInt(HellgateManager.static_rune_ids_low.size() + 1);
+                     itemId = HellgateManager.static_rune_ids_low.get(0);
+                    try {
+                        itemId = HellgateManager.static_rune_ids_low.get(roll);
+                    } catch (Exception ignored) {
+
+                   }
+                   runeBase = ItemBase.getItemBase(itemId);
+                   if (runeBase != null) {
+                       MobLoot rune = new MobLoot(playerCharacter, runeBase, true);
+
+                        if (rune != null)
+                            playerCharacter.getCharItemManager().addItemToInventory(rune);
+                    }
                 }
                 break;
             case 971012: //wrapped glass
@@ -763,7 +753,7 @@ public enum LootManager {
         ItemBase ib = ItemBase.getItemBase(selectedItem.cacheID);
         if(ib.getUUID() == Warehouse.coalIB.getUUID()){
             //no more coal, give gold instead
-            if (itemMan.getGoldInventory().getNumOfItems() + 250000 > 10000000) {
+            if (itemMan.getGoldInventory().getNumOfItems() + 250000 > MBServerStatics.PLAYER_GOLD_LIMIT) {
                 ErrorPopupMsg.sendErrorPopup(playerCharacter, 21);
                 return;
             }
@@ -941,8 +931,8 @@ public enum LootManager {
         }
 
         //present drop chance for all
-        if (ThreadLocalRandom.current().nextInt(100) < 35)
-            DropPresent(mob);
+        //if (ThreadLocalRandom.current().nextInt(100) < 35)
+        //    DropPresent(mob);
 
         //random contract drop chance for all
         if (ThreadLocalRandom.current().nextInt(100) < 40) {

src/engine/gameManager/LoreMineManager.java

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

src/engine/gameManager/MovementManager.java

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

src/engine/gameManager/PowersManager.java

@@ -28,7 +28,6 @@ import engine.net.client.ClientConnection;
 import engine.net.client.msg.*;
 import engine.objects.*;
 import engine.powers.*;
-import engine.powers.effectmodifiers.AbstractEffectModifier;
 import engine.powers.poweractions.AbstractPowerAction;
 import engine.powers.poweractions.TrackPowerAction;
 import engine.server.MBServerStatics;
@@ -170,11 +169,14 @@ public enum PowersManager {
         if(pc == null)
             return;
 
+        if(pc.getRecycleTimers().containsKey(msg.getPowerUsedID())) {
+            return;
+        }
         if(!pc.isFlying() && powersBaseByToken.get(msg.getPowerUsedID()) != null && powersBaseByToken.get(msg.getPowerUsedID()).isSpell) //cant be sitting if flying
             CombatManager.toggleSit(false,origin);
 
-        if(pc.isMoving())
-            pc.stopMovement(pc.getMovementLoc());
+        //if(pc.isMoving())
+            //pc.stopMovement(pc.getMovementLoc());
         if(msg.getPowerUsedID() != 421084024 && origin.getPlayerCharacter().getPromotionClassID() != 2513) {
             if (!origin.getPlayerCharacter().getPowers().containsKey(msg.getPowerUsedID())) {
                 Logger.error(origin.getPlayerCharacter().getFirstName() + " attempted to cast a power they do not have");
@@ -245,6 +247,12 @@ public enum PowersManager {
         if (playerCharacter == null)
             return false;
 
+        //if(playerCharacter.getRecycleTimers().containsKey(msg.getPowerUsedID())){
+       //     playerCharacter.setIsCasting(false);
+        //    playerCharacter.setItemCasting(false);
+        //    return false;
+        //}
+
         boolean CSRCast = false;
 
         if(msg.getPowerUsedID() == 430628895) {
@@ -846,6 +854,19 @@ public enum PowersManager {
     // called when a spell finishes casting. perform actions
     public static void finishUsePower(final PerformActionMsg msg, PlayerCharacter playerCharacter, int casterLiveCounter, int targetLiveCounter) {
 
+       // if(true) {
+        //    newFinishCast(msg);
+        //    return;
+        //}
+
+        //if(HandleItemEnchantments(playerCharacter, msg)) {
+        //    playerCharacter.setIsCasting(false);
+        //    PerformActionMsg castMsg = new PerformActionMsg(msg);
+        //    castMsg.setNumTrains(9999);
+        //    castMsg.setUnknown04(2);
+        //    DispatchMessage.dispatchMsgToInterestArea(playerCharacter, castMsg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
+        //    return;
+        //}
         PerformActionMsg performActionMsg;
         Dispatch dispatch;
 
@@ -1085,6 +1106,13 @@ public enum PowersManager {
 
             //Player didn't miss power, send finish cast. Miss cast already sent.
 
+            //if (playerCharacter.isBoxed) {
+            //    if (AbstractCharacter.IsAbstractCharacter(target)) {
+            //        if (target.getObjectType().equals(GameObjectType.PlayerCharacter)) {
+            //            return;
+             //       }
+             //   }
+            //}
 
             // finally Apply actions
             for (ActionsBase ab : pb.getActions()) {
@@ -1094,7 +1122,7 @@ public enum PowersManager {
                     continue;
                 // If something blocks the action, then stop
 
-                if (ab.blocked(target, pb, trains)) {
+                if (ab.blocked(target, pb, trains, playerCharacter)) {
 
                     PowersManager.sendEffectMsg(playerCharacter, 5, ab, pb);
                     continue;
@@ -1281,7 +1309,7 @@ public enum PowersManager {
                     continue;
                 // If something blocks the action, then stop
 
-                if (ab.blocked(target, pb, trains))
+                if (ab.blocked(target, pb, trains, caster))
                     continue;
                 // TODO handle overwrite stack order here
                 String stackType = ab.getStackType();
@@ -1482,7 +1510,7 @@ public enum PowersManager {
         // Handle Accepting or Denying a summons.
         // set timer based on summon type.
         boolean wentThrough = false;
-        if (msg.accepted())
+        if (msg.accepted()) {
             // summons accepted, let's move the player if within time
             if (source.isAlive()) {
 
@@ -1528,14 +1556,14 @@ public enum PowersManager {
                     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())){
+                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())
+                if (enemiesNear && !pc.isInSafeZone())
                     duration += 60000;
 
                 // Teleport to summoners location
@@ -1546,7 +1574,10 @@ public enum PowersManager {
                     timers.put("Summon", jc);
                 wentThrough = true;
             }
-
+        }else{
+            // recycle summons power
+            finishRecycleTime(428523680, source, true);
+        }
         // Summons failed
         if (!wentThrough)
             // summons refused. Let's be nice and reset recycle timer
@@ -1835,6 +1866,10 @@ public enum PowersManager {
     private static void applyPowerA(AbstractCharacter ac, AbstractWorldObject target,
                                     Vector3fImmutable targetLoc, PowersBase pb, int trains,
                                     boolean fromItem) {
+
+        if(fromItem && pb.token == 429021400)
+            trains = 40;
+
         int time = pb.getCastTime(trains);
         if (!fromItem)
             finishApplyPowerA(ac, target, targetLoc, pb, trains, false);
@@ -1893,6 +1928,18 @@ public enum PowersManager {
     public static void finishApplyPowerA(AbstractCharacter ac,
                                          AbstractWorldObject target, Vector3fImmutable targetLoc,
                                          PowersBase pb, int trains, boolean fromChant) {
+
+
+        //if (ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
+         //   PlayerCharacter pc = (PlayerCharacter) ac;
+         //   if (pc.isBoxed && pb.token != -2133617927) {
+         //       if(AbstractCharacter.IsAbstractCharacter(target)){
+         //           if (target.getObjectType().equals(GameObjectType.PlayerCharacter)){
+         //               return;
+         //           }
+        //        }
+        //    }
+        //}
         // finally Apply actions
         ArrayList<ActionsBase> actions = pb.getActions();
         for (ActionsBase ab : actions) {
@@ -1900,7 +1947,7 @@ public enum PowersManager {
             if (trains < ab.getMinTrains() || trains > ab.getMaxTrains())
                 continue;
             // If something blocks the action, then stop
-            if (ab.blocked(target, pb, trains))
+            if (ab.blocked(target, pb, trains, ac))
                 // sendPowerMsg(pc, 5, msg);
                 continue;
             // TODO handle overwrite stack order here
@@ -1976,31 +2023,9 @@ public enum PowersManager {
     public static void runPowerAction(AbstractCharacter source, AbstractWorldObject awo, Vector3fImmutable targetLoc, ActionsBase ab, int trains, PowersBase pb) {
         AbstractPowerAction pa = ab.getPowerAction();
         if (pa == null) {
-            Logger.error(
-                    "runPowerAction(): PowerAction not found of IDString: "
-                            + ab.getEffectID());
+            Logger.error("runPowerAction(): PowerAction not found of IDString: " + ab.getEffectID());
             return;
         }
-
-        if(AbstractCharacter.IsAbstractCharacter(awo)) {
-            try {
-                boolean immune = false;
-                AbstractCharacter absChar = (AbstractCharacter) awo;
-                for (AbstractEffectModifier mod : ab.getPowerAction().getEffectsBase().getModifiers()) {
-                    if (absChar.getBonuses() != null) {
-                        if (absChar.getBonuses().getBool(ModType.ImmuneTo, mod.sourceType) || absChar.getBonuses().getBool(ModType.NoMod, mod.sourceType))
-                            immune = true;
-                    }
-                }
-
-                if (immune)
-                    return;
-            }catch(Exception e){
-
-            }
-        }
-
-
         pa.startAction(source, awo, targetLoc, trains, ab, pb);
     }
 
@@ -3106,6 +3131,70 @@ public enum PowersManager {
         }
         return true;
     }
+
+    public static boolean HandleItemEnchantments(PlayerCharacter pc, PerformActionMsg msg){
+        switch(msg.getPowerUsedID()){
+            case 429505998: // Reinforce Item
+            case 429407694: // hone weapon
+            case 429440462: // hone armor
+            case 429016905: //poison blade
+            case 429505610: // poison blade
+            case 427908971: // consecrate weapon
+            case 429439055: // mark of slaying
+            case 429605702: // annoint blade
+            case 429414682: // slay rat
+            case 429594877: // consecrate weapon
+            case 429440895: // charm of slaying
+            case 429491437: // infuse with power
+                PowersBase pb = PowersManager.getPowerByToken(msg.getPowerUsedID());
+                if(pb == null)
+                    return false;
+                for (ActionsBase action : pb.getActions()){
+                    try {
+                        if(msg.getNumTrains() > action.maxTrains)
+                            continue;
+                        EffectsBase eb = action.getPowerAction().getEffectsBase();
+                        if(eb == null)
+                            return false;
+                        //Effect eff = pc.addEffectNoTimer(eb.getName(),eb,msg.getNumTrains(),false);
+                        //if(eff == null){
+                        //    Logger.error(pc.getFirstName() + " failed to apply self buff: " + msg.getPowerUsedID());
+                        //}
+
+                        UsePowerJob asj = new UsePowerJob(pc,msg,pb.getToken(),pb,pc.getLiveCounter(),pc.getLiveCounter());
+
+                        JobContainer jc = JobScheduler.getInstance().scheduleJob(asj, 1800000);
+                        Effect eff = new Effect(jc, eb, msg.getNumTrains());
+                       // pc.effects.put("CASTABLE", eff);
+                        pc.addEffect("CASTABLE",1800,asj,eb,msg.getNumTrains());
+                        pc.applyAllBonuses();
+
+                        ApplyEffectMsg pum = new ApplyEffectMsg();
+                        pum.setEffectID(eff.getEffectToken());
+                        pum.setSourceType(pc.getObjectType().ordinal());
+                        pum.setSourceID(pc.getObjectUUID());
+                        pum.setTargetType(pc.getObjectType().ordinal());
+                        pum.setTargetID(pc.getObjectUUID());
+                        pum.setNumTrains(eff.getTrains());
+                        pum.setUnknown05(1);
+                        pum.setUnknown02(2);
+                        pum.setUnknown06((byte) 1);
+                        pum.setEffectSourceType(GameObjectType.PlayerCharacter.ordinal());
+                        pum.setEffectSourceID(pc.getObjectUUID());
+                        pum.setDuration(1800);
+
+
+                        DispatchMessage.dispatchMsgToInterestArea(pc, pum, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
+                    }
+                    catch(Exception e){
+
+                    }
+                }
+                return true;
+        }
+        return false;
+    }
+
 }
 
 

src/engine/gameManager/SimulationManager.java

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

src/engine/gameManager/SpecialLootHandler.java

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

src/engine/gameManager/ZergManager.java

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

src/engine/jobs/PersistentAoeJob.java

@@ -45,6 +45,13 @@ public class PersistentAoeJob extends AbstractEffectJob {
         if (this.aej == null || this.source == null || this.action == null || this.power == null || this.source == null || this.eb == null)
             return;
 
+        try {
+            if (!this.target.isAlive())
+                PowersManager.finishEffectTime(this.source, this.target, this.action, this.trains);
+        }catch(Exception e){
+            PowersManager.finishEffectTime(this.source, this.target, this.action, this.trains);
+        }
+
         if (!this.source.isAlive())
             PowersManager.finishEffectTime(this.source, this.target, this.action, this.trains);
         else if (this.iteration < this.power.getChantIterations()) {

src/engine/mobileAI/Behaviours/StandardMob.java

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

src/engine/mobileAI/MobAI.java

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

src/engine/mobileAI/utilities/CombatUtilities.java

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

src/engine/mobileAI/utilities/MovementUtilities.java

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

src/engine/net/client/ClientMessagePump.java

@@ -571,6 +571,11 @@ public class ClientMessagePump implements NetMsgHandler {
             return;
 
         if (i.isCanDestroy()) {
+
+            if (i.getItemBase().isRune() && !sourcePlayer.isInSafeZone()) {
+                ChatManager.chatSystemInfo(sourcePlayer, "You May Only Delete Runes In A Safe Zone.");
+                return;
+            }
             int goldValue = i.getBaseValue();
             if (i.getItemBase().isRune())
                 goldValue = 500000;
@@ -578,7 +583,7 @@ public class ClientMessagePump implements NetMsgHandler {
             if (i.getItemBaseID() == 980066)
                 goldValue = 0;
 
-            if(itemManager.getGoldInventory().getNumOfItems() + goldValue > 10000000)
+            if(itemManager.getGoldInventory().getNumOfItems() + goldValue > MBServerStatics.PLAYER_GOLD_LIMIT)
                 return;
 
             if (itemManager.delete(i)) {
@@ -792,6 +797,8 @@ public class ClientMessagePump implements NetMsgHandler {
         if (item == null)
             return;
 
+        item.stripCastableEnchants();
+
         if (item.lootLock.tryLock()) {
             try {
                 Item itemRet = null;
@@ -1287,7 +1294,7 @@ public class ClientMessagePump implements NetMsgHandler {
 
                 cost *= profit;
 
-                if (gold.getNumOfItems() + cost > 10000000) {
+                if (gold.getNumOfItems() + cost > MBServerStatics.PLAYER_GOLD_LIMIT) {
                     return;
                 }
 
@@ -1480,6 +1487,7 @@ public class ClientMessagePump implements NetMsgHandler {
                                 if (buy != null) {
                                     me.transferEnchants(buy);
                                     itemMan.addItemToInventory(buy);
+                                    buy.stripCastableEnchants();
                                     if(npc.contractUUID == 900 && buy.getItemBaseID() == 1705032){
                                         buy.setNumOfItems(10);
                                         DbManager.ItemQueries.UPDATE_NUM_ITEMS(buy,buy.getNumOfItems());

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

@@ -415,6 +415,8 @@ public class ItemProductionMsgHandler extends AbstractClientMsgHandler {
             if (player.getCharItemManager().hasRoomInventory(targetItem.getItemBase().getWeight()) == false)
                 return;
 
+            targetItem.stripCastableEnchants();
+
             player.getCharItemManager().buyFromNPC(targetItem, vendor);
 
         }

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

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

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

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

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

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

src/engine/objects/AbstractCharacter.java

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

src/engine/objects/AbstractGameObject.java

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

src/engine/objects/Building.java

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

src/engine/objects/CharacterItemManager.java

@@ -1510,6 +1510,8 @@ public class CharacterItemManager {
         if (purchasedItem == null || npc == null)
             return false;
 
+        purchasedItem.stripCastableEnchants();
+
         itemMan = npc.getCharItemManager();
 
         if (itemMan == null)
@@ -2351,7 +2353,7 @@ public class CharacterItemManager {
         }
 
 
-        if (this.getGoldInventory().getNumOfItems() + goldFrom2 > 10000000) {
+        if (this.getGoldInventory().getNumOfItems() + goldFrom2 > MBServerStatics.PLAYER_GOLD_LIMIT) {
             PlayerCharacter pc = (PlayerCharacter) this.absCharacter;
             if (pc.getClientConnection() != null)
                 ErrorPopupMsg.sendErrorPopup(pc, 202);
@@ -2359,7 +2361,7 @@ public class CharacterItemManager {
         }
 
 
-        if (tradingWith.getGoldInventory().getNumOfItems() + goldFrom1 > 10000000) {
+        if (tradingWith.getGoldInventory().getNumOfItems() + goldFrom1 > MBServerStatics.PLAYER_GOLD_LIMIT) {
             PlayerCharacter pc = (PlayerCharacter) tradingWith.absCharacter;
             if (pc.getClientConnection() != null)
                 ErrorPopupMsg.sendErrorPopup(pc, 202);

src/engine/objects/CharacterTitle.java

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

src/engine/objects/City.java

@@ -382,6 +382,12 @@ public class City extends AbstractWorldObject {
             if (ago.getObjectType().equals(GameObjectType.City)) {
                 City city = (City) ago;
 
+                if(city == null)
+                    continue;
+
+                if(city.getTOL() != null && city.getTOL().getRank() < 0)
+                    continue;
+
                 if (city.noTeleport)
                     continue;
 

src/engine/objects/Contract.java

@@ -591,10 +591,10 @@ public class Contract extends AbstractGameObject {
             for(MobEquipment me : this.sellInventory){
                 switch(me.getItemBase().getUUID()) {
                     case 971070:
-                        me.magicValue = 3000000;
+                        me.magicValue = 2000000;
                         break;
                     case 971012:
-                        me.magicValue = 1000000;
+                        me.magicValue = 500000;
                         break;
                 }
             }

src/engine/objects/Effect.java

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

src/engine/objects/ItemBase.java

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

src/engine/objects/ItemFactory.java

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

src/engine/objects/Mine.java

@@ -18,6 +18,7 @@ import engine.math.Vector3fImmutable;
 import engine.net.ByteBufferWriter;
 import engine.net.client.msg.ErrorPopupMsg;
 import engine.server.MBServerStatics;
+import org.joda.time.DateTime;
 import org.pmw.tinylog.Logger;
 
 import java.net.UnknownHostException;
@@ -29,6 +30,7 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ThreadLocalRandom;
 
 import static engine.gameManager.DbManager.MineQueries;
 import static engine.gameManager.DbManager.getObject;
@@ -67,6 +69,12 @@ public class Mine extends AbstractGameObject {
     public HashMap<Integer,Integer> oldBuildings;
     public HashMap<Integer, Long> mineAttendees = new HashMap<>();
 
+    public ZergTracker zergTracker;
+
+    public Long allowed_teleport_time;
+    public Boolean enforceLore = false;
+    public HashMap<Guild, Enum.GuildType> chosen_charters;
+
     /**
      * ResultSet Constructor
      */
@@ -125,12 +133,31 @@ public class Mine extends AbstractGameObject {
         this.openHour = rs.getInt("mineLiveHour");
         this.openMinute = rs.getInt("mineLiveMinute");
         this.capSize = rs.getInt("capSize");
+
+        //uncomment this for weekend 5s in lieu of 3s
+        //int loggedCapSize = rs.getInt("capSize");
+        //if(loggedCapSize == 3){
+        //    int dayOfWeek = DateTime.now().dayOfWeek().get();
+        //    if(dayOfWeek == 7 || dayOfWeek == 6 || dayOfWeek == 5){
+        //        this.capSize = 5;
+        //    }else{
+       //         this.capSize = loggedCapSize;
+        //    }
+        //}else{
+        //    this.capSize = loggedCapSize;
+        //}
+
         this.liveTime = LocalDateTime.now().withHour(this.openHour).withMinute(this.openMinute);
         Building tower = BuildingManager.getBuildingFromCache(this.buildingID);
         if(tower != null){
             tower.setMaxHitPoints(5000f * this.capSize);
             tower.setCurrentHitPoints(tower.healthMax);
         }
+        this.allowed_teleport_time = System.currentTimeMillis();
+
+        //decide if lore or not
+        this.enforceLore = false;
+        //this.enforceLore = ThreadLocalRandom.current().nextInt(1,5) == 2;
     }
 
     public static void releaseMineClaims(PlayerCharacter playerCharacter) {
@@ -207,12 +234,12 @@ public class Mine extends AbstractGameObject {
             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("");
+            if(mine.enforceLore){
+                writer.putString(mine.mineType.name);
+                writer.putString(mine.capSize + " Man LORE");
             }else {
                 writer.putString(mine.mineType.name);
-                writer.putString(mine.capSize + " Man ");
+                writer.putString(mine.capSize + " Man ARAC");
             }
             //writer.putString(mine.zoneName + " " + mine.capSize + " Man ");
 
@@ -339,7 +366,7 @@ public class Mine extends AbstractGameObject {
     public static ArrayList<Mine> getMinesToTeleportTo(PlayerCharacter player) {
         ArrayList<Mine> mines = new ArrayList<>();
         for(Mine mine : Mine.getMines())
-            if(!mine.isActive)
+            if(!mine.isActive && System.currentTimeMillis() > mine.allowed_teleport_time)
                 if(mine.getOwningGuild() != null)
                   if(mine.getOwningGuild().getNation().equals(player.getGuild().getNation()))
                       if(!mine.getOwningGuild().equals(Guild.getErrantGuild()))
@@ -425,6 +452,7 @@ public class Mine extends AbstractGameObject {
                     //something went wrong resetting zerg multiplier, maybe player was deleted?
                 }
             }
+            this.allowed_teleport_time = System.currentTimeMillis() + MBServerStatics.FIVE_MINUTES;
         }
     }
 
@@ -596,16 +624,16 @@ public class Mine extends AbstractGameObject {
         int amount = 0;
         switch(this.capSize){
             case 3:
-                amount = 1800000;
-                break;
-            case 5:
                 amount = 3000000;
                 break;
+            case 5:
+                amount = 4200000;
+                break;
             case 10:
-                amount = 6000000;
+                amount = 7200000;
                 break;
             case 20:
-                amount = 12000000;
+                amount = 13200000;
                 break;
         }
         if(this.production.UUID == 7)
@@ -641,6 +669,11 @@ public class Mine extends AbstractGameObject {
                 ChatManager.chatSystemInfo(player,"You Have Entered an Active Mine Area");
             }
             Guild nation = player.guild.getNation();
+
+            if(this.enforceLore){
+                LoreMineManager.AuditPlayer(player, this);
+            }
+
             if(charactersByNation.containsKey(nation)){
                 if(!charactersByNation.get(nation).contains(player)) {
                     charactersByNation.get(nation).add(player);
@@ -673,7 +706,11 @@ public class Mine extends AbstractGameObject {
         for(Guild nation : updatedNations){
             float multiplier = ZergManager.getCurrentMultiplier(charactersByNation.get(nation).size(),this.capSize);
             for(PlayerCharacter player : charactersByNation.get(nation)){
-                player.ZergMultiplier = multiplier;
+                if(this.capSize == 3 && player.getPromotionClassID() == 2519) {
+                    player.ZergMultiplier = 0.0f; // priest gets 100% debuff at 3 man mines
+                }else{
+                    player.ZergMultiplier = multiplier;
+                }
             }
         }
         try

src/engine/objects/Mob.java

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

src/engine/objects/MobBase.java

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

src/engine/objects/MobEquipment.java

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

src/engine/objects/PlayerCharacter.java

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

src/engine/objects/PlayerCombatStats.java

@@ -6,6 +6,7 @@ import engine.powers.EffectsBase;
 import engine.powers.PowersBase;
 import engine.powers.effectmodifiers.AbstractEffectModifier;
 import engine.server.MBServerStatics;
+import org.pmw.tinylog.Logger;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
@@ -384,15 +385,19 @@ public class PlayerCombatStats {
                     }
                 }
             } else {
-                for (AbstractEffectModifier mod : this.owner.effects.get(effID).getEffectModifiers()) {
-                    if (mod.modType.equals(Enum.ModType.OCV)) {
-                        if(mod.getPercentMod() == 0) {
-                            float value = mod.getMinMod();
-                            int trains = this.owner.effects.get(effID).getTrains();
-                            float modValue = value + (trains * mod.getRamp());
-                            atrEnchants += modValue;
+                try {
+                    for (AbstractEffectModifier mod : this.owner.effects.get(effID).getEffectModifiers()) {
+                        if (mod.modType.equals(Enum.ModType.OCV)) {
+                            if (mod.getPercentMod() == 0) {
+                                float value = mod.getMinMod();
+                                int trains = this.owner.effects.get(effID).getTrains();
+                                float modValue = value + (trains * mod.getRamp());
+                                atrEnchants += modValue;
+                            }
                         }
                     }
+                }catch(Exception e){
+                    //Logger.error(e.getMessage());
                 }
             }
         }
@@ -434,16 +439,35 @@ public class PlayerCombatStats {
 
             atr *= 1.0f + stanceValue;
         if(this.owner.bonuses != null) {
-            float positivePercentBonuses = this.owner.bonuses.getFloatPercentPositive(Enum.ModType.OCV, Enum.SourceType.None) - stanceValue;
-            float negativePercentBonuses = this.owner.bonuses.getFloatPercentNegative(Enum.ModType.OCV, Enum.SourceType.None);
-            float modifier = 1 + (positivePercentBonuses + negativePercentBonuses);
+
+
+
+
+            //float positivePercentBonuses = this.owner.bonuses.getFloatPercentPositive(Enum.ModType.OCV, Enum.SourceType.None) - stanceValue;
+            //float negativePercentBonuses = this.owner.bonuses.getFloatPercentNegative(Enum.ModType.OCV, Enum.SourceType.None);
+            //float modifier = 1 + (positivePercentBonuses + negativePercentBonuses);
+            float modifier = this.owner.bonuses.getFloatPercentAll(Enum.ModType.OCV, Enum.SourceType.None);
             if(preciseRune > 1.0f)
                 modifier -= 0.05f;
-            if(stanceValue > 0.0f){
+            if(stanceValue != 0.0f){
                 modifier -= (stanceValue);
             }
             modifier -= healerDefStance;
-            atr *= modifier;
+            modifier += 1.0f;
+            float weaponMoveBonus = 0.0f;
+            if(this.owner.effects != null){
+                if(this.owner.effects.containsKey("WeaponMove")){
+                    Effect eff = this.owner.effects.get("WeaponMove");
+                    for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                        if(mod.modType.equals(Enum.ModType.OCV)){
+                            float min = mod.getPercentMod();
+                            float ramp = mod.getRamp() * eff.getTrains();
+                            weaponMoveBonus += (min + ramp) * 0.01f;
+                        }
+                    }
+                }
+            }
+            atr *= modifier - weaponMoveBonus;
         }
             atr = (float) Math.round(atr);
 
@@ -1056,15 +1080,28 @@ public class PlayerCombatStats {
         atr += (modifiedDexterity * 0.5f) + weaponATR1 + weaponATR2;
         atr *= precise;
         atr += atrBuffs;
-        if(pc.getWeaponPower() != null){
-            DeferredPowerJob dpj = pc.getWeaponPower();
-            dpj.endEffect();
+
+        float weaponMoveBonus = 0.0f;
+        if(pc.effects != null){
+            if(pc.effects.containsKey("WeaponMove")){
+                Effect eff = pc.effects.get("WeaponMove");
+                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                    if(mod.modType.equals(Enum.ModType.OCV)){
+                        float min = mod.getPercentMod();
+                        float ramp = mod.getRamp() * eff.getTrains();
+                        weaponMoveBonus += (min + ramp) * 0.01f;
+                    }
+                }
+            }
         }
 
+        float subtraction = (stanceMod - 1) - (precise - 1) - healerDefStance;
+        float bonuses = 0.0f;
         if(pc.bonuses != null)
-            atr *= 1 + (pc.bonuses.getFloatPercentAll(Enum.ModType.OCV, Enum.SourceType.None) - (stanceMod - 1) - (precise - 1) - healerDefStance);
+            bonuses = pc.bonuses.getFloatPercentAll(Enum.ModType.OCV, Enum.SourceType.None) - subtraction - weaponMoveBonus;
 
-        atr *= stanceMod;
+        atr *= 1+ bonuses;
+        atr *= stanceMod - healerDefStance;
         return atr;
     }
 

src/engine/objects/ZergTracker.java

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

src/engine/powers/ActionsBase.java

@@ -9,6 +9,8 @@
 
 package engine.powers;
 
+import com.sun.corba.se.spi.orbutil.fsm.ActionBase;
+import engine.Enum;
 import engine.Enum.ModType;
 import engine.Enum.SourceType;
 import engine.Enum.StackType;
@@ -237,32 +239,86 @@ public class ActionsBase {
     }
 
     //Add blocked types here
-    public boolean blocked(AbstractWorldObject awo, PowersBase pb, int trains) {
+    public boolean blocked(AbstractWorldObject awo, PowersBase pb, int trains, AbstractCharacter source) {
+
+        if(!pb.getName().contains("Summon")) {
+            if (AbstractWorldObject.IsAbstractCharacter(awo)) {
+                AbstractCharacter target = (AbstractCharacter) awo;
+                if (source.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {
+                    PlayerCharacter pc = (PlayerCharacter) source;
+                    if (target.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {
+                        if (pc.isBoxed && pc.getObjectUUID() != target.getObjectUUID()) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+
+        if(pb.isChant)
+            return false;
+
         if (AbstractWorldObject.IsAbstractCharacter(awo)) {
             AbstractCharacter ac = (AbstractCharacter) awo;
+
+            if(ac.effects.containsKey(this.stackType)) {
+                Boolean sameRank = false;
+                Effect eff = ac.effects.get(this.stackType);
+
+                String currentEffect = eff.getEffectsBase().getIDString();
+                String newEffect = this.effectID;
+                if (currentEffect.equals(newEffect) && !this.stackType.equals("Stun"))
+                    return false;
+
+                if (eff != null) {
+                    for (ActionsBase action : eff.getPower().getActions()) {
+                        if (this.stackType.equals(action.stackType) && this.stackOrder == action.stackOrder) {
+                            if (this.stackType.equals("NoStun")) {
+                                return true;
+                            }
+                        }
+
+                        if (sameRank) {
+                            if (this.greaterThan && trains <= eff.getTrains())
+                                return true;
+
+                            if (this.greaterThanEqual && trains < eff.getTrains())
+                                return true;
+                        }
+                    }
+                }
+            }
             PlayerBonuses bonus = ac.getBonuses();
             if (bonus == null)
                 return false;
 
-            //TODO make this more efficient then testing strings
-            if (this.stackType.equals("Stun") && bonus.getBool(ModType.ImmuneTo, SourceType.Stun))
-                return true; //Currently stun immune. Skip stun
-            else if (this.stackType.equals("Snare") && bonus.getBool(ModType.ImmuneTo, SourceType.Snare))
-                return true; //Currently snare immune. Skip snare
-            else if (this.stackType.equals("Blindness") && bonus.getBool(ModType.ImmuneTo, SourceType.Blind))
-                return true; //Currently blind immune. Skip blind
-            else if (this.stackType.equals("PowerInhibitor") && bonus.getBool(ModType.ImmuneTo, SourceType.Powerblock))
-                return true; //Currently power block immune. Skip power block
-            else if (this.stackType.equals("Root") && bonus.getBool(ModType.ImmuneTo, SourceType.Root))
+            SourceType sourceType = null;
+            try {
+                sourceType = SourceType.GetSourceType(this.stackType);
+            }catch(Exception ignored){
+
+            }
+            if(sourceType != null && (bonus.getBool(ModType.ImmuneTo,sourceType) || bonus.getBool(ModType.NoMod,sourceType)))
                 return true;
-                //			else if (pb.isHeal() && (bonus.getByte("immuneTo.Heal")) >= trains)
-                //				return true; //Currently shadowmantled. Skip heals
-            else if (this.stackType.equals("Flight") && bonus.getBool(ModType.NoMod, SourceType.Fly))
+            if(ac.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)){
+                PlayerCharacter pc = (PlayerCharacter)ac;
+                if(this.stackType.equals("Blindness") && pc.getRace().getName().contains("Shade"))
+                    return true;
+                if(this.stackType.equals("Stun") && pc.getRace().getName().contains("Minotaur"))
+                    return true;
+            }
+
+            if(this.stackType.equals("Stun") && bonus.getBool(ModType.ImmuneTo,SourceType.Stun))
                 return true;
-            else if (this.stackType.equals("Track") && bonus.getBool(ModType.CannotTrack, SourceType.None))
+
+            if(pb.vampDrain() && bonus.getBool(ModType.BlockedPowerType, SourceType.VAMPDRAIN))
+                return true;
+
+            if (this.stackType.equals("Track") && bonus.getBool(ModType.CannotTrack, SourceType.None))
+                return true;
+
+            if (this.stackType.equals("PowerInhibitor") && bonus.getBool(ModType.ImmuneTo, SourceType.Powerblock))
                 return true;
-            else
-                return pb.vampDrain() && bonus.getBool(ModType.BlockedPowerType, SourceType.VAMPDRAIN);
         }
         return false;
     }

src/engine/powers/PowersBase.java

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

src/engine/powers/poweractions/StealPowerAction.java

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

src/engine/server/MBServerStatics.java

@@ -33,11 +33,11 @@ public class MBServerStatics {
     // hit box
     // calcs
     public static final boolean PRINT_INCOMING_OPCODES = false; // print
-    public static final int BANK_GOLD_LIMIT = 25000000;
+    public static final int BANK_GOLD_LIMIT = 100000000;
     // incoming
     // opcodes to
     // console
-    public static final int PLAYER_GOLD_LIMIT = 10000000;
+    public static final int PLAYER_GOLD_LIMIT = 50000000;
     // buildings, npcs
     /*
      * Login cache flags
@@ -379,6 +379,7 @@ public class MBServerStatics {
     // Mine related
     public static final int MINE_EARLY_WINDOW = 16; // 4pm
     public static final int MINE_LATE_WINDOW = 0; // Midnight
+    public static final Long THREE_MINUTES = 180000L;
     public static boolean DEBUG_PROTOCOL = false;
     public static int SPATIAL_HASH_BUCKETSX = 16384;
     public static int SPATIAL_HASH_BUCKETSY = 12288;

src/engine/server/world/WorldServer.java

@@ -534,6 +534,9 @@ public class WorldServer {
 		printThreads();
 		Logger.info("Threads Running:");
 
+		Logger.info("Starting Hotzone...");
+		HotzoneManager.SelectRandomHotzone();
+
 		return true;
 	}
 

src/engine/util/KeyCloneAudit.java

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

src/engine/workthreads/HourlyJobThread.java

@@ -36,6 +36,7 @@ public class HourlyJobThread implements Runnable {
 
         ConcurrentHashMap<Integer, AbstractGameObject> map = DbManager.getMap(Enum.GameObjectType.City);
 
+        HotzoneManager.SelectRandomHotzone();
         if (map != null) {
 
             for (AbstractGameObject ago : map.values()) {