city null pointer check

src/engine/Dungeons/Dungeon.java

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

src/engine/Dungeons/DungeonManager.java

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

src/engine/Enum.java

@@ -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;
@@ -2325,7 +2325,8 @@ public class Enum {
 
         GRID(544),
         ZONE(672),
-        PLACEMENT(673);
+        PLACEMENT(673),
+        SIEGEBOUNDS(1750);
 
         public final float extents;
 

src/engine/InterestManagement/InterestManager.java

@@ -511,6 +511,18 @@ public enum InterestManager implements Runnable {
         if (player == null)
             return;
 
+        //for(PlayerCharacter pc : SessionManager.getAllActivePlayerCharacters()){
+        //    if(pc.equals(player)){
+        //        try{
+        //            WorldGrid.RemoveWorldObject(player);
+        //        }catch(Exception e){
+
+        //        }
+        //    }
+        //}
+
+
+
         ClientConnection origin = player.getClientConnection();
 
         if (origin == null)

src/engine/db/handlers/dbAccountHandler.java

@@ -19,10 +19,7 @@ import engine.objects.Account;
 import engine.objects.PlayerCharacter;
 import org.pmw.tinylog.Logger;
 
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
+import java.sql.*;
 import java.util.ArrayList;
 
 public class dbAccountHandler extends dbHandlerBase {
@@ -278,4 +275,21 @@ public class dbAccountHandler extends dbHandlerBase {
         }
     }
 
+    public void TRASH_CHEATERS() {
+        try (Connection connection = DbManager.getConnection();
+             CallableStatement callableStatement = connection.prepareCall("{CALL BanAccountsWithMachineID()}")) {
+
+            boolean hasResultSet = callableStatement.execute();
+
+            if (!hasResultSet && callableStatement.getUpdateCount() > 0) {
+                Logger.info("TRASHED CHEATERS");
+            } else {
+                Logger.warn("No cheaters to trash.");
+            }
+
+        } catch (SQLException e) {
+            Logger.error("Error trashing cheaters: ", e);
+        }
+    }
+
 }

src/engine/devcmd/cmds/DungenonCmd.java

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

src/engine/gameManager/ArenaManager.java

@@ -18,6 +18,8 @@ public class ArenaManager {
     public static Long pulseDelay = 180000L;
     public static Long lastExecution = 0L;
 
+    public static float arena_radius = 500f;
+
     public static void pulseArenas() {
         if(lastExecution == 0L){
             lastExecution = System.currentTimeMillis();
@@ -110,13 +112,10 @@ public class ArenaManager {
 
         if(winner != null){
             ChatManager.chatPVP("[ARENA] " + winner.getName() + " has slain " + loser.getName() + " in the arena!");
-            //handle prize distribution
-            //ItemBase specialLoot = ItemBase.getItemBase(866);
-            //Item promoted = new MobLoot(winner, specialLoot, 1, false).promoteToItem(winner);
-            //promoted.setNumOfItems(21235);
-            //promoted.setName("Special Banker(21235)");
-            //DbManager.ItemQueries.UPDATE_NUM_ITEMS(promoted,21235);
-            //winner.getCharItemManager().addItemToInventory(promoted);
+            //handle prize distribution of wrapped rune gift
+            //ItemBase specialLoot = ItemBase.getItemBase(971070);
+            //MobLoot winnings = new MobLoot(winner,specialLoot,false);
+            //winner.getCharItemManager().addItemToInventory(winnings.promoteToItem(winner));
             //winner.getCharItemManager().updateInventory();
         }
     }
@@ -132,7 +131,7 @@ public class ArenaManager {
                 float y = 0; // Y coordinate is always 0
 
                 loc = new Vector3fImmutable(x, y, z * -1);
-                HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(loc,500f, MBServerStatics.MASK_PLAYER);
+                HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(loc,arena_radius, MBServerStatics.MASK_PLAYER);
                 if(inRange.isEmpty() && !isUnderWater(loc))
                     locSet = true;
                 //}

src/engine/gameManager/BaneManager.java

@@ -0,0 +1,45 @@
+package engine.gameManager;
+
+import engine.Enum;
+import engine.objects.Bane;
+import org.joda.time.DateTime;
+
+public class BaneManager {
+
+    public static void default_check(){
+        for(Bane bane : Bane.banes.values()){
+            if(!bane.daySet || !bane.timeSet || !bane.capSet){
+                DateTime placementDate = bane.getPlacementDate();
+                if(DateTime.now().isAfter(placementDate.plusHours(48))){
+                    //set bane for default time
+                    if(!bane.daySet){
+                        bane.daySet = true;
+                        DbManager.BaneQueries.SET_BANE_DAY_NEW(3,bane.getCityUUID());
+                    }
+
+                    if(!bane.timeSet){
+                        bane.timeSet = true;
+                        DbManager.BaneQueries.SET_BANE_TIME_NEW(9,bane.getCityUUID());
+                    }
+
+                    if(!bane.capSet){
+                        bane.capSet = true;
+                        bane.capSize = 20;
+                        DbManager.BaneQueries.SET_BANE_CAP_NEW(20,bane.getCityUUID());
+                    }
+                    bane.setLiveDate(DbManager.BaneQueries.getLiveDate(bane.getCityUUID()));
+                }
+            }
+        }
+    }
+
+    public static void pulse_banes(){
+        //used to pulse the anti-zerg mechanic of active banes
+        for(Bane bane : Bane.banes.values()){
+            if(bane.getSiegePhase().equals(Enum.SiegePhase.WAR)){
+                // bane is live, handle bane anti-zerg mechanic stuff
+                bane.applyZergBuffs();
+            }
+        }
+    }
+}

src/engine/gameManager/CombatManager.java

@@ -8,6 +8,7 @@
 
 package engine.gameManager;
 
+import engine.Enum;
 import engine.Enum.*;
 import engine.exception.MsgSendException;
 import engine.job.JobContainer;
@@ -303,11 +304,15 @@ public enum CombatManager {
             //pet to assist in attacking target
             if(abstractCharacter.getObjectType().equals(GameObjectType.PlayerCharacter)){
                 PlayerCharacter attacker = (PlayerCharacter)abstractCharacter;
+                if(attacker.combatStats == null){
+                    attacker.combatStats = new PlayerCombatStats(attacker);
+                }
                 if(attacker.getPet() != null){
                     Mob pet = attacker.getPet();
                     if(pet.combatTarget == null && pet.assist)
                         pet.setCombatTarget(attacker.combatTarget);
                 }
+
             }
 
 
@@ -326,10 +331,13 @@ public enum CombatManager {
                 else if (!tar.isActive())
                     return 0;
 
-                if (target.getObjectType().equals(GameObjectType.PlayerCharacter) && abstractCharacter.getObjectType().equals(GameObjectType.PlayerCharacter) && abstractCharacter.getTimers().get("Attack" + slot) == null)
+                if (target.getObjectType().equals(GameObjectType.PlayerCharacter) && abstractCharacter.getObjectType().equals(GameObjectType.PlayerCharacter) && abstractCharacter.getTimers().get("Attack" + slot) == null) {
+                    if(((PlayerCharacter)target).combatStats == null){
+                        ((PlayerCharacter)target).combatStats = new PlayerCombatStats(((PlayerCharacter)target));
+                    }
                     if (!((PlayerCharacter) abstractCharacter).canSee((PlayerCharacter) target))
                         return 0;
-
+                }
                 //must not be immune to all or immune to attack
 
                 Resists res = tar.getResists();
@@ -473,6 +481,7 @@ public enum CombatManager {
                 }
             }
 
+            range += 2;
             if (NotInRange(abstractCharacter, target, range)) {
 
                 //target is in stealth and can't be seen by source
@@ -496,6 +505,16 @@ public enum CombatManager {
                 }
             }
 
+            if(abstractCharacter.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                PlayerCharacter pc = (PlayerCharacter)abstractCharacter;
+                if(pc.isBoxed){
+                    if(target.getObjectType().equals(GameObjectType.PlayerCharacter)) {
+                        ChatManager.chatSystemInfo(pc, "You Are PvE Flagged: Cannot Attack Players.");
+                        attackFailure = true;
+                    }
+                }
+            }
+
             //TODO Verify attacker has los (if not ranged weapon).
 
             if (!attackFailure) {
@@ -686,6 +705,9 @@ public enum CombatManager {
             } else {
                 AbstractCharacter tar = (AbstractCharacter) target;
                 if(tar.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                    if(((PlayerCharacter)tar).combatStats == null){
+                        ((PlayerCharacter)tar).combatStats = new PlayerCombatStats((PlayerCharacter)tar);
+                    }
                     ((PlayerCharacter)tar).combatStats.calculateDefense();
                     defense = ((PlayerCharacter)tar).combatStats.defense;
                 }else {
@@ -915,15 +937,22 @@ public enum CombatManager {
                         damage *= 1 + (armorPierce * 0.01f);
                     }
                 }
-
                 //Resists.handleFortitude(tarAc,damageType,damage);
 
                 float d = 0f;
 
+                int originalDamage = (int)damage;
+                if(ac != null && ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                    damage *= ((PlayerCharacter)ac).ZergMultiplier;
+                } // Health modifications are modified by the ZergMechanic
+
                 errorTrack = 12;
 
                 //Subtract Damage from target's health
 
+                if(ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
+                    damage *= ((PlayerCharacter)ac).ZergMultiplier;
+                }
                 if (tarAc != null) {
 
                     if (tarAc.isSit())
@@ -933,9 +962,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();
 
@@ -969,77 +1002,67 @@ public enum CombatManager {
                 errorTrack = 14;
 
                 //handle procs
-
-                if (weapon != null && tarAc != null && tarAc.isAlive()) {
-
-                    if(weapon.effects != null){
-                        for (Effect eff : weapon.effects.values()){
-                            for(AbstractEffectModifier mod : eff.getEffectModifiers()){
-                                if(mod.modType.equals(ModType.WeaponProc)){
-                                    int procChance = ThreadLocalRandom.current().nextInt(100);
-                                    if (procChance < MBServerStatics.PROC_CHANCE) {
-                                        try {
-                                            ((WeaponProcEffectModifier) mod).applyProc(ac, target);
-                                        }catch(Exception e){
-                                            Logger.error(eff.getName() + " Failed To Cast Proc");
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
+                procChanceHandler(weapon,ac,tarAc);
 
                 errorTrack = 15;
 
                 //handle damage shields
 
                 if (ac.isAlive() && tarAc != null && tarAc.isAlive())
-                    handleDamageShields(ac, tarAc, damage);
+                    try {
+                        handleDamageShields(ac, tarAc, damage);
+                    }catch(Exception e){
+                        Logger.error(e.getMessage());
+                    }
 
             } else {
 
                 // Apply Weapon power effect if any.
                 // don't try to apply twice if dual wielding.
+                try {
+                    if (ac.getObjectType().equals(GameObjectType.PlayerCharacter) && (mainHand || wb.isTwoHanded())) {
+                        dpj = ((PlayerCharacter) ac).getWeaponPower();
 
-                if (ac.getObjectType().equals(GameObjectType.PlayerCharacter) && (mainHand || wb.isTwoHanded())) {
-                    dpj = ((PlayerCharacter) ac).getWeaponPower();
+                        if (dpj != null) {
 
-                    if (dpj != null) {
+                            PowersBase wp = dpj.getPower();
 
-                        PowersBase wp = dpj.getPower();
+                            if (wp.requiresHitRoll() == false) {
+                                PlayerBonuses bonus = ac.getBonuses();
+                                float attackRange = getWeaponRange(wb, bonus);
 
-                        if (wp.requiresHitRoll() == false) {
-                            PlayerBonuses bonus = ac.getBonuses();
-                            float attackRange = getWeaponRange(wb, bonus);
-
-                            if(ac.isMoving()){
-                                attackRange += (ac.getSpeed() * 0.1f);
-                            }
-
-                            if(AbstractWorldObject.IsAbstractCharacter(target)) {
-                                AbstractCharacter tarAc = (AbstractCharacter) target;
-                                if(tarAc != null && tarAc.isMoving()){
-                                    attackRange += (tarAc.getSpeed() * 0.1f);
+                                if (ac.isMoving()) {
+                                    attackRange += (ac.getSpeed() * 0.1f);
+                                }
+
+                                if (AbstractWorldObject.IsAbstractCharacter(target)) {
+                                    AbstractCharacter tarAc = (AbstractCharacter) target;
+                                    if (tarAc != null && tarAc.isMoving()) {
+                                        attackRange += (tarAc.getSpeed() * 0.1f);
+                                    }
                                 }
-                            }
 
 
-                            if(specialCaseHitRoll(dpj.getPowerToken())) {
-                                if(hitLanded) {
+                                if (specialCaseHitRoll(dpj.getPowerToken())) {
+                                    if (hitLanded) {
+                                        dpj.attack(target, attackRange);
+                                    }
+                                } else {
                                     dpj.attack(target, attackRange);
                                 }
-                            }else{
-                                dpj.attack(target, attackRange);
-                            }
-                        } else
-                            ((PlayerCharacter) ac).setWeaponPower(null);
+                            } else
+                                ((PlayerCharacter) ac).setWeaponPower(null);
+                        }
                     }
+                }catch(Exception e) {
+                    Logger.error(e.getMessage());
+                }
+                try {
+                    if (target.getObjectType() == GameObjectType.Mob)
+                        ((Mob) target).handleDirectAggro(ac);
+                }catch(Exception e){
+                    Logger.error(e.getMessage());
                 }
-
-                if (target.getObjectType() == GameObjectType.Mob)
-                    ((Mob) target).handleDirectAggro(ac);
-
                 errorTrack = 17;
 
                 //miss, Send miss message
@@ -1062,6 +1085,41 @@ public enum CombatManager {
         }
     }
 
+    private static void procChanceHandler(Item weapon, AbstractCharacter ac, AbstractCharacter tarAc) {
+
+        //no weapon means no proc
+        if(weapon == null)
+            return;
+
+        //caster is dead of null, no proc
+        if(ac == null || !ac.isAlive())
+            return;
+
+        //target is dead or null, no proc
+        if(tarAc == null || !tarAc.isAlive())
+            return;
+
+        //no effects on weapon, skip proc
+        if(weapon.effects == null || weapon.effects.isEmpty())
+            return;
+
+        for (Effect eff : weapon.effects.values()){
+            for(AbstractEffectModifier mod : eff.getEffectModifiers()) {
+                if (mod.modType.equals(ModType.WeaponProc)) {
+                    int procChance = ThreadLocalRandom.current().nextInt(100);
+                    if (procChance < MBServerStatics.PROC_CHANCE) {
+                        try {
+                            ((WeaponProcEffectModifier) mod).applyProc(ac, tarAc);
+                            break;
+                        } catch (Exception e) {
+                            Logger.error(eff.getName() + " Failed To Cast Proc");
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     public static boolean canTestParry(AbstractCharacter ac, AbstractWorldObject target) {
 
         if (ac == null || target == null || !AbstractWorldObject.IsAbstractCharacter(target))
@@ -1069,12 +1127,6 @@ public enum CombatManager {
 
         AbstractCharacter tar = (AbstractCharacter) target;
 
-        if(target.getObjectType().equals(GameObjectType.PlayerCharacter)){
-            PlayerCharacter pc = (PlayerCharacter) target;
-            if(pc.getRaceID() == 1999)
-                return true;
-        }
-
         CharacterItemManager acItem = ac.getCharItemManager();
         CharacterItemManager tarItem = tar.getCharItemManager();
 
@@ -1086,6 +1138,12 @@ public enum CombatManager {
         Item tarMain = tarItem.getItemFromEquipped(1);
         Item tarOff = tarItem.getItemFromEquipped(2);
 
+        if(target.getObjectType().equals(GameObjectType.PlayerCharacter)){
+            PlayerCharacter pc = (PlayerCharacter) target;
+            if(pc.getRaceID() == 1999 && !isRanged(acMain) && !isRanged(acOff))
+                return true;
+        }
+
         return !isRanged(acMain) && !isRanged(acOff) && !isRanged(tarMain) && !isRanged(tarOff);
     }
 
@@ -1178,10 +1236,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

@@ -85,6 +85,7 @@ public enum DevCmdManager {
         DevCmdManager.registerDevCmd(new AddBuildingCmd());
         DevCmdManager.registerDevCmd(new AddNPCCmd());
         DevCmdManager.registerDevCmd(new AddMobCmd());
+        DevCmdManager.registerDevCmd(new DungenonCmd());
         DevCmdManager.registerDevCmd(new RemoveObjectCmd());
         DevCmdManager.registerDevCmd(new RotateCmd());
         DevCmdManager.registerDevCmd(new FlashMsgCmd());

src/engine/gameManager/ForgeManager.java

@@ -0,0 +1,15 @@
+package engine.gameManager;
+
+import engine.objects.ForgeWorkOrder;
+import engine.objects.NPC;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+public class ForgeManager {
+    public HashMap<NPC, ArrayList<ForgeWorkOrder>> work_orders;
+
+    public static void add_work_order(NPC npc, ForgeWorkOrder workOrder){
+
+    }
+}

src/engine/gameManager/LootManager.java

@@ -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,14 @@ public enum LootManager {
             return;
         }
 
+        if(!mob.getSafeZone()) {
+            SpecialLootHandler.RollContract(mob);
+            SpecialLootHandler.RollGlass(mob);
+            SpecialLootHandler.RollRune(mob);
+            SpecialLootHandler.RollRacialGuard(mob);
+            SpecialLootHandler.ResourceDrop(mob);
+        }
+
         //determine if mob is in hotzone
         boolean inHotzone = false;
 
@@ -127,7 +132,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 +149,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) {
@@ -232,116 +187,6 @@ public enum LootManager {
         }
     }
 
-    public static void SpecialCaseContractDrop(Mob mob,ArrayList<BootySetEntry> entries){
-
-        int lootTableID = 0;
-        for(BootySetEntry entry : entries){
-            if(entry.bootyType.equals("LOOT")){
-                lootTableID = entry.genTable;
-                break;
-            }
-        }
-
-        if(lootTableID == 0)
-            return;
-
-        int ContractTableID = 0;
-        for(GenTableEntry entry : _genTables.get(lootTableID)){
-            try {
-                if (ItemBase.getItemBase(_itemTables.get(entry.itemTableID).get(0).cacheID).getType().equals(Enum.ItemType.CONTRACT)) {
-                    ContractTableID = entry.itemTableID;
-                    break;
-                }
-            }catch(Exception e){
-
-            }
-        }
-
-        if(ContractTableID == 0)
-            return;
-
-        ItemBase ib = ItemBase.getItemBase(rollRandomItem(ContractTableID));
-        if(ib != null){
-            MobLoot toAdd = new MobLoot(mob,ib,false);
-            mob.getCharItemManager().addItemToInventory(toAdd);
-        }
-    }
-
-    public static void SpecialCaseRuneDrop(Mob mob,ArrayList<BootySetEntry> entries){
-        //int lootTableID = 0;
-        //for(BootySetEntry entry : entries){
-        //    if(entry.bootyType.equals("LOOT")){
-        //        lootTableID = entry.genTable;
-        //        break;
-        //    }
-        //}
-
-       // if(lootTableID == 0)
-       //     return;
-
-        //int RuneTableID = 0;
-        //for(GenTableEntry entry : _genTables.get(lootTableID)){
-        //    try {
-        //        if (ItemBase.getItemBase(_itemTables.get(entry.itemTableID).get(0).cacheID).getType().equals(Enum.ItemType.RUNE)) {
-        //            RuneTableID = entry.itemTableID;
-        //            break;
-        //        }
-        //    }catch(Exception e){
-
-        //    }
-        //}
-
-        //if(RuneTableID == 0)
-        //    return;
-
-        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){
-
-        }
-        ItemBase ib = ItemBase.getItemBase(itemId);
-        if(ib != null){
-            MobLoot toAdd = new MobLoot(mob,ib,false);
-            mob.getCharItemManager().addItemToInventory(toAdd);
-        }
-    }
-
-    public static void SpecialCaseResourceDrop(Mob mob,ArrayList<BootySetEntry> entries){
-        int lootTableID = 0;
-        for(BootySetEntry entry : entries){
-            if(entry.bootyType.equals("LOOT")){
-                lootTableID = entry.genTable;
-                break;
-            }
-        }
-
-        if(lootTableID == 0)
-            return;
-
-        int ResourceTableID = 0;
-        for(GenTableEntry entry : _genTables.get(lootTableID)){
-            try {
-                if (ItemBase.getItemBase(_itemTables.get(entry.itemTableID).get(0).cacheID).getType().equals(Enum.ItemType.RESOURCE)) {
-                    ResourceTableID = entry.itemTableID;
-                    break;
-                }
-            }catch(Exception e){
-
-            }
-        }
-
-        if(ResourceTableID == 0)
-            return;
-
-        ItemBase ib = ItemBase.getItemBase(rollRandomItem(ResourceTableID));
-        if(ib != null){
-            MobLoot toAdd = new MobLoot(mob,ib,false);
-            mob.getCharItemManager().addItemToInventory(toAdd);
-        }
-    }
-
     public static MobLoot getGenTableItem(int genTableID, AbstractCharacter mob, Boolean inHotzone) {
 
         if (mob == null || _genTables.containsKey(genTableID) == false)
@@ -377,24 +222,11 @@ public enum LootManager {
         if (itemUUID == 0)
             return null;
 
-        if (ItemBase.getItemBase(itemUUID).getType().ordinal() == Enum.ItemType.RESOURCE.ordinal()) {
-            if(ThreadLocalRandom.current().nextInt(1,101) < 91)
-                return null; // cut down world drops rates of resources by 90%
-            int amount = ThreadLocalRandom.current().nextInt(tableRow.minSpawn, tableRow.maxSpawn + 1);
-            return new MobLoot(mob, ItemBase.getItemBase(itemUUID), amount, false);
-        }
-        if(ItemBase.getItemBase(itemUUID).getType().equals(Enum.ItemType.RUNE)){
-            int randomRune = rollRandomItem(itemTableId);
-            if(randomRune != 0) {
-                itemUUID = randomRune;
-            }
-        } else if(ItemBase.getItemBase(itemUUID).getType().equals(Enum.ItemType.CONTRACT)){
-            int randomContract = rollRandomItem(itemTableId);
-            if(randomContract != 0) {
-                itemUUID = randomContract;
-            }
-        }
-        outItem = new MobLoot(mob, ItemBase.getItemBase(itemUUID), false);
+        ItemBase ib = ItemBase.getItemBase(itemUUID);
+        if (ib == null || ib.getType().equals(Enum.ItemType.RESOURCE) || ib.getName().equals("Mithril") || ib.getType().equals(Enum.ItemType.RUNE) || ib.getType().equals(Enum.ItemType.CONTRACT))
+            return null;
+
+        outItem = new MobLoot(mob, ib, false);
 
         if(selectedRow.pModTable != 0){
             try {
@@ -413,11 +245,6 @@ public enum LootManager {
             }
         }
 
-        if(outItem.getItemBase().getType().equals(Enum.ItemType.CONTRACT) || outItem.getItemBase().getType().equals(Enum.ItemType.RUNE)){
-            if(ThreadLocalRandom.current().nextInt(1,101) < 66)
-                return null; // cut down world drops rates of resources by 65%
-        }
-
         return outItem;
     }
 
@@ -446,8 +273,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 +416,10 @@ public enum LootManager {
                 case RESOURCE:
                     return;
             }
+
+            if (ib.getUUID() == 1580021)//mithril
+                return;
+
             toAdd.setIsID(true);
             mob.getCharItemManager().addItemToInventory(toAdd);
         }
@@ -633,6 +479,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 +510,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(SpecialLootHandler.static_rune_ids_high.size() + 1);
+                     itemId = SpecialLootHandler.static_rune_ids_high.get(0);
+                    try {
+                        itemId = SpecialLootHandler.static_rune_ids_high.get(roll);
+                   } catch (Exception e) {
 
-                }
-                runeBase = ItemBase.getItemBase(itemId);
-                if(runeBase != null) {
-                    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(SpecialLootHandler.static_rune_ids_mid.size() + 1);
+                    itemId = SpecialLootHandler.static_rune_ids_mid.get(0);
+                    try {
+                        itemId = SpecialLootHandler.static_rune_ids_mid.get(roll);
+                   } catch (Exception e) {
+
+                    }
+                    runeBase = ItemBase.getItemBase(itemId);
+                    if (runeBase != null) {
+                        MobLoot rune = new MobLoot(playerCharacter, runeBase, true);
+
+                        if (rune != null)
+                            playerCharacter.getCharItemManager().addItemToInventory(rune.promoteToItem(playerCharacter));
+                    }
+                 } else {
+                //5-30
+                     roll = ThreadLocalRandom.current().nextInt(SpecialLootHandler.static_rune_ids_low.size() + 1);
+                     itemId = SpecialLootHandler.static_rune_ids_low.get(0);
+                    try {
+                        itemId = SpecialLootHandler.static_rune_ids_low.get(roll);
+                    } catch (Exception ignored) {
+
+                   }
+                   runeBase = ItemBase.getItemBase(itemId);
+                   if (runeBase != null) {
+                       MobLoot rune = new MobLoot(playerCharacter, runeBase, true);
+
+                        if (rune != null)
+                            playerCharacter.getCharItemManager().addItemToInventory(rune.promoteToItem(playerCharacter));
+                    }
                 }
                 break;
             case 971012: //wrapped glass
@@ -763,7 +652,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 +830,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/PowersManager.java

@@ -28,6 +28,7 @@ import engine.net.client.ClientConnection;
 import engine.net.client.msg.*;
 import engine.objects.*;
 import engine.powers.*;
+import engine.powers.effectmodifiers.AbstractEffectModifier;
 import engine.powers.poweractions.AbstractPowerAction;
 import engine.powers.poweractions.TrackPowerAction;
 import engine.server.MBServerStatics;
@@ -172,18 +173,33 @@ public enum PowersManager {
         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(msg.getPowerUsedID() == 429429978){
-            applyPower(origin.getPlayerCharacter(),origin.getPlayerCharacter(),origin.getPlayerCharacter().getLoc(),429429978,msg.getNumTrains(),false);
-            origin.getPlayerCharacter().getRecycleTimers().remove(429429978);
+        if(msg.getPowerUsedID() != 421084024 && origin.getPlayerCharacter().getPromotionClassID() != 2513) {
+            if (!origin.getPlayerCharacter().getPowers().containsKey(msg.getPowerUsedID())) {
+                Logger.error(origin.getPlayerCharacter().getFirstName() + " attempted to cast a power they do not have");
+                return;
+            }
+        }
+        //crusader sacrifice
+        if((msg.getPowerUsedID() == 428695403 && msg.getTargetID() == pc.getObjectUUID())){
+            RecyclePowerMsg recyclePowerMsg = new RecyclePowerMsg(msg.getPowerUsedID());
+            Dispatch dispatch = Dispatch.borrow(origin.getPlayerCharacter(), recyclePowerMsg);
+            DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
+
+            // Send Fail to cast message
+            if (pc != null) {
+                sendPowerMsg(pc, 2, msg);
+                if (pc.isCasting()) {
+                    pc.update(false);
+                }
+
+                pc.setIsCasting(false);
+            }
             return;
         }
 
-        if(!origin.getPlayerCharacter().getPowers().containsKey(msg.getPowerUsedID())){
-            Logger.error(origin.getPlayerCharacter().getFirstName() + " attempted to cast a power they do not have");
-            return;
+        if(msg.getPowerUsedID() == -1851459567){//backstab
+            applyPower(pc,pc,pc.loc,-1851459567,msg.getNumTrains(),false);
         }
 
         if (usePowerA(msg, origin, sendCastToSelf)) {
@@ -204,6 +220,10 @@ public enum PowersManager {
             }
 
         }
+
+        if(msg.getPowerUsedID() == 429429978){
+            origin.getPlayerCharacter().getRecycleTimers().remove(429429978);
+        }
     }
 
     public static void useMobPower(Mob caster, AbstractCharacter target, PowersBase pb, int rank) {
@@ -1073,7 +1093,7 @@ public enum PowersManager {
                     continue;
                 // If something blocks the action, then stop
 
-                if (ab.blocked(target, pb, trains)) {
+                if (ab.blocked(target, pb, trains, playerCharacter)) {
 
                     PowersManager.sendEffectMsg(playerCharacter, 5, ab, pb);
                     continue;
@@ -1160,7 +1180,18 @@ public enum PowersManager {
 
 
         //DispatchMessage.dispatchMsgToInterestArea(playerCharacter, msg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
-
+//handle mob hate values
+        HashSet<AbstractWorldObject> mobs = WorldGrid.getObjectsInRangePartial(playerCharacter.loc,60.0f,MBServerStatics.MASK_MOB);
+        for(AbstractWorldObject awo : mobs){
+            Mob mobTarget = (Mob)awo;
+            if(mobTarget.hate_values != null) {
+                if (mobTarget.hate_values.containsKey(playerCharacter)) {
+                    mobTarget.hate_values.put(playerCharacter, mobTarget.hate_values.get(playerCharacter) + pb.getHateValue(trains));
+                } else {
+                    mobTarget.hate_values.put(playerCharacter, pb.getHateValue(trains));
+                }
+            }
+        }
 
     }
 
@@ -1249,7 +1280,7 @@ public enum PowersManager {
                     continue;
                 // If something blocks the action, then stop
 
-                if (ab.blocked(target, pb, trains))
+                if (ab.blocked(target, pb, trains, caster))
                     continue;
                 // TODO handle overwrite stack order here
                 String stackType = ab.getStackType();
@@ -1450,7 +1481,7 @@ public enum PowersManager {
         // Handle Accepting or Denying a summons.
         // set timer based on summon type.
         boolean wentThrough = false;
-        if (msg.accepted())
+        if (msg.accepted()) {
             // summons accepted, let's move the player if within time
             if (source.isAlive()) {
 
@@ -1496,14 +1527,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
@@ -1514,7 +1545,10 @@ public enum PowersManager {
                     timers.put("Summon", jc);
                 wentThrough = true;
             }
-
+        }else{
+            // recycle summons power
+            finishRecycleTime(428523680, source, true);
+        }
         // Summons failed
         if (!wentThrough)
             // summons refused. Let's be nice and reset recycle timer
@@ -1615,7 +1649,7 @@ public enum PowersManager {
                 it.remove();
             else if (awo.getObjectType().equals(GameObjectType.PlayerCharacter)) {
                 PlayerBonuses bonus = ((PlayerCharacter) awo).getBonuses();
-                if (bonus != null && bonus.getBool(ModType.CannotTrack, SourceType.None))
+                if (bonus != null && bonus.getBool(ModType.CannotTrack, SourceType.None) || ((PlayerCharacter) awo).getAccount().status.equals(AccountStatus.ADMIN))
                     it.remove();
             }
         }
@@ -1679,7 +1713,7 @@ public enum PowersManager {
             if(awo.equals(tracker))
                 continue;
             PlayerCharacter pc = (PlayerCharacter)awo;
-            if(!pc.isAlive())
+            if(!pc.isAlive() || pc.getAccount().status.equals(AccountStatus.ADMIN))
                 continue;
             if(guildsPresent.contains(pc.guild.getNation()))
                 list.add(pc);
@@ -1803,6 +1837,10 @@ public enum PowersManager {
     private static void applyPowerA(AbstractCharacter ac, AbstractWorldObject target,
                                     Vector3fImmutable targetLoc, PowersBase pb, int trains,
                                     boolean fromItem) {
+
+        if(fromItem && pb.token == 429021400)
+            trains = 40;
+
         int time = pb.getCastTime(trains);
         if (!fromItem)
             finishApplyPowerA(ac, target, targetLoc, pb, trains, false);
@@ -1868,7 +1906,7 @@ public enum PowersManager {
             if (trains < ab.getMinTrains() || trains > ab.getMaxTrains())
                 continue;
             // If something blocks the action, then stop
-            if (ab.blocked(target, pb, trains))
+            if (ab.blocked(target, pb, trains, ac))
                 // sendPowerMsg(pc, 5, msg);
                 continue;
             // TODO handle overwrite stack order here
@@ -1941,14 +1979,10 @@ public enum PowersManager {
         }
     }
 
-    public static void runPowerAction(AbstractCharacter source,
-                                      AbstractWorldObject awo, Vector3fImmutable targetLoc,
-                                      ActionsBase ab, int trains, PowersBase pb) {
+    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;
         }
         pa.startAction(source, awo, targetLoc, trains, ab, pb);
@@ -2487,10 +2521,12 @@ public enum PowersManager {
                     return true;
                 } else if (testPassive(pc, tarAc, "Block")) {
                     // Dodge fired, send dodge message
-                    PerformActionMsg dodgeMsg = new PerformActionMsg(msg);
-                    dodgeMsg.setTargetType(awo.getObjectType().ordinal());
-                    dodgeMsg.setTargetID(awo.getObjectUUID());
-                    sendPowerMsg(pc, 4, dodgeMsg);
+                    //PerformActionMsg dodgeMsg = new PerformActionMsg(msg);
+                    //dodgeMsg.setTargetType(awo.getObjectType().ordinal());
+                    //dodgeMsg.setTargetID(awo.getObjectUUID());
+                    //sendPowerMsg(pc, 4, dodgeMsg);
+                    TargetedActionMsg cmm = new TargetedActionMsg(pc, 75, tarAc, MBServerStatics.COMBAT_SEND_BLOCK);
+                    DispatchMessage.sendToAllInRange(tarAc, cmm);
                     return true;
                 }
             }

src/engine/gameManager/SpecialLootHandler.java

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

src/engine/gameManager/ZergManager.java

@@ -21,9 +21,9 @@ public class ZergManager {
             return 0.0f;
 
         switch(count){
-            case 4: return 0.63f;
-            case 5: return 0.40f;
-            case 6: return 0.25f;
+            case 4: return 0.50f;
+            case 5: return 0.0f;
+            case 6: return 0.0f;
             default: return 1.0f;
         }
     }

src/engine/jobs/AttackJob.java

@@ -9,9 +9,11 @@
 
 package engine.jobs;
 
+import engine.Enum;
 import engine.gameManager.CombatManager;
 import engine.job.AbstractJob;
 import engine.objects.AbstractCharacter;
+import engine.objects.PlayerCharacter;
 
 public class AttackJob extends AbstractJob {
 
@@ -28,6 +30,17 @@ public class AttackJob extends AbstractJob {
 
     @Override
     public void doJob() {
+
+        if(this.source.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)){
+            PlayerCharacter pc = (PlayerCharacter)source;
+            if(pc.combatTarget != null && pc.combatTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)){
+                PlayerCharacter target = (PlayerCharacter)pc.combatTarget;
+                if(!pc.canSee(target)) {
+                    this._cancelJob();
+                    return;
+                }
+            }
+        }
         CombatManager.doCombat(this.source, slot);
     }
 

src/engine/jobs/PersistentAoeJob.java

@@ -45,6 +45,14 @@ 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;
 
+        if(this.source.isAlive() && this.source.getObjectType().equals(GameObjectType.PlayerCharacter)){
+            PlayerCharacter pc = (PlayerCharacter)this.source;
+            if(pc.getPromotionClassID() == 2511){
+                this.cancelJob();
+                return;
+            }
+        }
+
         if (!this.source.isAlive())
             PowersManager.finishEffectTime(this.source, this.target, this.action, this.trains);
         else if (this.iteration < this.power.getChantIterations()) {

src/engine/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.MobHandlers.MobHandler;
 import engine.mobileAI.Threads.MobAIThread;
 import engine.mobileAI.utilities.CombatUtilities;
 import engine.mobileAI.utilities.MovementUtilities;
@@ -27,6 +28,7 @@ import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map.Entry;
 import java.util.concurrent.ConcurrentHashMap;
@@ -94,7 +96,7 @@ public class MobAI {
             }
 
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
         }
     }
 
@@ -133,6 +135,9 @@ public class MobAI {
                 if (mob.isMoving() && mob.getRange() > 20)
                     return;
 
+                if(target.combatStats == null)
+                    target.combatStats = new PlayerCombatStats(target);
+
                 // add timer for last attack.
 
                 ItemBase mainHand = mob.getWeaponItemBase(true);
@@ -170,7 +175,7 @@ public class MobAI {
             }
 
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackPlayer" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackPlayer" + " " + e.getMessage());
         }
 
     }
@@ -228,7 +233,7 @@ public class MobAI {
             //}
 
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackBuilding" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackBuilding" + " " + e.getMessage());
         }
     }
 
@@ -267,7 +272,7 @@ public class MobAI {
                 }
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackMob" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackMob" + " " + e.getMessage());
         }
     }
 
@@ -320,7 +325,7 @@ public class MobAI {
                         }
                     }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
         }
     }
 
@@ -364,7 +369,7 @@ public class MobAI {
             return mob.nextCastTime <= System.currentTimeMillis();
 
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: canCast" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: canCast" + " " + e.getMessage());
         }
         return false;
     }
@@ -450,7 +455,7 @@ public class MobAI {
                 return true;
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
         }
         return false;
     }
@@ -572,7 +577,7 @@ public class MobAI {
                 return true;
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
         }
         return false;
     }
@@ -608,7 +613,7 @@ public class MobAI {
                 mob.nextCallForHelp = System.currentTimeMillis() + 60000;
 
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCallForHelp" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCallForHelp" + " " + e.getMessage());
         }
     }
 
@@ -616,6 +621,35 @@ public class MobAI {
 
         try {
 
+            //if(mob.isSiege() || mob.isPet() || mob.isPlayerGuard()){
+            //    SuperSimpleMobAI.run(mob);
+            //    return;
+            //}
+            //boolean override;
+            //switch (mob.BehaviourType) {
+            //    case GuardCaptain:
+            //    case GuardMinion:
+            //    case GuardWallArcher:
+            //    case Pet1:
+            //    case HamletGuard:
+            //        override = false;
+            //        break;
+            //    default:
+             //       override = true;
+            //        break;
+            //}
+
+            //if(mob.isSiege())
+            //    override = false;
+
+            //if(mob.isPet())
+            //    override = false;
+
+            //if(override){
+            //    SuperSimpleMobAI.run(mob);
+            //    return;
+            //}
+
             //always check the respawn que, respawn 1 mob max per second to not flood the client
 
             if (mob == null)
@@ -723,18 +757,22 @@ public class MobAI {
                     HamletGuardLogic(mob);
                     break;
                 default:
+                    //SuperSimpleMobAI.run(mob);
+                    //MobHandler.run(mob);
                     DefaultLogic(mob);
                     break;
             }
             if(mob.isAlive())
                 RecoverHealth(mob);
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: DetermineAction" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: DetermineAction" + " " + e.getMessage());
         }
     }
 
     private static void CheckForAggro(Mob aiAgent) {
 
+
+        //old system
         try {
 
             //looks for and sets mobs combatTarget
@@ -769,13 +807,11 @@ public class MobAI {
                     continue;
 
                 // No aggro for this race type
-
-                if (aiAgent.notEnemy.size() > 0 && aiAgent.notEnemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()) == true)
+                if (aiAgent.notEnemy.size() > 0 && aiAgent.notEnemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()))
                     continue;
 
                 //mob has enemies and this player race is not it
-
-                if (aiAgent.enemy.size() > 0 && aiAgent.enemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()) == false)
+                if (aiAgent.enemy.size() > 0 && !aiAgent.enemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()))
                     continue;
 
                 if (MovementUtilities.inRangeToAggro(aiAgent, loadedPlayer)) {
@@ -804,7 +840,7 @@ public class MobAI {
                 }
             }
         } catch (Exception e) {
-            Logger.info(aiAgent.getObjectUUID() + " " + aiAgent.getName() + " Failed At: CheckForAggro" + " " + e.getMessage());
+            //(aiAgent.getObjectUUID() + " " + aiAgent.getName() + " Failed At: CheckForAggro" + " " + e.getMessage());
         }
     }
 
@@ -865,7 +901,7 @@ public class MobAI {
 
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckMobMovement" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckMobMovement" + " " + e.getMessage());
         }
     }
 
@@ -919,7 +955,7 @@ public class MobAI {
                 }
             }
         } catch (Exception e) {
-            Logger.info(aiAgent.getObjectUUID() + " " + aiAgent.getName() + " Failed At: CheckForRespawn" + " " + e.getMessage());
+            //(aiAgent.getObjectUUID() + " " + aiAgent.getName() + " Failed At: CheckForRespawn" + " " + e.getMessage());
         }
     }
 
@@ -945,7 +981,7 @@ public class MobAI {
                 AttackTarget(mob, mob.getCombatTarget());
 
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckForAttack" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckForAttack" + " " + e.getMessage());
         }
     }
 
@@ -972,7 +1008,8 @@ public class MobAI {
                     if (mob.BehaviourType.ordinal() == Enum.MobBehaviourType.GuardCaptain.ordinal())
                         CheckForPlayerGuardAggro(mob);
                 } else {
-                    CheckForAggro(mob);
+                    if(mob.combatTarget == null)
+                        NewAggroMechanic(mob);
                 }
             }
 
@@ -1006,7 +1043,7 @@ public class MobAI {
                 mob.setCombatTarget(null);
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckToSendMobHome" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckToSendMobHome" + " " + e.getMessage());
         }
     }
 
@@ -1049,7 +1086,7 @@ public class MobAI {
             mob.updateMovementState();
             mob.updateLocation();
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: chaseTarget" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: chaseTarget" + " " + e.getMessage());
         }
     }
 
@@ -1081,7 +1118,7 @@ public class MobAI {
                 mob.setCombatTarget(aggroMob);
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: SafeGuardAggro" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: SafeGuardAggro" + " " + e.getMessage());
         }
     }
 
@@ -1104,21 +1141,10 @@ public class MobAI {
             if (mob.getCombatTarget() == null)
                 CheckForPlayerGuardAggro(mob);
 
-            AbstractWorldObject newTarget = ChangeTargetFromHateValue(mob);
-
-            if (newTarget != null) {
-
-                if (newTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {
-                    if (GuardCanAggro(mob, (PlayerCharacter) newTarget))
-                        mob.setCombatTarget(newTarget);
-                } else
-                    mob.setCombatTarget(newTarget);
-
-            }
             CheckMobMovement(mob);
             CheckForAttack(mob);
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardCaptainLogic" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardCaptainLogic" + " " + e.getMessage());
         }
     }
 
@@ -1140,7 +1166,7 @@ public class MobAI {
             CheckMobMovement(mob);
             CheckForAttack(mob);
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardMinionLogic" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardMinionLogic" + " " + e.getMessage());
         }
     }
 
@@ -1154,7 +1180,7 @@ public class MobAI {
             else
                 CheckForAttack(mob);
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardWallArcherLogic" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardWallArcherLogic" + " " + e.getMessage());
         }
     }
 
@@ -1175,7 +1201,7 @@ public class MobAI {
 
             CheckForAttack(mob);
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: PetLogic" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: PetLogic" + " " + e.getMessage());
         }
     }
 
@@ -1191,7 +1217,7 @@ public class MobAI {
 
             CheckForAttack(mob);
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: HamletGuardLogic" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: HamletGuardLogic" + " " + e.getMessage());
         }
     }
 
@@ -1206,17 +1232,11 @@ public class MobAI {
 
             if (mob.BehaviourType.isAgressive) {
 
-                AbstractWorldObject newTarget = ChangeTargetFromHateValue(mob);
-
-                if (newTarget != null)
-                    mob.setCombatTarget(newTarget);
-                else {
-                    if (mob.getCombatTarget() == null) {
-                        if (mob.BehaviourType == Enum.MobBehaviourType.HamletGuard)
-                            SafeGuardAggro(mob);  //safehold guard
-                        else
-                            CheckForAggro(mob);   //normal aggro
-                    }
+                if (mob.getCombatTarget() == null) {
+                    if (mob.BehaviourType == Enum.MobBehaviourType.HamletGuard)
+                        SafeGuardAggro(mob);  //safehold guard
+                    else
+                        NewAggroMechanic(mob);//CheckForAggro(mob);   //normal aggro
                 }
             }
 
@@ -1232,7 +1252,7 @@ public class MobAI {
 
 
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: DefaultLogic" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: DefaultLogic" + " " + e.getMessage());
         }
     }
 
@@ -1282,7 +1302,7 @@ public class MobAI {
                 }
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckForPlayerGuardAggro" + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckForPlayerGuardAggro" + e.getMessage());
         }
     }
 
@@ -1345,7 +1365,7 @@ public class MobAI {
                 }
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardCanAggro" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardCanAggro" + " " + e.getMessage());
         }
         return false;
     }
@@ -1394,41 +1414,10 @@ public class MobAI {
                 }
             }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: randomGuardPatrolPoints" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: randomGuardPatrolPoints" + " " + e.getMessage());
         }
     }
 
-    public static AbstractWorldObject ChangeTargetFromHateValue(Mob mob) {
-
-        try {
-
-            float CurrentHateValue = 0;
-
-            if (mob.getCombatTarget() != null && mob.getCombatTarget().getObjectType().equals(Enum.GameObjectType.PlayerCharacter))
-                CurrentHateValue = ((PlayerCharacter) mob.getCombatTarget()).getHateValue();
-
-            AbstractWorldObject mostHatedTarget = null;
-
-            for (Entry playerEntry : mob.playerAgroMap.entrySet()) {
-
-                PlayerCharacter potentialTarget = PlayerCharacter.getFromCache((int) playerEntry.getKey());
-
-                if (potentialTarget.equals(mob.getCombatTarget()))
-                    continue;
-
-                if (potentialTarget != null && potentialTarget.getHateValue() > CurrentHateValue && MovementUtilities.inRangeToAggro(mob, potentialTarget)) {
-                    CurrentHateValue = potentialTarget.getHateValue();
-                    mostHatedTarget = potentialTarget;
-                }
-
-            }
-            return mostHatedTarget;
-        } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: ChangeTargetFromMostHated" + " " + e.getMessage());
-        }
-        return null;
-    }
-
     public static void RecoverHealth(Mob mob) {
         //recover health
         try {
@@ -1446,7 +1435,7 @@ public class MobAI {
                         mob.setHealth(mob.getHealthMax());
                 }
         } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: RecoverHealth" + " " + e.getMessage());
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: RecoverHealth" + " " + e.getMessage());
         }
     }
 
@@ -1456,4 +1445,69 @@ public class MobAI {
         rwss.setPlayer(mob);
         DispatchMessage.sendToAllInRange(mob, rwss);
     }
+
+    public static void NewAggroMechanic(Mob mob){
+
+        if(mob == null || !mob.isAlive() || mob.playerAgroMap.isEmpty()){
+            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,60.0f,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 = (PlayerCharacter)inRange.iterator().next();
+        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(mob.hate_values.containsKey(loadedPlayer))
+                if(mob.hate_values.get(loadedPlayer) > mob.hate_values.get(mostHated))
+                    mostHated = loadedPlayer;
+        }
+
+        if(mostHated != null)
+            mob.setCombatTarget(mostHated);
+    }
 }

src/engine/mobileAI/MobBehaviours/Pet.java

@@ -1,33 +0,0 @@
-package engine.mobileAI.MobBehaviours;
-
-import engine.gameManager.ZoneManager;
-import engine.mobileAI.utilities.MovementUtilities;
-import engine.objects.Mob;
-import org.pmw.tinylog.Logger;
-
-public class Pet {
-
-    public static void run(Mob pet){
-
-        try {
-
-            if(StaticBehaviours.EarlyExit(pet))
-                return;
-
-            if (pet.getOwner() == null && pet.isNecroPet() == false && pet.isSiege() == false)
-                if (ZoneManager.getSeaFloor().zoneMobSet.contains(pet))
-                    pet.killCharacter("no owner");
-
-            if(!pet.isSiege())
-                pet.BehaviourType.canRoam = true;
-
-
-            if (MovementUtilities.canMove(pet) && pet.BehaviourType.canRoam)
-                StaticBehaviours.CheckMobMovement(pet);
-
-            StaticBehaviours.CheckForAttack(pet);
-        } catch (Exception e) {
-            Logger.info(pet.getObjectUUID() + " " + pet.getName() + " Failed At: PetLogic" + " " + e.getMessage());
-        }
-    }
-}

src/engine/mobileAI/MobBehaviours/PlayerGuard.java

@@ -1,146 +0,0 @@
-package engine.mobileAI.MobBehaviours;
-
-import engine.Enum;
-import engine.objects.AbstractWorldObject;
-import engine.objects.Mob;
-import engine.objects.PlayerCharacter;
-import org.pmw.tinylog.Logger;
-
-public class PlayerGuard {
-
-    public static void run(Mob guard) {
-
-        if(StaticBehaviours.EarlyExit(guard))
-            return;
-
-        if (guard.mobPowers.isEmpty()) {
-            //mele
-            if (guard.BehaviourType.equals(Enum.MobBehaviourType.GuardWallArcher)) {
-                GuardWallArcherLogic(guard);
-            } else {
-                if (guard.BehaviourType.equals(Enum.MobBehaviourType.GuardCaptain)) {
-                    GuardCaptainLogic(guard);
-                } else if (guard.BehaviourType.equals(Enum.MobBehaviourType.GuardMinion)) {
-                    GuardMinionLogic(guard);
-                }
-            }
-        } else {
-            //caster
-            if (guard.BehaviourType.equals(Enum.MobBehaviourType.GuardCaptain)) {
-                MagisterCaptainLogic(guard);
-            } else if (guard.BehaviourType.equals(Enum.MobBehaviourType.GuardMinion)) {
-                MagisterMinionLogic(guard);
-            }
-        }
-    }
-
-    public static void GuardCaptainLogic(Mob mob) {
-
-        try {
-            StaticBehaviours.checkToDropGuardAggro(mob);
-            if (mob.getCombatTarget() == null)
-                StaticBehaviours.CheckForPlayerGuardAggro(mob);
-
-            AbstractWorldObject newTarget = StaticBehaviours.ChangeTargetFromHateValue(mob);
-
-            if (newTarget != null) {
-
-                if (newTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {
-                    if (StaticBehaviours.GuardCanAggro(mob, (PlayerCharacter) newTarget))
-                        mob.setCombatTarget(newTarget);
-                } else
-                    mob.setCombatTarget(newTarget);
-
-            }
-            StaticBehaviours.CheckMobMovement(mob);
-            StaticBehaviours.CheckForAttack(mob);
-        } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardCaptainLogic" + " " + e.getMessage());
-        }
-    }
-
-    public static void GuardMinionLogic(Mob mob) {
-
-        try {
-            StaticBehaviours.checkToDropGuardAggro(mob);
-
-            boolean isComanded = mob.npcOwner.isAlive();
-            if (!isComanded) {
-                GuardCaptainLogic(mob);
-            }else {
-                if (mob.npcOwner.getCombatTarget() != null)
-                    mob.setCombatTarget(mob.npcOwner.getCombatTarget());
-                else
-                if (mob.getCombatTarget() != null)
-                    mob.setCombatTarget(null);
-            }
-            StaticBehaviours.CheckMobMovement(mob);
-            StaticBehaviours.CheckForAttack(mob);
-        } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardMinionLogic" + " " + e.getMessage());
-        }
-    }
-
-    public static void GuardWallArcherLogic(Mob mob) {
-
-        try {
-            StaticBehaviours.checkToDropGuardAggro(mob);
-
-            if (mob.getCombatTarget() == null)
-                StaticBehaviours.CheckForPlayerGuardAggro(mob);
-            else
-                StaticBehaviours.CheckForAttack(mob);
-        } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardWallArcherLogic" + " " + e.getMessage());
-        }
-    }
-
-    public static void MagisterCaptainLogic(Mob mob){
-        try {
-            StaticBehaviours.checkToDropGuardAggro(mob);
-            if (mob.getCombatTarget() == null)
-                StaticBehaviours.CheckForPlayerGuardAggro(mob);
-
-            AbstractWorldObject newTarget = StaticBehaviours.ChangeTargetFromHateValue(mob);
-
-            if (newTarget != null) {
-
-                if (newTarget.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {
-                    if (StaticBehaviours.GuardCanAggro(mob, (PlayerCharacter) newTarget))
-                        mob.setCombatTarget(newTarget);
-                } else
-                    mob.setCombatTarget(newTarget);
-
-            }
-            StaticBehaviours.CheckMobMovement(mob);
-            CheckForCast(mob);
-        } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardCaptainLogic" + " " + e.getMessage());
-        }
-    }
-
-    public static void MagisterMinionLogic(Mob mob){
-        try {
-            StaticBehaviours.checkToDropGuardAggro(mob);
-
-            boolean isComanded = mob.npcOwner.isAlive();
-            if (!isComanded) {
-                MagisterCaptainLogic(mob);
-            }else {
-                if (mob.npcOwner.getCombatTarget() != null)
-                    mob.setCombatTarget(mob.npcOwner.getCombatTarget());
-                else
-                if (mob.getCombatTarget() != null)
-                    mob.setCombatTarget(null);
-            }
-            StaticBehaviours.CheckMobMovement(mob);
-            CheckForCast(mob);
-        } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: GuardMinionLogic" + " " + e.getMessage());
-        }
-    }
-
-    public static void CheckForCast(Mob mob){
-
-    }
-}

src/engine/mobileAI/MobBehaviours/SiegeEngine.java

@@ -1,27 +0,0 @@
-package engine.mobileAI.MobBehaviours;
-
-import engine.Enum;
-import engine.objects.Mob;
-
-public class SiegeEngine {
-
-    public static void run(Mob engine){
-
-        if(StaticBehaviours.EarlyExit(engine))
-            return;
-
-        if(engine.getOwner() == null)
-            return;
-
-        if(engine.combatTarget == null)
-            return;
-
-        if(engine.combatTarget.loc.distanceSquared(engine.loc) > engine.getRange() * engine.getRange())
-            return;
-
-        if(!engine.combatTarget.getObjectType().equals(Enum.GameObjectType.Building))
-            return;
-
-        StaticBehaviours.CheckForAttack(engine);
-    }
-}

src/engine/mobileAI/MobBehaviours/Standard.java

@@ -1,53 +0,0 @@
-package engine.mobileAI.MobBehaviours;
-
-import engine.Enum;
-import engine.objects.AbstractWorldObject;
-import engine.objects.Mob;
-import org.pmw.tinylog.Logger;
-
-public class Standard {
-
-    public static void run(Mob mob){
-
-        try {
-
-            if(StaticBehaviours.EarlyExit(mob))
-                return;
-
-            //check for players that can be aggroed if mob is agressive and has no target
-
-            if (mob.getCombatTarget() != null && !mob.playerAgroMap.containsKey(mob.getCombatTarget().getObjectUUID()))
-                mob.setCombatTarget(null);
-
-            if (mob.BehaviourType.isAgressive) {
-
-                AbstractWorldObject newTarget = StaticBehaviours.ChangeTargetFromHateValue(mob);
-
-                if (newTarget != null)
-                    mob.setCombatTarget(newTarget);
-                else {
-                    if (mob.getCombatTarget() == null) {
-                        if (mob.BehaviourType == Enum.MobBehaviourType.HamletGuard)
-                            StaticBehaviours.SafeGuardAggro(mob);  //safehold guard
-                        else
-                            StaticBehaviours.CheckForAggro(mob);   //normal aggro
-                    }
-                }
-            }
-
-            //check if mob can move for patrol or moving to target
-
-            if (mob.BehaviourType.canRoam)
-                StaticBehaviours.CheckMobMovement(mob);
-
-            //check if mob can attack if it isn't wimpy
-
-            if (!mob.BehaviourType.isWimpy && mob.getCombatTarget() != null)
-                StaticBehaviours.CheckForAttack(mob);
-
-
-        } catch (Exception e) {
-            Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: DefaultLogic" + " " + e.getMessage());
-        }
-    }
-}

src/engine/mobileAI/MobHandlers/MobHandler.java

@@ -0,0 +1,282 @@
+package engine.mobileAI.MobHandlers;
+
+import engine.InterestManagement.WorldGrid;
+import engine.gameManager.PowersManager;
+import engine.mobileAI.Threads.MobAIThread;
+import engine.mobileAI.utilities.CombatUtilities;
+import engine.mobileAI.utilities.MovementUtilities;
+import engine.objects.*;
+import engine.powers.PowersBase;
+import engine.server.MBServerStatics;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class MobHandler {
+    public static void run(Mob mob){
+
+        if (!mob.isAlive()) {
+            CheckForRespawn(mob);
+            return;
+        }
+
+        if(mob.playerAgroMap.isEmpty())
+            return;
+
+        CheckToSendMobHome(mob);
+
+        if(mob.combatTarget == null || !mob.combatTarget.isAlive()){
+            CheckForAggro(mob);
+        }
+        if(mob.combatTarget != null)
+            CheckToDropAggro(mob);
+
+        if(MovementUtilities.canMove(mob))
+            CheckMobMovement(mob);
+
+        if(mob.combatTarget != null && CombatUtilities.inRangeToAttack(mob,mob.combatTarget))
+            CheckToAttack(mob);
+    }
+
+    public static void CheckToDropAggro(Mob mob){
+        if(mob.loc.distanceSquared(mob.combatTarget.loc) > (128f * 128f))
+            mob.setCombatTarget(null);
+    }
+
+    public static void CheckForRespawn(Mob mob){
+        try {
+
+            if (mob.deathTime == 0) {
+                mob.setDeathTime(System.currentTimeMillis());
+                return;
+            }
+
+            //handles checking for respawn of dead mobs even when no players have mob loaded
+            //Despawn Timer with Loot currently in inventory.
+
+            if (!mob.despawned) {
+
+                if (mob.getCharItemManager().getInventoryCount() > 0) {
+                    if (System.currentTimeMillis() > mob.deathTime + MBServerStatics.DESPAWN_TIMER_WITH_LOOT) {
+                        mob.despawn();
+                        mob.deathTime = System.currentTimeMillis();
+                        return;
+                    }
+                    //No items in inventory.
+                } else if (mob.isHasLoot()) {
+                    if (System.currentTimeMillis() > mob.deathTime + MBServerStatics.DESPAWN_TIMER_ONCE_LOOTED) {
+                        mob.despawn();
+                        mob.deathTime = System.currentTimeMillis();
+                        return;
+                    }
+                    //Mob never had Loot.
+                } else {
+                    if (System.currentTimeMillis() > mob.deathTime + MBServerStatics.DESPAWN_TIMER) {
+                        mob.despawn();
+                        mob.deathTime = System.currentTimeMillis();
+                        return;
+                    }
+                }
+                return;
+            }
+
+            if(Mob.discDroppers.contains(mob))
+                return;
+
+            if (mob.despawned && System.currentTimeMillis() > (mob.deathTime + (mob.spawnTime * 1000L))) {
+                if (!Zone.respawnQue.contains(mob)) {
+                    Zone.respawnQue.add(mob);
+                }
+            }
+        } catch (Exception e) {
+            //(aiAgent.getObjectUUID() + " " + aiAgent.getName() + " Failed At: CheckForRespawn" + " " + e.getMessage());
+        }
+    }
+
+    public static void CheckForAggro(Mob mob){
+        switch(mob.BehaviourType){
+            case SimpleStandingGuard:
+            case Simple:
+            case None:
+                return;
+        }
+        PlayerCharacter tar = null;
+        for(int id : mob.playerAgroMap.keySet()){
+            PlayerCharacter target = PlayerCharacter.getFromCache(id);
+
+            if(target.loc.distanceSquared(mob.loc) > mob.getAggroRange() * mob.getAggroRange())
+                continue;
+
+            if(tar == null || mob.loc.distanceSquared(tar.loc) < mob.loc.distanceSquared(target.loc))
+                if(MobCanAggro(mob,target))
+                    tar = target;
+        }
+        if(tar != null)
+            mob.setCombatTarget(tar);
+    }
+
+    public static Boolean MobCanAggro(Mob mob, PlayerCharacter loadedPlayer){
+        if (loadedPlayer == null)
+            return false;
+
+        //Player is Dead, Mob no longer needs to attempt to aggro. Remove them from aggro map.
+        if (!loadedPlayer.isAlive())
+            return false;
+
+        //Can't see target, skip aggro.
+        if (!mob.canSee(loadedPlayer))
+            return false;
+
+        // No aggro for this race type
+        if (mob.notEnemy != null && mob.notEnemy.size() > 0 && mob.notEnemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()))
+            return false;
+
+        //mob has enemies and this player race is not it
+        if (mob.enemy != null && mob.enemy.size() > 0 && !mob.enemy.contains(loadedPlayer.getRace().getRaceType().getMonsterType()))
+            return false;
+
+        return true;
+    }
+
+    public static void CheckMobMovement(Mob mob){
+        if(!mob.isAlive())
+            return;
+
+        mob.updateLocation();
+
+        if(mob.combatTarget == null){
+            //patrol
+            Patrol(mob);
+        }else{
+            //combat movement
+            if(CombatUtilities.inRangeToAttack(mob,mob.combatTarget)) {
+                return;
+            }else {
+                MovementUtilities.moveToLocation(mob, mob.combatTarget.loc, mob.getRange());
+            }
+        }
+    }
+
+    public static void CheckToAttack(Mob mob){
+        try {
+
+            if(mob.getLastAttackTime() > System.currentTimeMillis())
+                return;
+
+            PlayerCharacter target = (PlayerCharacter) mob.combatTarget;
+
+            if (!mob.canSee(target)) {
+                mob.setCombatTarget(null);
+                return;
+            }
+
+            //if (mob.BehaviourType.callsForHelp)
+            MobCallForHelp(mob);
+
+            if (mob.isMoving() && mob.getRange() > 20)
+                return;
+
+            if(target.combatStats == null)
+                target.combatStats = new PlayerCombatStats(target);
+
+            ItemBase mainHand = mob.getWeaponItemBase(true);
+            ItemBase offHand = mob.getWeaponItemBase(false);
+
+            if (mainHand == null && offHand == null) {
+                CombatUtilities.combatCycle(mob, target, true, null);
+                int delay = 3000;
+                mob.setLastAttackTime(System.currentTimeMillis() + delay);
+            } else if (mob.getWeaponItemBase(true) != null) {
+                int delay = 3000;
+                CombatUtilities.combatCycle(mob, target, true, mob.getWeaponItemBase(true));
+                mob.setLastAttackTime(System.currentTimeMillis() + delay);
+            } else if (mob.getWeaponItemBase(false) != null) {
+                int attackDelay = 3000;
+                CombatUtilities.combatCycle(mob, target, false, mob.getWeaponItemBase(false));
+                mob.setLastAttackTime(System.currentTimeMillis() + attackDelay);
+            }
+
+            if (target.getPet() != null)
+                if (target.getPet().getCombatTarget() == null && target.getPet().assist)
+                    target.getPet().setCombatTarget(mob);
+
+        } catch (Exception e) {
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackPlayer" + " " + e.getMessage());
+        }
+    }
+
+    public static void MobCallForHelp(Mob mob) {
+
+        try {
+            HashSet<AbstractWorldObject> helpers = WorldGrid.getObjectsInRangePartial(mob.loc,mob.getAggroRange() * 2, MBServerStatics.MASK_MOB);
+            for (AbstractWorldObject awo : helpers) {
+                if(awo.equals(mob))
+                    continue;
+                Mob helper = (Mob) awo;
+
+                if(helper.equals(mob))
+                    continue;
+
+                if(helper.combatTarget != null)
+                    continue;
+
+                helper.setCombatTarget(mob.getCombatTarget());
+            }
+
+        } catch (Exception e) {
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCallForHelp" + " " + e.getMessage());
+        }
+    }
+
+    private static void Patrol(Mob mob) {
+
+        try {
+
+            if(mob.isMoving())
+                return;
+            //make sure mob is out of combat stance
+
+            int patrolDelay = ThreadLocalRandom.current().nextInt((int) (MobAIThread.AI_PATROL_DIVISOR * 0.5f), MobAIThread.AI_PATROL_DIVISOR) + MobAIThread.AI_PATROL_DIVISOR;
+
+            //early exit while waiting to patrol again
+
+            if (mob.stopPatrolTime + (patrolDelay * 1000) > System.currentTimeMillis())
+                return;
+
+            if (mob.lastPatrolPointIndex > mob.patrolPoints.size() - 1)
+                mob.lastPatrolPointIndex = 0;
+
+            mob.destination = mob.patrolPoints.get(mob.lastPatrolPointIndex);
+            mob.lastPatrolPointIndex += 1;
+
+            MovementUtilities.aiMove(mob, mob.destination, true);
+
+        } catch (Exception e) {
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
+        }
+    }
+
+    private static void CheckToSendMobHome(Mob mob) {
+
+        if(mob.isNecroPet())
+            return;
+
+        try {
+
+            if (!MovementUtilities.inRangeOfBindLocation(mob)) {
+
+                PowersBase recall = PowersManager.getPowerByToken(-1994153779);
+                PowersManager.useMobPower(mob, mob, recall, 40);
+
+                for (Map.Entry playerEntry : mob.playerAgroMap.entrySet())
+                    PlayerCharacter.getFromCache((int) playerEntry.getKey()).setHateValue(0);
+
+                mob.setCombatTarget(null);
+            }
+        } catch (Exception e) {
+            //(mob.getObjectUUID() + " " + mob.getName() + " Failed At: CheckToSendMobHome" + " " + e.getMessage());
+        }
+    }
+
+}

src/engine/mobileAI/MobHandlers/PetHandler.java

@@ -0,0 +1,66 @@
+package engine.mobileAI.MobHandlers;
+
+import engine.Enum;
+import engine.gameManager.MovementManager;
+import engine.gameManager.ZoneManager;
+import engine.mobileAI.utilities.CombatUtilities;
+import engine.mobileAI.utilities.MovementUtilities;
+import engine.objects.City;
+import engine.objects.Mob;
+import engine.objects.PlayerCharacter;
+
+public class PetHandler {
+
+    public static void run(Mob pet){
+        PlayerCharacter owner = pet.getOwner();
+
+        if(owner == null)
+            return;
+
+        if(!pet.isAlive()){
+            return;
+        }
+
+        if(!owner.isAlive()) {
+            owner.dismissPet();
+            return;
+        }
+
+        pet.updateLocation();
+
+        if(pet.combatTarget == null){
+            //follow owner
+            if(!CombatUtilities.inRangeToAttack(pet,owner)) {
+                MovementUtilities.moveToLocation(pet, owner.loc, pet.getRange());
+            }
+        }else{
+
+            if (pet.combatTarget.equals(pet)) {
+                pet.setCombatTarget(null);
+                return;
+            }
+
+            //chase target
+            if(!CombatUtilities.inRangeToAttack(pet,pet.combatTarget)) {
+                MovementUtilities.moveToLocation(pet, pet.combatTarget.loc, pet.getRange());
+            }else{
+                if(pet.getLastAttackTime() > System.currentTimeMillis())
+                    return;
+
+                pet.setLastAttackTime(System.currentTimeMillis() + 3000);
+
+                //attack target
+                if(pet.combatTarget.getObjectType().equals(Enum.GameObjectType.Building)){
+                    //attacking building
+                    City playercity = ZoneManager.getCityAtLocation(pet.getLoc());
+                    if (playercity != null)
+                        for (Mob guard : playercity.getParent().zoneMobSet)
+                            if (guard.combatTarget == null && guard.getGuild() != null && pet.getGuild() != null && !guard.getGuild().equals(pet.getGuild()))
+                                MovementUtilities.aiMove(guard,pet.loc,false);
+                }
+
+                CombatUtilities.combatCycle(pet,pet.combatTarget,true,null);
+            }
+        }
+    }
+}

src/engine/mobileAI/MobHandlers/PlayerGuardHandler.java

@@ -0,0 +1,449 @@
+package engine.mobileAI.MobHandlers;
+
+import engine.gameManager.PowersManager;
+import engine.math.Vector3fImmutable;
+import engine.mobileAI.Threads.MobAIThread;
+import engine.mobileAI.utilities.CombatUtilities;
+import engine.mobileAI.utilities.MovementUtilities;
+import engine.net.client.msg.PerformActionMsg;
+import engine.objects.*;
+import engine.powers.ActionsBase;
+import engine.powers.PowersBase;
+import engine.server.MBServerStatics;
+
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class PlayerGuardHandler {
+    public static void run(Mob guard) {
+        if(!guard.isAlive() || guard.despawned){
+            CheckRespawn(guard);
+            return;
+        }
+
+        CheckForRecall(guard);
+
+        if (guard.contract != null && guard.contract.getName().contains("Wall Archer")) {
+            runWallArcherGuard(guard);
+            return;
+        }else if (guard.contract != null && guard.contract.getName().contains("Magister")) {
+            runMagisterGuard(guard);
+            return;
+        }else if (guard.contract != null && guard.contract.getName().contains("Archer")) {
+            runArcherGuard(guard);
+            return;
+        }
+        runMeleGuard(guard);
+    }
+
+    public static void runMeleGuard(Mob guard){
+        try {
+            if (guard.combatTarget != null)
+                checkToDropGuardAggro(guard);
+
+            if (guard.combatTarget == null)
+                CheckForPlayerGuardAggro(guard);
+
+            if(MovementUtilities.canMove(guard))
+                CheckGuardMovement(guard);
+
+            if (guard.combatTarget != null && CombatUtilities.inRangeToAttack(guard, guard.combatTarget))
+                CheckToAttack(guard);
+
+        } catch (Exception ignored) {
+
+        }
+    }
+
+    public static void runArcherGuard(Mob guard){
+        try {
+            if (guard.combatTarget != null)
+                checkToDropGuardAggro(guard);
+
+            if (guard.combatTarget == null)
+                CheckForPlayerGuardAggro(guard);
+
+            if(MovementUtilities.canMove(guard))
+                CheckGuardMovement(guard);
+
+            if (guard.combatTarget != null && CombatUtilities.inRangeToAttack(guard, guard.combatTarget))
+                CheckToAttack(guard);
+
+        } catch (Exception ignored) {
+
+        }
+    }
+
+    public static void runMagisterGuard(Mob guard){
+        try {
+            if (guard.combatTarget != null)
+                checkToDropGuardAggro(guard);
+
+            if (guard.combatTarget == null)
+                CheckForPlayerGuardAggro(guard);
+
+            if(MovementUtilities.canMove(guard))
+                CheckMagisterMovement(guard);
+
+            if (guard.combatTarget != null && inRangeToCast(guard, guard.combatTarget))
+                GuardCast(guard);
+
+        } catch (Exception ignored) {
+
+        }
+    }
+
+    public static void runWallArcherGuard(Mob guard){
+        try {
+            if (guard.combatTarget != null)
+                checkToDropGuardAggro(guard);
+
+            if (guard.combatTarget == null)
+                CheckForPlayerGuardAggro(guard);
+
+            if (guard.combatTarget != null && CombatUtilities.inRangeToAttack(guard, guard.combatTarget))
+                CheckToAttack(guard);
+
+        } catch (Exception ignored) {
+
+        }
+    }
+
+    public static void checkToDropGuardAggro(Mob guard){
+        if(guard.combatTarget.loc.distanceSquared(guard.loc) > (128f * 128f))
+            guard.setCombatTarget(null);
+    }
+
+    public static void CheckForPlayerGuardAggro(Mob guard){
+        PlayerCharacter tar = null;
+        for(int id : guard.playerAgroMap.keySet()){
+            PlayerCharacter target = PlayerCharacter.getFromCache(id);
+
+            float aggroRange = guard.getAggroRange();
+
+            if(guard.getEquip().get(2) != null && guard.getEquip().get(2).getItemBase().getRange() > 15)
+                aggroRange = guard.getEquip().get(2).getItemBase().getRange() * 1.5f;
+
+            float squared = aggroRange * aggroRange;
+
+            if(target.loc.distanceSquared(guard.loc) > squared)
+                continue;
+
+            if(tar == null || guard.loc.distanceSquared(tar.loc) < guard.loc.distanceSquared(target.loc))
+                if(GuardCanAggro(guard,target))
+                    tar = target;
+        }
+        if(tar != null)
+            guard.setCombatTarget(tar);
+    }
+
+    public static Boolean GuardCanAggro(Mob guard, PlayerCharacter loadedPlayer){
+        if (loadedPlayer == null)
+            return false;
+
+        //Player is Dead, Mob no longer needs to attempt to aggro. Remove them from aggro map.
+        if (!loadedPlayer.isAlive())
+            return false;
+
+        //Can't see target, skip aggro.
+        if (!guard.canSee(loadedPlayer))
+            return false;
+
+        if(guard.guardedCity != null && guard.guardedCity.cityOutlaws.contains(loadedPlayer.getObjectUUID()))
+            return true;
+
+        if(loadedPlayer.guild.getNation().equals(guard.guardedCity.getGuild().getNation()))
+            return false;
+
+        return !guard.guardedCity.isOpen();
+    }
+
+    public static void GuardCast(Mob mob) {
+
+        if(mob.nextCastTime > System.currentTimeMillis())
+            return;
+
+        try {
+            // Method picks a random spell from a mobile's list of powers
+            // and casts it on the current target (or itself).  Validation
+            // (including empty lists) is done previously within canCast();
+
+            ArrayList<Integer> powerTokens;
+            ArrayList<Integer> purgeTokens;
+            AbstractCharacter target = (AbstractCharacter) mob.getCombatTarget();
+
+            // Generate a list of tokens from the mob powers for this mobile.
+
+            powerTokens = new ArrayList<>(mob.mobPowers.keySet());
+            purgeTokens = new ArrayList<>();
+
+            // If player has this effect on them currently then remove
+            // this token from our list.
+
+            for (int powerToken : powerTokens) {
+
+                PowersBase powerBase = PowersManager.getPowerByToken(powerToken);
+
+                for (ActionsBase actionBase : powerBase.getActions()) {
+
+                    String stackType = actionBase.stackType;
+
+                    if (target.getEffects() != null && target.getEffects().containsKey(stackType))
+                        purgeTokens.add(powerToken);
+                }
+            }
+
+            powerTokens.removeAll(purgeTokens);
+
+            // Sanity check
+
+            if (powerTokens.isEmpty())
+                return;
+
+            int powerToken;
+            int nukeRoll = ThreadLocalRandom.current().nextInt(1,100);
+
+            if (nukeRoll < 55) {
+
+                //use direct damage spell
+                powerToken = powerTokens.get(powerTokens.size() - 1);
+
+            } else {
+                //use random spell
+                powerToken = powerTokens.get(ThreadLocalRandom.current().nextInt(powerTokens.size()));
+            }
+
+            int powerRank = 1;
+
+            switch(mob.getRank()){
+                case 1:
+                    powerRank = 10;
+                    break;
+                case 2:
+                    powerRank = 15;
+                    break;
+                case 3:
+                    powerRank = 20;
+                    break;
+                case 4:
+                    powerRank = 25;
+                    break;
+                case 5:
+                    powerRank = 30;
+                    break;
+                case 6:
+                    powerRank = 35;
+                    break;
+                case 7:
+                    powerRank = 40;
+                    break;
+            }
+
+            PowersBase mobPower = PowersManager.getPowerByToken(powerToken);
+
+            //check for hit-roll
+
+            if (mobPower.requiresHitRoll)
+                if (CombatUtilities.triggerDefense(mob, mob.getCombatTarget()))
+                    return;
+
+            // Cast the spell
+
+            if (CombatUtilities.inRange2D(mob, mob.getCombatTarget(), mobPower.getRange())) {
+
+                PerformActionMsg msg;
+
+                if (!mobPower.isHarmful() || mobPower.targetSelf) {
+
+                    if (mobPower.category.equals("DISPEL")) {
+                        PowersManager.useMobPower(mob, target, mobPower, powerRank);
+                        msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, target);
+                    } else {
+                        PowersManager.useMobPower(mob, mob, mobPower, powerRank);
+                        msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, mob);
+                    }
+                } else {
+                    PowersManager.useMobPower(mob, target, mobPower, powerRank);
+                    msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, target);
+                }
+
+                msg.setUnknown04(2);
+
+                PowersManager.finishUseMobPower(msg, mob, 0, 0);
+            }
+            mob.nextCastTime = (long) (System.currentTimeMillis() + MobAIThread.AI_CAST_FREQUENCY);
+        } catch (Exception e) {
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
+        }
+    }
+
+    public static void CheckToAttack(Mob guard){
+        try {
+
+            if(guard.getLastAttackTime() > System.currentTimeMillis())
+                return;
+
+            PlayerCharacter target = (PlayerCharacter) guard.combatTarget;
+
+            if (!guard.canSee(target)) {
+                guard.setCombatTarget(null);
+                return;
+            }
+
+            if (guard.isMoving() && guard.getRange() > 20)
+                return;
+
+            if(target.combatStats == null)
+                target.combatStats = new PlayerCombatStats(target);
+
+            ItemBase mainHand = guard.getWeaponItemBase(true);
+            ItemBase offHand = guard.getWeaponItemBase(false);
+
+            if (mainHand == null && offHand == null) {
+                CombatUtilities.combatCycle(guard, target, true, null);
+                int delay = 3000;
+                guard.setLastAttackTime(System.currentTimeMillis() + delay);
+            } else if (guard.getWeaponItemBase(true) != null) {
+                int delay = 3000;
+                CombatUtilities.combatCycle(guard, target, true, guard.getWeaponItemBase(true));
+                guard.setLastAttackTime(System.currentTimeMillis() + delay);
+            } else if (guard.getWeaponItemBase(false) != null) {
+                int attackDelay = 3000;
+                CombatUtilities.combatCycle(guard, target, false, guard.getWeaponItemBase(false));
+                guard.setLastAttackTime(System.currentTimeMillis() + attackDelay);
+            }
+
+            if (target.getPet() != null)
+                if (target.getPet().getCombatTarget() == null && target.getPet().assist)
+                    target.getPet().setCombatTarget(guard);
+
+        } catch (Exception e) {
+            ////(guard.getObjectUUID() + " " + guard.getName() + " Failed At: AttackPlayer" + " " + e.getMessage());
+        }
+    }
+
+    public static void CheckGuardMovement(Mob guard){
+        if (guard.getCombatTarget() == null) {
+            if (!guard.isMoving())
+                Patrol(guard);
+            else {
+                guard.stopPatrolTime = System.currentTimeMillis();
+            }
+        } else {
+            MovementUtilities.moveToLocation(guard, guard.combatTarget.loc, guard.getRange());
+        }
+    }
+
+    private static void Patrol(Mob mob) {
+
+        try {
+
+            if(mob.isMoving())
+                return;
+            //make sure mob is out of combat stance
+
+            int patrolDelay = ThreadLocalRandom.current().nextInt((int) (MobAIThread.AI_PATROL_DIVISOR * 0.5f), MobAIThread.AI_PATROL_DIVISOR) + MobAIThread.AI_PATROL_DIVISOR;
+
+            //early exit while waiting to patrol again
+
+            if (mob.stopPatrolTime + (patrolDelay * 1000L) > System.currentTimeMillis())
+                return;
+
+            if (mob.lastPatrolPointIndex > mob.patrolPoints.size() - 1)
+                mob.lastPatrolPointIndex = 0;
+
+            mob.destination = Vector3fImmutable.getRandomPointOnCircle(mob.patrolPoints.get(mob.lastPatrolPointIndex),16f);
+            mob.lastPatrolPointIndex += 1;
+
+            MovementUtilities.aiMove(mob, mob.destination, true);
+
+        } catch (Exception e) {
+            ////(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackTarget" + " " + e.getMessage());
+        }
+    }
+
+    private static boolean inRangeToCast(Mob guard, AbstractWorldObject target){
+        float castRangeSquared = 50f * 50f;
+        float rangeSquared = guard.loc.distanceSquared(target.loc);
+        return castRangeSquared >= rangeSquared;
+    }
+
+    public static void CheckMagisterMovement(Mob guard){
+        if (guard.getCombatTarget() == null) {
+            if (!guard.isMoving())
+                Patrol(guard);
+            else {
+                guard.stopPatrolTime = System.currentTimeMillis();
+            }
+        } else {
+            if(guard.isMoving()){
+                float desiredRangeSquared = 40f * 40f;
+                float distance = guard.loc.distanceSquared(guard.combatTarget.loc);
+                if(distance <= desiredRangeSquared){
+                    guard.stopMovement(guard.getMovementLoc());
+                    guard.updateLocation();
+                }
+            }else {
+                MovementUtilities.moveToLocation(guard, guard.combatTarget.loc, guard.getRange());
+            }
+        }
+    }
+
+    public static void CheckForRecall(Mob guard){
+
+        if(guard.loc.distanceSquared(guard.parentZone.getLoc()) > (800 * 800)) {
+
+            PowersBase recall = PowersManager.getPowerByToken(-1994153779);
+            PowersManager.useMobPower(guard, guard, recall, 40);
+
+            for (Map.Entry playerEntry : guard.playerAgroMap.entrySet())
+                PlayerCharacter.getFromCache((int) playerEntry.getKey()).setHateValue(0);
+
+            guard.setCombatTarget(null);
+        }
+    }
+
+    public static void CheckRespawn(Mob guard){
+        if(!guard.despawned)
+            guard.despawn();
+
+        long respawnTime = 0L;
+
+        Building barracks = guard.building;
+        if(barracks == null){
+            respawnTime = MBServerStatics.FIFTEEN_MINUTES;
+        }else{
+            switch(barracks.getRank()) {
+                case 2:
+                    respawnTime = 750000; // 12.5 minutes
+                    break;
+                case 3:
+                    respawnTime = 660000; // 11 minutes
+                    break;
+                case 4:
+                    respawnTime = 570000; // 9.5 minutes
+                    break;
+                case 5:
+                    respawnTime = 480000; // 8 minutes
+                    break;
+                case 6:
+                    respawnTime = 450000; // 6.5 minutes
+                    break;
+                case 7:
+                    respawnTime = MBServerStatics.FIVE_MINUTES;
+                    break;
+                default:
+                    respawnTime = MBServerStatics.FIFTEEN_MINUTES;
+                    break;
+            }
+
+        }
+
+        if(guard.deathTime + respawnTime < System.currentTimeMillis()){
+            if (!Zone.respawnQue.contains(guard)) {
+                Zone.respawnQue.add(guard);
+            }
+        }
+    }
+}

src/engine/mobileAI/MobHandlers/SiegeHandler.java

@@ -0,0 +1,56 @@
+package engine.mobileAI.MobHandlers;
+
+import engine.Enum;
+import engine.gameManager.MovementManager;
+import engine.gameManager.ZoneManager;
+import engine.mobileAI.utilities.CombatUtilities;
+import engine.mobileAI.utilities.MovementUtilities;
+import engine.objects.Building;
+import engine.objects.City;
+import engine.objects.Mob;
+import engine.server.MBServerStatics;
+
+public class SiegeHandler {
+    public static void run(Mob engine){
+
+        if(!engine.isAlive()) {
+            check_siege_respawn(engine);
+            return;
+        }
+
+        if(engine.getOwner() == null || !engine.getOwner().isAlive() || !engine.playerAgroMap.containsKey(engine.getOwner().getObjectUUID()))
+            return;
+
+        if(engine.combatTarget == null || !engine.combatTarget.getObjectType().equals(Enum.GameObjectType.Building))
+            return;
+
+        siege_attack(engine);
+    }
+
+    public static void check_siege_respawn(Mob engine){
+        if(!engine.despawned) {
+            engine.despawn();
+        }else{
+            if(engine.deathTime + MBServerStatics.FIFTEEN_MINUTES > System.currentTimeMillis()){
+                engine.respawn();
+            }
+        }
+    }
+
+    public static void siege_attack(Mob engine){
+        if(engine.getLastAttackTime() > System.currentTimeMillis())
+            return;
+
+        if(CombatUtilities.inRangeToAttack(engine,engine.combatTarget)){
+            CombatUtilities.combatCycle(engine, engine.combatTarget, true, null);
+            engine.setLastAttackTime(System.currentTimeMillis() + 15000);
+            City playercity = ZoneManager.getCityAtLocation(engine.getLoc());
+            if (playercity != null)
+                for (Mob guard : playercity.getParent().zoneMobSet)
+                    if (guard.isPlayerGuard && guard.combatTarget == null && guard.getGuild() != null && engine.getGuild() != null && !guard.getGuild().equals(engine.getGuild()))
+                        MovementUtilities.aiMove(guard,engine.loc,false);
+
+            MovementManager.sendRWSSMsg(engine);
+        }
+    }
+}

src/engine/mobileAI/SuperSimpleMobAI.java

@@ -0,0 +1,26 @@
+package engine.mobileAI;
+
+import engine.mobileAI.MobHandlers.MobHandler;
+import engine.mobileAI.MobHandlers.PetHandler;
+import engine.mobileAI.MobHandlers.PlayerGuardHandler;
+import engine.mobileAI.MobHandlers.SiegeHandler;
+import engine.objects.Mob;
+
+public class SuperSimpleMobAI {
+
+    public static void run(Mob mob){
+        mob.updateLocation();
+        if(mob.isPet() && !mob.isSiege()) {
+            PetHandler.run(mob);
+            return;
+        }else if (mob.isSiege()) {
+            SiegeHandler.run(mob);
+            return;
+        }else if(mob.isPlayerGuard()){
+            PlayerGuardHandler.run(mob);
+            return;
+        }else {
+            MobHandler.run(mob);
+        }
+    }
+}

src/engine/mobileAI/Threads/MobAIThread.java

@@ -3,7 +3,7 @@ package engine.mobileAI.Threads;
 import engine.gameManager.ConfigManager;
 import engine.mobileAI.MobAI;
 import engine.gameManager.ZoneManager;
-import engine.mobileAI.MobBehaviours.StaticBehaviours;
+import engine.mobileAI.SuperSimpleMobAI;
 import engine.objects.Mob;
 import engine.objects.Zone;
 import engine.server.MBServerStatics;
@@ -28,27 +28,26 @@ public class MobAIThread implements Runnable{
         AI_CAST_FREQUENCY = Float.parseFloat(ConfigManager.MB_AI_CAST_FREQUENCY.getValue());
         AI_BASE_AGGRO_RANGE = (int)(60 * Float.parseFloat(ConfigManager.MB_AI_AGGRO_RANGE.getValue()));
         while (true) {
-            for (Zone zone : ZoneManager.getAllZones()) {
-                if (zone != null && zone.zoneMobSet != null) {
-                    synchronized (zone.zoneMobSet) {
-                        for (Mob mob : zone.zoneMobSet) {
-                            try {
-                                if (mob != null) {
-                                    //MobAI.DetermineAction(mob);
-                                    StaticBehaviours.runBehaviour(mob);
+            try {
+                for (Zone zone : ZoneManager.getAllZones()) {
+                    if (zone != null && zone.zoneMobSet != null) {
+                        synchronized (zone.zoneMobSet) {
+                            for (Mob mob : zone.zoneMobSet) {
+                                try {
+                                    if (mob != null) {
+                                        //MobAI.DetermineAction(mob);
+                                        SuperSimpleMobAI.run(mob);
+                                    }
+                                } catch (Exception e) {
+                                    Logger.error("Error processing Mob [Name: {}, UUID: {}]", mob.getName(), mob.getObjectUUID(), e);
                                 }
-                            } catch (Exception e) {
-                                Logger.error("Error processing Mob [Name: {}, UUID: {}]", mob.getName(), mob.getObjectUUID(), e);
                             }
                         }
                     }
                 }
-            }
-            try {
                 Thread.sleep(100);
-            } catch (InterruptedException e) {
-                Logger.error("AI Thread interrupted", e);
-                Thread.currentThread().interrupt();
+            }catch(Exception e){
+                Logger.error(e.getMessage());
             }
         }
     }

src/engine/mobileAI/utilities/CombatUtilities.java

@@ -156,6 +156,8 @@ public class CombatUtilities {
         switch (target.getObjectType()) {
             case PlayerCharacter:
                 PlayerCharacter pc = (PlayerCharacter)target;
+                if(pc.combatStats == null)
+                    pc.combatStats = new PlayerCombatStats(pc);
                 pc.combatStats.calculateDefense();
                 defense = pc.combatStats.defense;
                 break;

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

@@ -66,6 +66,7 @@ public class ArcLoginNotifyMsgHandler extends AbstractClientMsgHandler {
         // Send Guild, Nation and IC MOTD
         GuildManager.enterWorldMOTD(player);
         ChatManager.sendSystemMessage(player, ConfigManager.MB_WORLD_GREETING.getValue());
+        ChatManager.sendSystemMessage(player, " Experience Gain: " + ConfigManager.MB_NORMAL_EXP_RATE.getValue());
 
         // Send branch string if available from ConfigManager.
 

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

@@ -54,7 +54,7 @@ public class DestroyBuildingHandler extends AbstractClientMsgHandler {
             return true;
         }
 
-        if (!BuildingManager.PlayerCanControlNotOwner(building, pc))
+        if (!BuildingManager.PlayerCanControlNotOwner(building, pc) && !pc.getAccount().status.equals(Enum.AccountStatus.ADMIN))
             return true;
 
         // Can't delete siege assets during an active bane.
@@ -72,8 +72,8 @@ public class DestroyBuildingHandler extends AbstractClientMsgHandler {
             return true;
 
         // Can't destroy a shrine
-        if (blueprint.getBuildingGroup() == BuildingGroup.SHRINE)
-            return true;
+        //if (blueprint.getBuildingGroup() == BuildingGroup.SHRINE)
+        //    return true;
 
         // Cannot destroy  mines outside of normal mine mechanics
 

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

@@ -21,6 +21,7 @@ import engine.net.client.ClientConnection;
 import engine.net.client.msg.ClientNetMsg;
 import engine.net.client.msg.ErrorPopupMsg;
 import engine.net.client.msg.guild.InviteToSubMsg;
+import engine.objects.Bane;
 import engine.objects.Guild;
 import engine.objects.GuildStatusController;
 import engine.objects.PlayerCharacter;
@@ -112,6 +113,12 @@ public class InviteToSubHandler extends AbstractClientMsgHandler {
             return true;
         }
 
+        //ensure bane to be subbed does not have a bane dropped
+        for(Bane bane : Bane.banes.values()){
+            if(bane.getOwner().guild.getNation().equals(targetGuild))
+                return true;
+        }
+
         //all tests passed, let's send invite.
 
         if (target.getClientConnection() != null) {

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

@@ -24,6 +24,7 @@ import engine.net.client.msg.ErrorPopupMsg;
 import engine.net.client.msg.ItemProductionMsg;
 import engine.net.client.msg.ManageNPCMsg;
 import engine.objects.*;
+import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
 import java.util.HashMap;
@@ -361,7 +362,7 @@ public class ItemProductionMsgHandler extends AbstractClientMsgHandler {
                 vendor.removeItemFromForge(targetItem);
 
                 //refund the gold for cancelled item
-                if(vendor.building.getStrongboxValue() + targetItem.getItemBase().getBaseValue() < 15000000){
+                if(vendor.building.getStrongboxValue() + targetItem.getItemBase().getBaseValue() < MBServerStatics.BUILDING_GOLD_LIMIT){
                     vendor.building.setStrongboxValue(vendor.building.getStrongboxValue() + targetItem.getItemBase().getBaseValue());
                 }
 

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

@@ -282,6 +282,14 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
                 }
             }
             if(mineTele == null){
+                //must be the dungeon request?
+                Vector3fImmutable loc = Vector3fImmutable.getRandomPointOnCircle(BuildingManager.getBuilding(2827951).loc,30f);
+                ChatManager.chatSystemInfo(player, "You Will Teleport To Whitehorn Citadel In " + 10 +  " Seconds.");
+                if (10 > 0) {
+                    //TODO add timer to teleport
+                    TeleportJob tj = new TeleportJob(player, npc, loc, origin, true);
+                    JobScheduler.getInstance().scheduleJob(tj, 10 * 1000);
+                }
                 return;
             }else {
                 int time = MBServerStatics.TELEPORT_TIME_IN_SECONDS;

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

@@ -568,7 +568,15 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
             return false;
         }
 
-        serverCity = ZoneManager.getCityAtLocation(buildingList.getLoc());
+        //serverCity = ZoneManager.getCityAtLocation(buildingList.getLoc());
+        Bane validBane = null;
+        serverCity = null;
+        for(Bane b : Bane.banes.values()){
+                City c = b.getCity();
+                if(c.getGuild().equals(player.guild) || b.getOwner().guild.equals(player.guild))
+                    serverCity = b.getCity();
+        }
+
 
         // No valid player city found
 
@@ -611,6 +619,13 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
             return false;
         }
 
+        //make sure building is withing range
+        float distanceSquared = buildingList.getLoc().distanceSquared(serverCity.loc);
+        float allowedSquared = (CityBoundsType.SIEGEBOUNDS.extents * 0.65f) * (CityBoundsType.SIEGEBOUNDS.extents * 0.65f);
+        if(allowedSquared < distanceSquared) {
+            PlaceAssetMsg.sendPlaceAssetError(origin, 52, ""); // Cannot place outisde a guild zone
+            return false;
+        }
         // If there is a bane placed, we limit bow placement to 2x the stone rank's worth of attacker assets
         // and 1x the tree rank for defenders
 
@@ -652,7 +667,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
 
         // Count bow for attackers and defenders
 
-        awoList = WorldGrid.getObjectsInRangePartial(serverCity, 1000, MBServerStatics.MASK_BUILDING);
+        awoList = WorldGrid.getObjectsInRangePartial(serverCity, CityBoundsType.SIEGEBOUNDS.extents, MBServerStatics.MASK_BUILDING);
 
         for (AbstractWorldObject awo : awoList) {
             Building building = (Building) awo;
@@ -661,7 +676,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
                 if (!building.getBlueprint().isSiegeEquip())
                     continue;
 
-            if (!building.getLoc().isInsideCircle(serverCity.getLoc(), CityBoundsType.ZONE.extents))
+            if (!building.getLoc().isInsideCircle(serverCity.getLoc(), CityBoundsType.SIEGEBOUNDS.extents))
                 continue;
 
             if (building.getGuild() == null)
@@ -1027,6 +1042,10 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
 
     private boolean placeCityWalls(PlayerCharacter player, ClientConnection origin, PlaceAssetMsg msg) {
 
+        if(player.getAccount().status.equals(AccountStatus.ADMIN)){
+            adminCreateBuildings(player,msg);
+            return false;
+        }
         // Member variables
 
         Zone serverZone;
@@ -1165,7 +1184,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
         return true;
     }
 
-    private Building createStructure(PlayerCharacter playerCharacter, PlacementInfo buildingInfo, Zone currentZone) {
+    private static Building createStructure(PlayerCharacter playerCharacter, PlacementInfo buildingInfo, Zone currentZone) {
 
         Blueprint blueprint;
         Building newMesh;
@@ -1387,4 +1406,16 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
 
         return true;
     }
+
+    public static void adminCreateBuildings(PlayerCharacter pc, PlaceAssetMsg msg){
+        //handled for building dungeon layouts
+        Zone zone = ZoneManager.getZoneByZoneID(993);
+        for(PlacementInfo placement : msg.getPlacementInfo()){
+            Building building = createStructure(pc,placement,zone);
+            if(building != null) {
+                building.setProtectionState(ProtectionState.NPC);
+                building.setRank(1);
+            }
+        }
+    }
 }

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

@@ -48,7 +48,7 @@ public class RequestEnterWorldHandler extends AbstractClientMsgHandler {
 
         PlayerCharacter player = origin.getPlayerCharacter();
 
-        WorldGrid.RemoveWorldObject(player);
+
         Dispatch dispatch;
 
         if (player == null) {
@@ -57,6 +57,11 @@ public class RequestEnterWorldHandler extends AbstractClientMsgHandler {
             return true;
         }
 
+        //if(player.isEnteredWorld()){
+        //    if(player != null) {
+       //         WorldGrid.RemoveWorldObject(player);
+       //     }
+        //}
         player.setEnteredWorld(false);
 
         Account acc = SessionManager.getAccount(origin);
@@ -106,9 +111,14 @@ public class RequestEnterWorldHandler extends AbstractClientMsgHandler {
 
         player.getTimestamps().put("EnterWorld", System.currentTimeMillis());
 
-        if (player.getLoc().equals(Vector3fImmutable.ZERO) || System.currentTimeMillis() > player.getTimeStamp("logout") + (15 * 60 * 1000)) {
+        Long logout = player.getTimeStamp("logout");
+        if (player.getLoc().equals(Vector3fImmutable.ZERO) || System.currentTimeMillis() > logout + (15 * 60 * 1000)) {
             player.stopMovement(player.getBindLoc());
-            player.setSafeMode();
+            try {
+                player.setSafeMode();
+            }catch(Exception e){
+                Logger.error(e);
+            }
             player.updateLocation();
             player.setRegion(AbstractWorldObject.GetRegionByWorldObject(player));
         }

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

@@ -567,8 +567,12 @@ public class ManageCityAssetsMsg extends ClientNetMsg {
             writer.put(labelSiege);// 1 sets the protection under siege
             writer.put(labelCeaseFire); //0 with 1 set above sets to under siege // 1 with 1 set above sets protection status to under siege(cease fire)
 
-            writer.put(buttonTransfer);// 1 enables the transfer asset button
-            writer.put(buttonDestroy);// 1 enables the destroy asset button
+            writer.put(buttonTransfer);
+            if(building.getBlueprint() != null && building.getBlueprint().getBuildingGroup() != null && building.getBlueprint().getBuildingGroup().equals(BuildingGroup.SHRINE)) {// 1 enables the transfer asset button
+                writer.put((byte)1);
+            }else {
+                writer.put(buttonDestroy);// 1 enables the destroy asset button
+            }
             writer.put(buttonAbandon);// 1 here enables the abandon asset button
             writer.put(buttonUpgrade); //disable upgrade building
 

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

@@ -10,6 +10,7 @@
 package engine.net.client.msg;
 
 
+import engine.Dungeons.Dungeon;
 import engine.net.AbstractConnection;
 import engine.net.AbstractNetMsg;
 import engine.net.ByteBufferReader;
@@ -108,7 +109,7 @@ public class TeleportRepledgeListMsg extends ClientNetMsg {
         for (int i = 0; i < 3; i++)
             writer.putInt(0);
 
-        writer.putInt(cities.size() + mines.size());
+        writer.putInt(cities.size() + mines.size());// + 1);
 
         for (City city : cities)
             City.serializeForClientMsg(city, writer);
@@ -116,6 +117,7 @@ public class TeleportRepledgeListMsg extends ClientNetMsg {
         for(Mine mine : mines)
             Mine.serializeForClientMsgTeleport(mine, writer);
 
+        //Dungeon.serializeForClientMsgTeleport(writer);
     }
 
     public PlayerCharacter getPlayer() {

src/engine/objects/AbstractCharacter.java

@@ -1464,6 +1464,7 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
 
             if (eff == null)
                 continue;
+
             if (eff.cancelOnAttack() && eff.cancel()) {
                 eff.cancelJob();
                 this.effects.remove(s);

src/engine/objects/Arena.java

@@ -19,8 +19,8 @@ public class Arena {
 
     }
     public Boolean disqualify() {
-        HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(this.loc, 250f, MBServerStatics.MASK_PLAYER);
-        HashSet<AbstractWorldObject> warningRange = WorldGrid.getObjectsInRangePartial(this.loc, 500f, MBServerStatics.MASK_PLAYER);
+        HashSet<AbstractWorldObject> inRange = WorldGrid.getObjectsInRangePartial(this.loc, ArenaManager.arena_radius, MBServerStatics.MASK_PLAYER);
+        HashSet<AbstractWorldObject> warningRange = WorldGrid.getObjectsInRangePartial(this.loc, ArenaManager.arena_radius + 250f, MBServerStatics.MASK_PLAYER);
         for(AbstractWorldObject obj : warningRange){
             PlayerCharacter pc = (PlayerCharacter)obj;
             if(pc.equals(this.player1) || pc.equals(this.player2))

src/engine/objects/Bane.java

@@ -57,6 +57,8 @@ public final class Bane {
     // Internal cache for banes
     private ActivateBaneJob activateBaneJob;
 
+    public ArrayList<PlayerCharacter> affected_players;
+
     /**
      * ResultSet Constructor
      */
@@ -208,6 +210,25 @@ public final class Bane {
             return false;
         }
 
+        //audit that defending nation does no have a bane on them already
+        boolean defenderBaned = false;
+        Guild defenderNation = targetCity.getGuild().getNation();
+        if(defenderNation.getOwnedCity() != null && defenderNation.getOwnedCity().getBane() != null){
+            defenderBaned = true;
+        }else{
+            for (Guild sub : defenderNation.getSubGuildList()) {
+                if (sub.getOwnedCity() != null) {
+                    if (sub.getOwnedCity().getBane() != null) {
+                        defenderBaned = true;
+                    }
+                }
+            }
+        }
+        if(defenderBaned){
+            ChatManager.chatSystemInfo(player, "This Nation has already been baned!");
+            return false;
+        }
+
         if (targetCity.isLocationOnCityGrid(player.getLoc()) == true) {
             PlaceAssetMsg.sendPlaceAssetError(origin, 1, "Cannot place banestone on city grid.");
             return false;
@@ -675,6 +696,9 @@ public final class Bane {
                 toUnprotect.setProtectionState(ProtectionState.NONE);
         }
 
+        for(PlayerCharacter affected : this.affected_players)
+            affected.ZergMultiplier = 1.0f;
+
     }
 
     public boolean isErrant() {
@@ -717,6 +741,8 @@ public final class Bane {
         if(city == null)
             return;
 
+        if(this.affected_players == null)
+            this.affected_players = new ArrayList<>();
         city.onEnter();
 
         ArrayList<Integer> attackers = new ArrayList<>();
@@ -727,8 +753,13 @@ public final class Bane {
         for(AbstractWorldObject obj : inSiegeRange){
             int uuid = obj.getObjectUUID();
             PlayerCharacter player = PlayerCharacter.getPlayerCharacter(uuid);
+
             if(player == null)
                 continue;
+
+            if(player.getAccount().status.equals(Enum.AccountStatus.ADMIN))
+                continue;
+
             Guild playerNation = player.guild.getNation();
             //separate the players into categories
             if(playerNation.equals(defendNation))
@@ -755,18 +786,24 @@ public final class Bane {
         float defenderMultiplier = ZergManager.getCurrentMultiplier(defenderSize,this.capSize);
         for(int uuid : attackers){
             PlayerCharacter player = PlayerCharacter.getPlayerCharacter(uuid);
-            if(inSiegeRange.contains(player)) //player is still physically here, needs updated multiplier
+            if(inSiegeRange.contains(player)) { //player is still physically here, needs updated multiplier
                 player.ZergMultiplier = attackerMultiplier;
-            else
+                this.affected_players.add(player);
+            }else {
                 player.ZergMultiplier = 1.0f;
+                this.affected_players.add(player);
+            }
         }
 
         for(int uuid : defenders){
             PlayerCharacter player = PlayerCharacter.getPlayerCharacter(uuid);
-            if(inSiegeRange.contains(player)) //player is still physically here, needs updated multiplier
-                player.ZergMultiplier = defenderMultiplier;
-            else
+            if(inSiegeRange.contains(player)) { //player is still physically here, needs updated multiplier
+                player.ZergMultiplier = attackerMultiplier;
+                this.affected_players.add(player);
+            }else {
                 player.ZergMultiplier = 1.0f;
+                this.affected_players.add(player);
+            }
         }
 
     }

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 = MBServerStatics.BUILDING_GOLD_LIMIT; // *** Refactor to blueprint method
             this.reserve = rs.getInt("reserve");
 
             // Does building have a protection contract?

src/engine/objects/CharacterItemManager.java

@@ -1058,6 +1058,7 @@ public class CharacterItemManager {
         i.addToCache();
         try {
             i.stripCastableEnchants();
+            this.updateInventory();
         }catch(Exception ignored){
             Logger.error("FAILED TO STRIP CASTABLE ENCHANTS: Move Item To Bank");
         }
@@ -1203,6 +1204,7 @@ public class CharacterItemManager {
 
         try {
             i.stripCastableEnchants();
+            this.updateInventory();
         }catch(Exception ignored){
             Logger.error("FAILED TO STRIP CASTABLE ENCHANTS: Move Item To Vault");
         }
@@ -1508,6 +1510,8 @@ public class CharacterItemManager {
         if (purchasedItem == null || npc == null)
             return false;
 
+        purchasedItem.stripCastableEnchants();
+
         itemMan = npc.getCharItemManager();
 
         if (itemMan == null)
@@ -2349,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);
@@ -2357,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);
@@ -2448,6 +2452,9 @@ public class CharacterItemManager {
     public void damageItem(Item item, int amount) {
         if (item == null || amount < 1 || amount > 5)
             return;
+        if(item.getItemBase().isGlass()){
+            amount = 1;
+        }
 
         //verify the item is equipped by this player
         int slot = item.getEquipSlot();

src/engine/objects/City.java

@@ -397,7 +397,7 @@ public class City extends AbstractWorldObject {
                             cities.add(city);
                         }else {
                             try {
-                                if (city.getGuild().getNation().equals(pc.guild.getNation())) {
+                                if (city.getGuild() != null && city.getGuild().getNation().equals(pc.guild.getNation())) {
                                     cities.add(city);
                                 }
                             }catch(Exception e){
@@ -953,7 +953,7 @@ public class City extends AbstractWorldObject {
 
     public boolean isLocationWithinSiegeBounds(Vector3fImmutable insideLoc) {
 
-        return insideLoc.isInsideCircle(this.getLoc(), CityBoundsType.ZONE.extents);
+        return insideLoc.isInsideCircle(this.getLoc(), CityBoundsType.SIEGEBOUNDS.extents);
 
     }
 

src/engine/objects/Contract.java

@@ -608,52 +608,62 @@ public class Contract extends AbstractGameObject {
                     case 250019:
                     case 250028:
                     case 250037:
-                        me.magicValue = 3000000;
+                        me.magicValue = 1000000;
                         break;
                     case 250002: //10 stats
                     case 250011:
                     case 250020:
                     case 250029:
                     case 250038:
-                        me.magicValue = 4000000;
+                        me.magicValue = 2000000;
                         break;
                     case 250003: //15 stats
                     case 250012:
                     case 250021:
                     case 250030:
                     case 250039:
-                        me.magicValue = 5000000;
+                        me.magicValue = 3000000;
                         break;
                     case 250004: //20 stats
                     case 250013:
                     case 250022:
                     case 250031:
                     case 250040:
-                        me.magicValue = 6000000;
+                        me.magicValue = 4000000;
                         break;
                     case 250005: //25 stats
                     case 250014:
                     case 250023:
                     case 250032:
                     case 250041:
-                        me.magicValue = 7000000;
+                        me.magicValue = 5000000;
                         break;
                     case 250006: //30 stats
                     case 250015:
                     case 250024:
                     case 250033:
                     case 250042:
-                        me.magicValue = 8000000;
+                        me.magicValue = 6000000;
                         break;
                     case 250007: //35 stats
                     case 250016:
                     case 250025:
                     case 250034:
                     case 250043:
-                        me.magicValue = 9000000;
+                        me.magicValue = 7000000;
+                        break;
+                    case 250008: //40 stats
+                    case 250017:
+                    case 250026:
+                    case 250035:
+                    case 250044:
+                        me.magicValue = 10000000;
+                        break;
+                    case 252127:
+                        me.magicValue = 5000000;
                         break;
                     default:
-                        me.magicValue = 10000000;
+                        me.magicValue = 1000000;
                         break;
                 }
             }
@@ -727,6 +737,9 @@ public class Contract extends AbstractGameObject {
         if (this.allowedBuildings.size() == 0)
             return false;
 
+        if(this.name.equals("Siege Engineer") && building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.SIEGETENT))
+            return true;
+
         // Binary match
         return (building.getBlueprint().getBuildingGroup().elementOf(this.allowedBuildings));
     }

src/engine/objects/ForgeWorkOrder.java

@@ -0,0 +1,11 @@
+package engine.objects;
+
+public class ForgeWorkOrder {
+    public int itembaseUUID;
+    public String prefix;
+    public String suffix;
+    public boolean resourceRolled;
+    public boolean randomRolled;
+    public int orderAmount;
+    public int slot;
+}

src/engine/objects/Item.java

@@ -818,15 +818,65 @@ public class Item extends AbstractWorldObject {
     }
 
     public void stripCastableEnchants(){
-        ArrayList<Effect> ToRemove = new ArrayList<>();
-        for(Effect eff : this.effects.values()){
-            if(eff.getJobContainer() != null && !eff.getJobContainer().noTimer()){
+        try {
+            //strip EnchantWeapon
+            if(this.effects.get("EnchantWeapon") != null){
+                this.effects.remove("EnchantWeapon");
+                Effect eff = this.effects.get("EnchantWeapon");
                 eff.endEffectNoPower();
-                eff.getJobContainer().cancelJob();
-                ToRemove.add(eff);
             }
+
+            //strip FGM-003
+            if(this.effects.get("1000") != null){
+                this.effects.remove("1000");
+                Effect eff = this.effects.get("1000");
+                eff.endEffectNoPower();
+            }
+
+            //strip FGM-001
+            if(this.effects.get("996") != null){
+                this.effects.remove("996");
+                Effect eff = this.effects.get("996");
+                eff.endEffectNoPower();
+            }
+
+            //strip ENC-001
+            if(this.effects.get("957") != null){
+                this.effects.remove("957");
+                Effect eff = this.effects.get("957");
+                eff.endEffectNoPower();
+            }
+            if(this.effects.get("958") != null){
+                this.effects.remove("958");
+                Effect eff = this.effects.get("958");
+                eff.endEffectNoPower();
+            }
+            if(this.effects.get("959") != null){
+                this.effects.remove("959");
+                Effect eff = this.effects.get("959");
+                eff.endEffectNoPower();
+            }
+            if(this.effects.get("960") != null){
+                this.effects.remove("960");
+                Effect eff = this.effects.get("960");
+                eff.endEffectNoPower();
+            }
+            if(this.effects.get("961") != null){
+                this.effects.remove("961");
+                Effect eff = this.effects.get("961");
+                eff.endEffectNoPower();
+            }
+            if(this.effects.get("962") != null){
+                this.effects.remove("962");
+                Effect eff = this.effects.get("962");
+                eff.endEffectNoPower();
+            }
+
+            this.applyAllBonuses();
+            //this.effects.values().removeAll(ToRemove);
+        }catch(Exception ignored){
+
         }
-        this.effects.values().removeAll(ToRemove);
     }
     //Only to be used for trading
     public void setOwnerID(int ownerID) {

src/engine/objects/ItemBase.java

@@ -259,51 +259,53 @@ public class ItemBase {
             case 250019:
             case 250028:
             case 250037:
-                return 3000000;
+                return 1000000;
             case 250002: //10 stats
             case 250011:
             case 250020:
             case 250029:
             case 250038:
-                return 4000000;
+                return 2000000;
             case 250003: //15 stats
             case 250012:
             case 250021:
             case 250030:
             case 250039:
-                return 5000000;
+                return 3000000;
             case 250004: //20 stats
             case 250013:
             case 250022:
             case 250031:
             case 250040:
-                return 6000000;
+                return 4000000;
             case 250005: //25 stats
             case 250014:
             case 250023:
             case 250032:
             case 250041:
-                return 7000000;
+                return 5000000;
             case 250006: //30 stats
             case 250015:
             case 250024:
             case 250033:
             case 250042:
-                return 8000000;
+                return 6000000;
             case 250007: //35 stats
             case 250016:
             case 250025:
             case 250034:
             case 250043:
-                return 9000000;
+                return 7000000;
             case 250008: //40 stats
             case 250017:
             case 250026:
             case 250035:
             case 250044:
                 return 10000000;
+            case 252127:
+                return 5000000;
         }
-        return 10000000;
+        return 1000000;
     }
 
     /*

src/engine/objects/ItemFactory.java

@@ -710,6 +710,8 @@ public class ItemFactory {
             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)
@@ -727,6 +729,8 @@ public class ItemFactory {
             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)

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,10 @@ public class Mine extends AbstractGameObject {
     public HashMap<Integer,Integer> oldBuildings;
     public HashMap<Integer, Long> mineAttendees = new HashMap<>();
 
+    public Long allowed_teleport_time;
+    public Boolean enforceLore = false;
+    public HashMap<Guild, Enum.GuildType> chosen_charters;
+
     /**
      * ResultSet Constructor
      */
@@ -131,6 +137,11 @@ public class Mine extends AbstractGameObject {
             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 +218,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 +350,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 +436,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 +608,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)
@@ -673,7 +685,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

@@ -111,6 +111,8 @@ public class Mob extends AbstractIntelligenceAgent {
     public boolean StrongholdEpic = false;
     public boolean isDropper = false;
 
+    public HashMap<PlayerCharacter,Float> hate_values;
+
 
     /**
      * No Id Constructor
@@ -1450,6 +1452,7 @@ public class Mob extends AbstractIntelligenceAgent {
         this.stopPatrolTime = 0;
         this.lastPatrolPointIndex = 0;
         InterestManager.setObjectDirty(this);
+        this.hate_values = new HashMap<>();
     }
 
     public void despawn() {

src/engine/objects/PlayerCharacter.java

@@ -41,6 +41,7 @@ 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;
@@ -2957,6 +2958,7 @@ public class PlayerCharacter extends AbstractCharacter {
     }
 
     public synchronized void grantXP(int xp) {
+        xp *= LootManager.NORMAL_EXP_RATE;
         int groupSize = 1;
         if(GroupManager.getGroup(this)!= null)
             groupSize = GroupManager.getGroup(this).members.size();
@@ -5159,7 +5161,11 @@ public class PlayerCharacter extends AbstractCharacter {
                         if (this.combatStats == null) {
                             this.combatStats = new PlayerCombatStats(this);
                         } else {
-                            this.combatStats.update();
+                            try {
+                                this.combatStats.update();
+                            }catch(Exception ignored){
+
+                            }
                         }
                         this.doRegen();
                     }
@@ -5174,45 +5180,16 @@ public class PlayerCharacter extends AbstractCharacter {
                     this.updateBlessingMessage();
 
                     this.safeZone = this.isInSafeZone();
-                    if (!this.timestamps.containsKey("nextBoxCheck"))
-                        this.timestamps.put("nextBoxCheck", System.currentTimeMillis() + 10000);
 
-                    if (!this.isBoxed && this.timestamps.get("nextBoxCheck") < System.currentTimeMillis()) {
-                        this.isBoxed = checkIfBoxed(this);
-                        this.timestamps.put("nextBoxCheck", System.currentTimeMillis() + 10000);
-                    }
+                    if(this.isActive && this.enteredWorld)
+                        if (this.level < 10)
+                            while (this.level < 10)
+                                grantXP(Experience.getBaseExperience(this.level + 1) - this.exp);
 
-                    if (this.level < 10 && this.enteredWorld) {
-                        while (this.level < 10) {
-                            grantXP(Experience.getBaseExperience(this.level + 1) - this.exp);
-                        }
-                    }
+                    this.auditBoxedStatus();
 
-                    if (this.isBoxed && !this.containsEffect(1672601862)) {
-                        PowersManager.applyPower(this, this, Vector3fImmutable.ZERO, 1672601862, 40, false);
-                    }
-
-                    if (this.isFlying()) {
-                        if (this.effects.containsKey("MoveBuff")) {
-                            GroundPlayer(this);
-                        }
-                        if (!this.timestamps.containsKey("StunGrounded"))
-                            this.timestamps.put("StunGrounded", System.currentTimeMillis() - 1000L);
-                        if (this.bonuses.getBool(ModType.Stunned, SourceType.None) && this.timestamps.get("StunGrounded") < System.currentTimeMillis()) {
-                            boolean isFlyMoving = this.getDesiredAltitude() != this.altitude;
-                            if (!isFlyMoving && this.bonuses.getBool(ModType.Stunned, SourceType.None)) {
-                                this.setDesiredAltitude(this.altitude - 10);
-                                this.setTakeOffTime(System.currentTimeMillis());
-
-                                ChangeAltitudeMsg msg = new ChangeAltitudeMsg(this.getObjectType().ordinal(), this.getObjectUUID(), false, this.getAltitude(), this.getDesiredAltitude(), this.getAltitude());
-                                // force a landing
-                                DispatchMessage.dispatchMsgToInterestArea(this, msg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
-                                this.timestamps.put("StunGrounded", System.currentTimeMillis() + 1500L);
-                                ChatManager.chatSystemInfo(this, "Applying 1 Tier Ground");
-                            }
-                        }
-
-                    }
+                    if (this.isFlying())
+                        this.auditFlightStatus();
 
                 } catch (Exception e) {
                     Logger.error(e);
@@ -5224,6 +5201,67 @@ public class PlayerCharacter extends AbstractCharacter {
             Logger.error("UPDATE ISSUE: " + e);
         }
     }
+
+    public void auditBoxedStatus(){
+
+        if (!this.timestamps.containsKey("nextBoxCheck")) {
+            this.timestamps.put("nextBoxCheck", System.currentTimeMillis());
+            return;
+        }
+
+        if(this.timestamps.get("nextBoxCheck") > System.currentTimeMillis())
+            return;
+
+        this.timestamps.put("nextBoxCheck", System.currentTimeMillis() + 3000);
+
+        //DS: 1672601862
+        if(this.isBoxed){
+            if(this.getPromotionClassID() == 2511) {//fury cannot be PVE anymore, fuck them
+                if (!this.containsEffect(1672601862))
+                    PowersManager.applyPower(this, this, Vector3fImmutable.ZERO, 1672601862, 40, false);
+            }else {
+                if (!this.containsEffect(-654906771))
+                    PowersManager.applyPower(this, this, Vector3fImmutable.ZERO, -935138707, 40, false);
+            }
+        }else{
+            if(this.getPromotionClassID() == 2511) {//fury cannot be PVE anymore, fuck them
+                if (this.containsEffect(1672601862)) {
+                    this.removeEffectBySource(EffectSourceType.DeathShroud,41,false);
+                }
+            }else {
+                if (this.containsEffect(-654906771)) {
+                    try {
+                        this.effects.get("1258").endEffect();
+                        //this.effects.remove("1258");
+                    } catch (Exception ignored) {
+
+                    }
+                }
+            }
+        }
+    }
+
+    public void auditFlightStatus(){
+        if (this.effects.containsKey("MoveBuff")) {
+            GroundPlayer(this);
+        }
+        if (!this.timestamps.containsKey("StunGrounded"))
+            this.timestamps.put("StunGrounded", System.currentTimeMillis() - 1000L);
+        if (this.bonuses.getBool(ModType.Stunned, SourceType.None) && this.timestamps.get("StunGrounded") < System.currentTimeMillis()) {
+            boolean isFlyMoving = this.getDesiredAltitude() != this.altitude;
+            if (!isFlyMoving && this.bonuses.getBool(ModType.Stunned, SourceType.None)) {
+                this.setDesiredAltitude(this.altitude - 10);
+                this.setTakeOffTime(System.currentTimeMillis());
+
+                ChangeAltitudeMsg msg = new ChangeAltitudeMsg(this.getObjectType().ordinal(), this.getObjectUUID(), false, this.getAltitude(), this.getDesiredAltitude(), this.getAltitude());
+                // force a landing
+                DispatchMessage.dispatchMsgToInterestArea(this, msg, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
+                this.timestamps.put("StunGrounded", System.currentTimeMillis() + 1500L);
+                ChatManager.chatSystemInfo(this, "Applying 1 Tier Ground");
+            }
+        }
+    }
+
     public static void unboxPlayer(PlayerCharacter player){
         String machineID = player.getClientConnection().machineID;
         ArrayList<PlayerCharacter> sameMachine = new ArrayList<>();
@@ -5233,21 +5271,17 @@ public class PlayerCharacter extends AbstractCharacter {
             }
         }
 
-        boolean valid = true;
-        for(PlayerCharacter pc : sameMachine){
-            if(!pc.safeZone)
-                valid = false;
+        for (PlayerCharacter pc : sameMachine) {
+            PowersManager.applyPower(pc, pc, Vector3fImmutable.ZERO, -935138707, 40, false);
+            pc.isBoxed = true;
         }
-        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");
+        player.isBoxed = false;
+        try{
+            player.effects.get("1258").endEffect();
+            //this.effects.remove("1258");
+        }catch(Exception ignored){
+
         }
     }
     public static boolean checkIfBoxed(PlayerCharacter player){
@@ -5660,6 +5694,8 @@ public class PlayerCharacter extends AbstractCharacter {
     }
 
     public void setEnteredWorld(boolean enteredWorld) {
+        if(enteredWorld)
+            this.timestamps.put("nextBoxCheck", System.currentTimeMillis() + 10000);
         this.enteredWorld = enteredWorld;
     }
 

src/engine/objects/PlayerCombatStats.java

@@ -1,10 +1,12 @@
 package engine.objects;
 
 import engine.Enum;
+import engine.jobs.DeferredPowerJob;
 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;
@@ -358,13 +360,22 @@ public class PlayerCombatStats {
 
         float stanceValue = 0.0f;
         float atrEnchants = 0;
-
+        float healerDefStance = 0.0f;
         for(String effID : this.owner.effects.keySet()) {
             if (effID.contains("Stance")) {
                 Effect effect = this.owner.effects.get(effID);
                 EffectsBase eb = effect.getEffectsBase();
-                if(eb.getIDString().equals("STC-H-DA"))
+                if(eb.getIDString().equals("STC-H-DA")){
+                    for (AbstractEffectModifier mod : this.owner.effects.get(effID).getEffectModifiers()) {
+                        if (mod.modType.equals(Enum.ModType.OCV)) {
+                            float percent = mod.getPercentMod();
+                            int trains = this.owner.effects.get(effID).getTrains();
+                            float modValue = percent + (trains * mod.getRamp());
+                            healerDefStance += modValue * 0.01f;
+                        }
+                    }
                     continue;
+                }
                 for (AbstractEffectModifier mod : this.owner.effects.get(effID).getEffectModifiers()) {
                     if (mod.modType.equals(Enum.ModType.OCV)) {
                         float percent = mod.getPercentMod();
@@ -374,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());
                 }
             }
         }
@@ -424,15 +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);
-            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);
             }
-            atr *= modifier;
+            modifier -= healerDefStance;
+            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);
 
@@ -506,6 +541,7 @@ public class PlayerCombatStats {
         );
         if(this.owner.bonuses != null){
             minDMG += this.owner.bonuses.getFloat(Enum.ModType.MinDamage, Enum.SourceType.None);
+            minDMG += this.owner.bonuses.getFloat(Enum.ModType.MeleeDamageModifier, Enum.SourceType.None);
             minDMG *= 1 + this.owner.bonuses.getFloatPercentAll(Enum.ModType.MeleeDamageModifier, Enum.SourceType.None);
         }
 
@@ -586,6 +622,7 @@ public class PlayerCombatStats {
 
         if(this.owner.bonuses != null){
             maxDMG += this.owner.bonuses.getFloat(Enum.ModType.MaxDamage, Enum.SourceType.None);
+            maxDMG += this.owner.bonuses.getFloat(Enum.ModType.MeleeDamageModifier, Enum.SourceType.None);
             maxDMG *= 1 + this.owner.bonuses.getFloatPercentAll(Enum.ModType.MeleeDamageModifier, Enum.SourceType.None);
         }
 
@@ -620,43 +657,20 @@ public class PlayerCombatStats {
         }else {
             weapon = this.owner.charItemManager.getEquipped(2);
         }
-        float delayExtra = 0;
-        if(weapon == null) {
-            speed = 20.0f;
-        }else{
-            speed = weapon.getItemBase().getSpeed();
-            for(Effect eff : weapon.effects.values()){
-                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
-                    if(mod.modType.equals(Enum.ModType.WeaponSpeed) || mod.modType.equals(Enum.ModType.AttackDelay)){
-                        float percent = mod.getPercentMod();
-                        int trains = eff.getTrains();
-                        float modValue = percent + (trains * mod.getRamp());
-                        speed *= 1 + (modValue * 0.01f);
-                    }
-                }
-            }
-        }
-        if(this.owner.charItemManager.getEquipped(1) != null){
-            for(Effect eff : this.owner.charItemManager.getEquipped(1).effects.values()){
-                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
-                    if(mod.modType.equals(Enum.ModType.AttackDelay)){
-                        float percent = mod.getPercentMod();
-                        int trains = eff.getTrains();
-                        float modValue = percent + (trains * mod.getRamp());
-                        delayExtra += modValue * 0.01f;
-                    }
-                }
-            }
-        }
-        if(this.owner.charItemManager.getEquipped(2) != null){
-            for(Effect eff : this.owner.charItemManager.getEquipped(2).effects.values()){
-                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
-                    if(mod.modType.equals(Enum.ModType.AttackDelay)){
-                        float percent = mod.getPercentMod();
-                        int trains = eff.getTrains();
-                        float modValue = percent + (trains * mod.getRamp());
-                        delayExtra += modValue * 0.01f;
-                    }
+
+        speed = weapon.getModifiedSpeed();
+
+        for(String effID : this.owner.effects.keySet()){
+            Effect eff = this.owner.effects.get(effID);
+            if(eff == null)
+                continue;
+            for(AbstractEffectModifier mod : eff.getEffectModifiers()){
+                if(mod.modType.equals(Enum.ModType.AttackDelay) && !effID.contains("Stance")){
+                    float base = mod.getPercentMod();
+                    if(mod.getRamp() != 0)
+                        base += (mod.getRamp() * eff.getTrains());
+                    base *= 0.01f;
+                    speed *= (1 + base);
                 }
             }
         }
@@ -676,11 +690,7 @@ public class PlayerCombatStats {
                 }
             }
         }
-
-        float bonusValues = 1 + this.owner.bonuses.getFloatPercentAll(Enum.ModType.AttackDelay,Enum.SourceType.None);//1.0f;
-        bonusValues -= stanceValue + delayExtra; // take away stance modifier from alacrity bonus values
         speed *= 1 + stanceValue; // apply stance bonus
-        speed *= bonusValues; // apply alacrity bonuses without stance mod
 
         if(speed < 10.0f)
             speed = 10.0f;
@@ -766,16 +776,20 @@ public class PlayerCombatStats {
             blockSkill = this.owner.skills.get("Block").getModifiedAmount();
 
         float shieldDefense = 0.0f;
-        if(this.owner.charItemManager.getEquipped(2) != null && this.owner.charItemManager.getEquipped(2).getItemBase().isShield()){
-            Item shield = this.owner.charItemManager.getEquipped(2);
-            shieldDefense += shield.getItemBase().getDefense();
-            for(Effect eff : shield.effects.values()){
-                for(AbstractEffectModifier mod : eff.getEffectModifiers()){
-                    if(mod.modType.equals(Enum.ModType.DR)){
-                        shieldDefense += mod.minMod + (mod.getRamp() * eff.getTrains());
+        try {
+            if (this.owner.charItemManager.getEquipped(2) != null && this.owner.charItemManager.getEquipped(2).getItemBase().isShield()) {
+                Item shield = this.owner.charItemManager.getEquipped(2);
+                shieldDefense += shield.getItemBase().getDefense();
+                for (Effect eff : shield.effects.values()) {
+                    for (AbstractEffectModifier mod : eff.getEffectModifiers()) {
+                        if (mod.modType.equals(Enum.ModType.DR)) {
+                            shieldDefense += mod.minMod + (mod.getRamp() * eff.getTrains());
+                        }
                     }
                 }
             }
+        }catch(Exception ignore){
+
         }
 
         float weaponSkill = 0.0f;
@@ -838,9 +852,10 @@ public class PlayerCombatStats {
 
         //right ring
         if(this.owner.charItemManager != null){
+            try{
             if(this.owner.charItemManager.getEquipped(7) != null){
                 for(String effID : this.owner.charItemManager.getEquipped(7).effects.keySet()) {
-                    for (AbstractEffectModifier mod : this.owner.effects.get(effID).getEffectModifiers()) {
+                    for (AbstractEffectModifier mod : this.owner.charItemManager.getEquipped(7).effects.get(effID).getEffectModifiers()) {
                         if (mod.modType.equals(Enum.ModType.DCV)) {
                             if (mod.getPercentMod() == 0) {
                                 float value = mod.getMinMod();
@@ -852,27 +867,33 @@ public class PlayerCombatStats {
                     }
                 }
             }
+            }catch(Exception e){
 
+            }
             //left ring
-            if(this.owner.charItemManager.getEquipped(8) != null){
-                for(String effID : this.owner.charItemManager.getEquipped(8).effects.keySet()) {
-                    for (AbstractEffectModifier mod : this.owner.effects.get(effID).getEffectModifiers()) {
-                        if (mod.modType.equals(Enum.ModType.DCV)) {
-                            if (mod.getPercentMod() == 0) {
-                                float value = mod.getMinMod();
-                                int trains = this.owner.effects.get(effID).getTrains();
-                                float modValue = value + (trains * mod.getRamp());
-                                flatBonuses += modValue;
+            try {
+                if (this.owner.charItemManager.getEquipped(8) != null) {
+                    for (String effID : this.owner.charItemManager.getEquipped(8).effects.keySet()) {
+                        for (AbstractEffectModifier mod : this.owner.charItemManager.getEquipped(8).effects.get(effID).getEffectModifiers()) {
+                            if (mod.modType.equals(Enum.ModType.DCV)) {
+                                if (mod.getPercentMod() == 0) {
+                                    float value = mod.getMinMod();
+                                    int trains = this.owner.effects.get(effID).getTrains();
+                                    float modValue = value + (trains * mod.getRamp());
+                                    flatBonuses += modValue;
+                                }
                             }
                         }
                     }
                 }
-            }
+            }catch(Exception e){
 
+            }
             //necklace
+            try{
             if(this.owner.charItemManager.getEquipped(9) != null){
                 for(String effID : this.owner.charItemManager.getEquipped(9).effects.keySet()) {
-                    for (AbstractEffectModifier mod : this.owner.effects.get(effID).getEffectModifiers()) {
+                    for (AbstractEffectModifier mod : this.owner.charItemManager.getEquipped(9).effects.get(effID).getEffectModifiers()) {
                         if (mod.modType.equals(Enum.ModType.DCV)) {
                             if (mod.getPercentMod() == 0) {
                                 float value = mod.getMinMod();
@@ -884,12 +905,20 @@ public class PlayerCombatStats {
                     }
                 }
             }
+            }catch(Exception e){
+
+            }
+            try{
+            if(this.owner.charItemManager.getEquipped(2) == null)
+                blockSkill = 0;
+            else if(this.owner.charItemManager != null && this.owner.charItemManager.getEquipped(2) != null && !this.owner.charItemManager.getEquipped(2).getItemBase().isShield())
+                blockSkill = 0;
+            }catch(Exception e){
+
+            }
         }
 
-        if(this.owner.charItemManager.getEquipped(2) == null)
-            blockSkill = 0;
-        else if(this.owner.charItemManager != null && this.owner.charItemManager.getEquipped(2) != null && !this.owner.charItemManager.getEquipped(2).getItemBase().isShield())
-            blockSkill = 0;
+
 
         float defense = (1 + armorSkill / 50) * armorDefense;
         defense += (1 + blockSkill / 100) * shieldDefense;
@@ -982,12 +1011,22 @@ public class PlayerCombatStats {
         float stanceMod = 1.0f;
         float atrBuffs = 0.0f;
 
+        float healerDefStance = 0.0f;
         for(String effID : pc.effects.keySet()) {
             if (effID.contains("Stance")) {
                 Effect effect = pc.effects.get(effID);
                 EffectsBase eb = effect.getEffectsBase();
-                if(eb.getIDString().equals("STC-H-DA"))
+                if(eb.getIDString().equals("STC-H-DA")){
+                    for (AbstractEffectModifier mod : pc.effects.get(effID).getEffectModifiers()) {
+                        if (mod.modType.equals(Enum.ModType.OCV)) {
+                            float percent = mod.getPercentMod();
+                            int trains = pc.effects.get(effID).getTrains();
+                            float modValue = percent + (trains * mod.getRamp());
+                            healerDefStance += modValue * 0.01f;
+                        }
+                    }
                     continue;
+                }
                 for (AbstractEffectModifier mod : pc.effects.get(effID).getEffectModifiers()) {
                     if (mod.modType.equals(Enum.ModType.OCV)) {
                         float percent = mod.getPercentMod();
@@ -1014,9 +1053,28 @@ public class PlayerCombatStats {
         atr += (modifiedDexterity * 0.5f) + weaponATR1 + weaponATR2;
         atr *= precise;
         atr += atrBuffs;
+
+        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));
-        atr *= stanceMod;
+            bonuses = pc.bonuses.getFloatPercentAll(Enum.ModType.OCV, Enum.SourceType.None) - subtraction - weaponMoveBonus;
+
+        atr *= 1+ bonuses;
+        atr *= stanceMod - healerDefStance;
         return atr;
     }
 

src/engine/objects/Portal.java

@@ -6,6 +6,7 @@ import engine.InterestManagement.WorldGrid;
 import engine.gameManager.ConfigManager;
 import engine.job.JobScheduler;
 import engine.jobs.CloseGateJob;
+import engine.math.Vector3f;
 import engine.math.Vector3fImmutable;
 import engine.server.MBServerStatics;
 
@@ -104,7 +105,7 @@ public class Portal {
         if (player.getTimeStamp("lastMoveGate") < this.lastActive)
             return;
 
-        player.teleport(targetGate.getLoc());
+        player.teleport(targetGate.getLoc().add(new Vector3f(0f,6f,0f)));
         player.setSafeMode();
 
     }

src/engine/powers/ActionsBase.java

@@ -9,6 +9,7 @@
 
 package engine.powers;
 
+import engine.Enum;
 import engine.Enum.ModType;
 import engine.Enum.SourceType;
 import engine.Enum.StackType;
@@ -237,32 +238,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/RangeBasedAwo.java

@@ -78,7 +78,7 @@ public class RangeBasedAwo implements Comparable<RangeBasedAwo> {
             AbstractWorldObject awo = rba.awo;
 
             if (awo.getObjectType().equals(GameObjectType.PlayerCharacter))
-                if (((PlayerCharacter) awo).isCSR())
+                if (((PlayerCharacter) awo).getAccount().status.equals(Enum.AccountStatus.ADMIN))
                     continue;
 
             if (AbstractWorldObject.IsAbstractCharacter(awo) && !(pc.equals(awo))) {

src/engine/powers/effectmodifiers/HealthEffectModifier.java

@@ -176,7 +176,8 @@ public class HealthEffectModifier extends AbstractEffectModifier {
         }
 
         if(source.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)){
-            modAmount *= ((PlayerCharacter)source).ZergMultiplier;
+            float multiplier = ((PlayerCharacter)source).ZergMultiplier;
+            modAmount *= multiplier;
         }
 
         if (modAmount == 0f)

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,8 @@ 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 final int BUILDING_GOLD_LIMIT = 100000000;
     public static boolean DEBUG_PROTOCOL = false;
     public static int SPATIAL_HASH_BUCKETSX = 16384;
     public static int SPATIAL_HASH_BUCKETSY = 12288;

src/engine/server/login/LoginServer.java

@@ -281,6 +281,9 @@ public class LoginServer {
         Logger.info("Loading All Realms");
         Realm.loadAllRealms();
 
+        Logger.info("Trashing Multibox Cheaters");
+        DbManager.AccountQueries.TRASH_CHEATERS();
+
         Logger.info("***Boot Successful***");
         return true;
     }

src/engine/server/world/WorldServer.java

@@ -174,7 +174,7 @@ public class WorldServer {
 				}
 			}
 			//outString += " pop: " + SessionManager.getActivePlayerCharacterCount() + " max pop: " + SessionManager._maxPopulation;
-			outString += "Active Players: " + activePop + " Boxed Players: " + boxedPop;
+			outString += " Active Players: " + activePop + " Boxed Players: " + boxedPop;
 		} catch (Exception e) {
 			Logger.error("Failed to build string");
 		}

src/engine/workthreads/BaneThread.java

@@ -13,6 +13,7 @@ import engine.Enum;
 import engine.InterestManagement.WorldGrid;
 import engine.db.archive.DataWarehouse;
 import engine.db.archive.MineRecord;
+import engine.gameManager.BaneManager;
 import engine.gameManager.BuildingManager;
 import engine.gameManager.ChatManager;
 import engine.gameManager.StrongholdManager;
@@ -27,44 +28,20 @@ import java.util.ArrayList;
 
 public class BaneThread implements Runnable {
 
-    private volatile Long lastRun;
     public static final Long instancedelay = 1000L;
     public BaneThread() {
         Logger.info(" BaneThread thread has started!");
     }
 
 
-    public void processBanesWindow() {
-
-        try {
-            synchronized (Bane.banes) {
-                for (int baneId : Bane.banes.keySet()) {
-                    Bane bane = Bane.banes.get(baneId);
-                    if (bane != null && bane.getSiegePhase().equals(Enum.SiegePhase.WAR)) {
-                        bane.applyZergBuffs();
-                    }
-                }
-            }
-        } catch (Exception e) {
-            Logger.error("BANE ERROR",e);
-        }
-
-
-    }
-
     public void run() {
-        lastRun = System.currentTimeMillis();
         while (true) {
-            if (System.currentTimeMillis() >= lastRun + instancedelay) { // Correct condition
-                this.processBanesWindow();
-                lastRun = System.currentTimeMillis(); // Update lastRun after processing
-            }else {
-                try {
-                    Thread.sleep(100); // Pause for 100ms to reduce CPU usage
-                } catch (InterruptedException e) {
-                    Logger.error("Thread interrupted", e);
-                    Thread.currentThread().interrupt();
-                }
+            try {
+                BaneManager.pulse_banes();
+                Thread.sleep(1000); // Pause for 100ms to reduce CPU usage
+            } catch (InterruptedException e) {
+                Logger.error("Thread interrupted", e);
+                Thread.currentThread().interrupt();
             }
         }
     }

src/engine/workthreads/HourlyJobThread.java

@@ -92,10 +92,34 @@ public class HourlyJobThread implements Runnable {
         Logger.info(MessageDispatcher.getNetstatString());
         Logger.info(PurgeOprhans.recordsDeleted.toString() + "orphaned items deleted");
 
-        for (Bane bane : Bane.banes.values()){
-            if(bane.getSiegePhase().equals(Enum.SiegePhase.CHALLENGE)){
-                bane.setDefaultTime();
+        //for (Bane bane : Bane.banes.values()){
+        //    if(bane.getSiegePhase().equals(Enum.SiegePhase.CHALLENGE)){
+        //        bane.setDefaultTime();
+        //    }
+        //}
+
+        try{
+            Logger.info("Trashing Multibox Cheaters");
+            DbManager.AccountQueries.TRASH_CHEATERS();
+
+            //disconnect all players who were banned and are still in game
+            for(PlayerCharacter pc : SessionManager.getAllActivePlayers()){
+                Account account = pc.getClientConnection().getAccount();
+                if(account == null)
+                    continue;
+                try {
+                    boolean banned = DbManager.AccountQueries.GET_ACCOUNT(account.getUname()).status.equals(Enum.AccountStatus.BANNED);
+                    if (banned) {
+                        pc.getClientConnection().forceDisconnect();
+                    }
+                }catch(Exception e){
+                    Logger.error(e.getMessage());
+                }
             }
+        }catch(Exception e){
+            Logger.error("Failed To Run Ban Multibox Abusers");
         }
+
+        BaneManager.default_check();
     }
 }