add 4 to attack range to match clients stopping short

src/engine/gameManager/CombatManager.java

@@ -12,7 +12,6 @@ import engine.job.JobContainer;
 import engine.job.JobScheduler;
 import engine.jobs.AttackJob;
 import engine.jobs.DeferredPowerJob;
-import engine.math.Vector3f;
 import engine.mbEnums;
 import engine.net.client.ClientConnection;
 import engine.net.client.msg.TargetedActionMsg;
@@ -48,7 +47,7 @@ public enum CombatManager {
     public static final int COMBAT_PARRY_ANIMATION = 299;
     public static final int COMBAT_DODGE_ANIMATION = 300;
 
-    public static void combatCycle(AbstractCharacter attacker, AbstractWorldObject target) {
+    public static void combatCycle(AbstractCharacter attacker, AbstractWorldObject target, long addedDelay) {
 
         //early exit checks
 
@@ -79,61 +78,58 @@ public enum CombatManager {
 
         if (mainWeapon == null && offWeapon == null) {
             //no weapons equipped, punch with both fists
-            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
+            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD,addedDelay);
             if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter))
-                processAttack(attacker, target, mbEnums.EquipSlotType.LHELD);
+                processAttack(attacker, target, mbEnums.EquipSlotType.LHELD,addedDelay);
             return;
         }
 
         if (mainWeapon != null && offWeapon == null) {
             //swing right hand only
-            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
+            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD,addedDelay);
             return;
         }
 
         if (mainWeapon == null && offWeapon != null && !offWeapon.template.item_skill_used.equals("Block")) {
             //swing left hand only
-            processAttack(attacker, target, mbEnums.EquipSlotType.LHELD);
+            processAttack(attacker, target, mbEnums.EquipSlotType.LHELD,addedDelay);
             return;
         }
 
         if (mainWeapon == null && offWeapon != null && offWeapon.template.item_skill_used.equals("Block")) {
             //no weapon equipped with a shield, punch with one hand
-            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
+            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD,addedDelay);
             return;
         }
 
         if (mainWeapon != null && offWeapon != null && offWeapon.template.item_skill_used.equals("Block")) {
             //one weapon equipped with a shield, swing with one hand
-            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
+            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD,addedDelay);
             return;
         }
 
         if (mainWeapon != null && offWeapon != null && !offWeapon.template.item_skill_used.equals("Block")) {
             //two weapons equipped, swing both hands
-            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
+            processAttack(attacker, target, mbEnums.EquipSlotType.RHELD,addedDelay);
             if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter))
-                processAttack(attacker, target, mbEnums.EquipSlotType.LHELD);
+                processAttack(attacker, target, mbEnums.EquipSlotType.LHELD,addedDelay);
         }
     }
 
-    public static void processAttack(AbstractCharacter attacker, AbstractWorldObject target, mbEnums.EquipSlotType slot) {
+    public static void processAttack(AbstractCharacter attacker, AbstractWorldObject target, mbEnums.EquipSlotType slot, long addedDelay) {
+
+        if (slot == null || target == null || attacker == null)
+            return;
 
         if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
             if (!attacker.isCombat())
                 return;
-
-            //check if this slot is on attack timer, if timer has passed clear it, else early exit
-            if(attacker.getTimers().containsKey("Attack"+slot.name()))
-                if(attacker.getTimers().get("Attack"+slot.name()).timeToExecutionLeft() <= 0)
-                    attacker.getTimers().remove("Attack"+slot.name());
-                else
-                    return;
         }
 
+        target.combatLock.writeLock().lock();
 
         // check if character is in range to attack target
-
+        try {
             PlayerBonuses bonus = attacker.getBonuses();
 
             float rangeMod = 1.0f;
@@ -156,12 +152,15 @@ public enum CombatManager {
 
             boolean inRange = false;
             if (AbstractCharacter.IsAbstractCharacter(target)) {
-            attackRange += ((AbstractCharacter)target).calcHitBox();
+                attackRange += ((AbstractCharacter) target).calcHitBox();
             } else {
-
+                //need to handle building attacks range calculations here
             }
 
-        if(attackRange > 15 && attacker.isMoving()){
+            attackRange += 4; // need to add 4 to the attack range to offset where the client stops short of legitimate range
+
+            float distance = target.loc.distance(attacker.loc);
+            if (attackRange > 25 && attacker.isMoving()) {
                 //cannot shoot bow while moving;
                 return;
             }
@@ -178,14 +177,14 @@ public enum CombatManager {
                         inRange = true;
                     break;
                 case Building:
-                if(attackRange > 15){
+                    if (attackRange > 15) {
                         float rangeSquared = (attackRange + target.getBounds().getHalfExtents().x) * (attackRange + target.getBounds().getHalfExtents().x);
                         //float distanceSquared = attacker.loc.distanceSquared(target.loc);
-                    if(distanceSquared < rangeSquared) {
+                        if (distanceSquared < rangeSquared) {
                             inRange = true;
                             break;
                         }
-                }else {
+                    } else {
                         float locX = target.loc.x - target.getBounds().getHalfExtents().x;
                         float locZ = target.loc.z - target.getBounds().getHalfExtents().y;
                         float sizeX = (target.getBounds().getHalfExtents().x + attackRange) * 2;
@@ -200,25 +199,33 @@ public enum CombatManager {
             //get delay for the auto attack job
             long delay = 5000;
 
-        if (weapon != null) {
+            //if (weapon != null) {
 
-            int wepSpeed = (int) (weapon.template.item_weapon_wepspeed);
+            //    int wepSpeed = (int) (weapon.template.item_weapon_wepspeed);
 
-            if (weapon.getBonusPercent(mbEnums.ModType.WeaponSpeed, mbEnums.SourceType.None) != 0f) //add weapon speed bonus
-                wepSpeed *= (1 + weapon.getBonus(mbEnums.ModType.WeaponSpeed, mbEnums.SourceType.None));
+            //    if (weapon.getBonusPercent(mbEnums.ModType.WeaponSpeed, mbEnums.SourceType.None) != 0f) //add weapon speed bonus
+            //        wepSpeed *= (1 + weapon.getBonus(mbEnums.ModType.WeaponSpeed, mbEnums.SourceType.None));
 
-            if (attacker.getBonuses() != null && attacker.getBonuses().getFloatPercentAll(mbEnums.ModType.AttackDelay, mbEnums.SourceType.None) != 0f) //add effects speed bonus
-                wepSpeed *= (1 + attacker.getBonuses().getFloatPercentAll(mbEnums.ModType.AttackDelay, mbEnums.SourceType.None));
+            //    if (attacker.getBonuses() != null && attacker.getBonuses().getFloatPercentAll(mbEnums.ModType.AttackDelay, mbEnums.SourceType.None) != 0f) //add effects speed bonus
+            //        wepSpeed *= (1 + attacker.getBonuses().getFloatPercentAll(mbEnums.ModType.AttackDelay, mbEnums.SourceType.None));
 
-            if (wepSpeed < 10)
-                wepSpeed = 10; //Old was 10, but it can be reached lower with legit buffs,effects.
+            //    if (wepSpeed < 10)
+             //       wepSpeed = 10; //Old was 10, but it can be reached lower with legit buffs,effects.
 
-            delay = wepSpeed * 100L;
+             //   delay = wepSpeed * 100L;
+            //}
+
+            if(attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)){
+                if(slot.equals(mbEnums.EquipSlotType.RHELD)){
+                    delay = (long)(attacker.speedHandOne * 100L);
+                }else{
+                    delay = (long)(attacker.speedHandTwo * 100L);
+                }
             }
 
             if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob))
                 ((Mob) attacker).nextAttackTime = System.currentTimeMillis() + delay;
-
+            delay += addedDelay;
             if (inRange) {
 
                 //handle retaliate
@@ -226,7 +233,7 @@ public enum CombatManager {
                     if (((AbstractCharacter) target).combatTarget == null || !((AbstractCharacter) target).combatTarget.isAlive()) {
                         ((AbstractCharacter) target).combatTarget = attacker;
                         if (target.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter) && ((AbstractCharacter) target).isCombat())
-                        combatCycle((AbstractCharacter) target, attacker);
+                            combatCycle((AbstractCharacter) target, attacker,0);
                     }
                 }
 
@@ -264,6 +271,22 @@ public enum CombatManager {
                     atr = attacker.atrHandTwo;
                 }
 
+                //apply weapon powers before early exit for miss or passives
+                DeferredPowerJob dpj = null;
+
+                if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
+
+                    dpj = ((PlayerCharacter) attacker).getWeaponPower();
+
+                    if (dpj != null) {
+                        dpj.attack(target, attackRange);
+
+                        if (dpj.getPower() != null && (dpj.getPowerToken() == -1851459567 || dpj.getPowerToken() == -1851489518))
+                            ((PlayerCharacter) attacker).setWeaponPower(dpj);
+                    }
+                }
+
+
                 int def = 0;
 
                 if (AbstractCharacter.IsAbstractCharacter(target))
@@ -293,7 +316,7 @@ public enum CombatManager {
                         DispatchManager.sendToAllInRange(attacker, msg);
 
                     //we need to send the animation even if the attacker misses
-                TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) 0, getSwingAnimation(weapon.template,null,slot));
+                    TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) 0, getSwingAnimation(weapon.template, null, slot));
                     DispatchManager.sendToAllInRange(target, cmm);
 
                     //set auto attack job
@@ -332,6 +355,9 @@ public enum CombatManager {
                         if (target.getObjectType() == mbEnums.GameObjectType.PlayerCharacter)
                             DispatchManager.dispatchMsgToInterestArea(target, msg, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
 
+                        //we need to send the animation even if the attacker misses
+                        TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) 0, getSwingAnimation(weapon.template, null, slot));
+                        DispatchManager.sendToAllInRange(target, cmm);
                         //set auto attack job
                         setAutoAttackJob(attacker, slot, delay);
                         return;
@@ -345,7 +371,7 @@ public enum CombatManager {
                     setAutoAttackJob(attacker, slot, delay);
                     return;
                 }
-            if(attacker.getObjectType().equals(mbEnums.GameObjectType.Mob) && ((Mob)attacker).isPet())
+                if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob) && ((Mob) attacker).isPet())
                     calculatePetDamage(attacker);
 
                 //get the damage type
@@ -414,11 +440,16 @@ public enum CombatManager {
 
                         if (resists.immuneTo(damageType)) {
                             //set auto attack job
+                            //we need to send the animation even if the attacker misses
+                            TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) 0, getSwingAnimation(weapon.template, null, slot));
+                            DispatchManager.sendToAllInRange(target, cmm);
                             setAutoAttackJob(attacker, slot, delay);
                             return;
                         }
                         //calculate resisted damage including fortitude
-
+                        if(attacker.getObjectType().equals(mbEnums.GameObjectType.Mob))
+                            if(((Mob)attacker).isPet())
+                                damage *= attacker.level * 0.1f;
                         damage = (int) resists.getResistedDamage(attacker, (AbstractCharacter) target, damageType, damage, 0);
                     }
                 }
@@ -446,23 +477,14 @@ public enum CombatManager {
                 }
             }
 
-        DeferredPowerJob dpj = null;
-
-        if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
-
-            dpj = ((PlayerCharacter) attacker).getWeaponPower();
-
-            if (dpj != null) {
-                dpj.attack(target, attackRange);
-
-                if (dpj.getPower() != null && (dpj.getPowerToken() == -1851459567 || dpj.getPowerToken() == -1851489518))
-                    ((PlayerCharacter) attacker).setWeaponPower(dpj);
-            }
-        }
-
             //set auto attack job
             setAutoAttackJob(attacker, slot, delay);
-
+        } catch (Exception ex) {
+            cancelAutoAttackJob(attacker,slot);
+            //Logger.error("COMBAT CAUGHT ERROR: " + ex.getMessage());
+        } finally {
+            target.combatLock.writeLock().unlock();
+        }
     }
 
     public static void toggleCombat(boolean toggle, ClientConnection origin) {
@@ -537,7 +559,7 @@ public enum CombatManager {
         }
 
         //Item has no equipment slots and should not try to return an animation, return default instead
-        if(wb.item_eq_slots_or == null || wb.item_eq_slots_or.size() == 0){
+        if(wb.item_eq_slots_or == null || wb.item_eq_slots_or.isEmpty()){
             return 75;
         }
 
@@ -596,6 +618,9 @@ public enum CombatManager {
     public static void setAutoAttackJob(AbstractCharacter attacker, mbEnums.EquipSlotType slot, long delay) {
         //calculate next allowed attack and update the timestamp
 
+        if(attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter) == false)
+            return; //mobs dont submit auto attack jobs
+
         if(attacker.getTimestamps().containsKey("Attack" + slot.name()) && attacker.getTimestamps().get("Attack" + slot.name()) > System.currentTimeMillis())
             return;
 
@@ -605,7 +630,7 @@ public enum CombatManager {
         ConcurrentHashMap<String, JobContainer> timers = attacker.getTimers();
 
         if (timers != null) {
-            AttackJob aj = new AttackJob(attacker, slot.ordinal(), true);
+            AttackJob aj = new AttackJob(attacker, slot.ordinal(), true, attacker.getCombatTarget());
             JobContainer job;
             job = JobScheduler.getInstance().scheduleJob(aj, (System.currentTimeMillis() + delay)); // offset 1 millisecond so no overlap issue
             timers.put("Attack" + slot.name(), job);
@@ -613,7 +638,22 @@ public enum CombatManager {
             Logger.error("Unable to find Timers for Character " + attacker.getObjectUUID());
 
     }
-    public static int calculatePetDamage(AbstractCharacter agent) {
+    public static void cancelAutoAttackJob(AbstractCharacter attacker, mbEnums.EquipSlotType slot) {
+
+        if(attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter) == false)
+            return;
+        attacker.getTimestamps().put("Attack" + slot.name(), System.currentTimeMillis());
+
+        //handle auto attack job creation
+        ConcurrentHashMap<String, JobContainer> timers = attacker.getTimers();
+
+        if (timers != null) {
+            timers.get("Attack" + slot.name()).cancelJob();
+        } else
+            Logger.error("Unable to find Timers for Character " + attacker.getObjectUUID());
+
+    }
+    public static void calculatePetDamage(AbstractCharacter agent) {
         //damage calc for pet
         float range;
         float damage;
@@ -625,7 +665,6 @@ public enum CombatManager {
         dmgMultiplier += agent.getLevel() * 0.1f;
         range = (float) (maxDmg - minDmg);
         damage = min + ((ThreadLocalRandom.current().nextFloat() * range) + (ThreadLocalRandom.current().nextFloat() * range)) / 2;
-        return (int) (damage * dmgMultiplier);
     }
     public static double getMinDmg(double min, AbstractCharacter agent) {
         int primary = agent.getStatStrCurrent();

src/engine/gameManager/ForgeManager.java

@@ -393,6 +393,12 @@ public enum ForgeManager implements Runnable {
         if (rollForModifier < 80) {
             int randomModifier = LootManager.TableRoll(vendor.getLevel(), false);
             modTableEntry = ModTableEntry.rollTable(modTypeTableEntry.modTableID, randomModifier);
+
+            // @TODO : Figure out how a null can be returned from a defined set.
+
+            if (modTableEntry == null)
+                return 0;
+
             EffectsBase effectsBase = PowersManager.getEffectByIDString(modTableEntry.action);
             modifier = effectsBase.getToken();
         }

src/engine/gameManager/PowersManager.java

@@ -172,7 +172,7 @@ public enum PowersManager {
     public static void usePower(final PerformActionMsg msg, ClientConnection origin,
                                 boolean sendCastToSelf) {
 
-        if (ConfigManager.MB_RULESET.getValue().equals("LORE")) {
+        if (ConfigManager.MB_RULESET.getValue().equals("LORE") && getPowerByToken(msg.getPowerUsedID()).ignoreLore() == false) {
             PowersBase pb = PowersManager.powersBaseByToken.get(msg.getPowerUsedID());
             PlayerCharacter caster = origin.getPlayerCharacter();
             PlayerCharacter target = PlayerCharacter.getFromCache(msg.getTargetID());

src/engine/jobs/AttackJob.java

@@ -12,6 +12,7 @@ package engine.jobs;
 import engine.gameManager.CombatManager;
 import engine.job.AbstractJob;
 import engine.objects.AbstractCharacter;
+import engine.objects.AbstractWorldObject;
 
 public class AttackJob extends AbstractJob {
 
@@ -19,16 +20,20 @@ public class AttackJob extends AbstractJob {
     private final int slot;
     private final boolean success;
 
-    public AttackJob(AbstractCharacter source, int slot, boolean success) {
+    public final AbstractWorldObject target;
+
+    public AttackJob(AbstractCharacter source, int slot, boolean success, AbstractWorldObject target) {
         super();
         this.source = source;
         this.slot = slot;
         this.success = success;
+        this.target = target;
     }
 
     @Override
     protected void doJob() {
-        CombatManager.combatCycle(this.source, this.source.combatTarget);
+
+        CombatManager.combatCycle(this.source,target,0);
     }
 
     public boolean success() {

src/engine/mobileAI/MobAI.java

@@ -109,7 +109,7 @@ public class MobAI {
                 return;
             }
 
-            if (mob.behaviourType.callsForHelp)
+            if (mob.behaviourType != null && mob.behaviourType.callsForHelp)
                 mobCallForHelp(mob);
 
             if (!MovementUtilities.inRangeDropAggro(mob, target)) {
@@ -125,7 +125,7 @@ public class MobAI {
                 if (mob.isMoving() && mob.getRange() > 20)
                     return;
 
-                CombatManager.combatCycle(mob, target);
+                CombatManager.combatCycle(mob, target,0);
             }
 
             if (target.getPet() != null)
@@ -159,7 +159,7 @@ public class MobAI {
                 MovementManager.sendRWSSMsg(mob);
 
 
-            CombatManager.combatCycle(mob, target);
+            CombatManager.combatCycle(mob, target,0);
 
             if (mob.isSiege()) {
                 PowerProjectileMsg ppm = new PowerProjectileMsg(mob, target);
@@ -175,13 +175,15 @@ public class MobAI {
     public static void attackMob(Mob mob, Mob target) {
 
         try {
+            if(mob == null || target == null)
+                return;
 
             if (mob.getRange() >= 30 && mob.isMoving())
                 return;
 
             //no weapons, default mob attack speed 3 seconds.
 
-            CombatManager.combatCycle(mob, target);
+            CombatManager.combatCycle(mob, target,0);
 
         } catch (Exception e) {
             Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: AttackMob" + " " + e.getMessage());

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

@@ -2,6 +2,7 @@ package engine.net.client.handlers;
 
 import engine.gameManager.BuildingManager;
 import engine.gameManager.CombatManager;
+import engine.jobs.AttackJob;
 import engine.mbEnums;
 import engine.net.client.ClientConnection;
 import engine.net.client.msg.AttackCmdMsg;
@@ -82,7 +83,29 @@ public class AttackCmdMsgHandler extends AbstractClientMsgHandler {
         if (playerCharacter.isSit())
             CombatManager.toggleSit(false, origin);
 
-        CombatManager.combatCycle(playerCharacter, target);
+        long addedDelay = 0;
+        //check if we are changing targets, cancel outstanding jobs if so
+        if (playerCharacter.getTimers().containsKey("Attack" + mbEnums.EquipSlotType.RHELD)) {
+            AttackJob ajR = ((AttackJob)playerCharacter.getTimers().get("Attack" + mbEnums.EquipSlotType.RHELD).getJob());
+            if(ajR.target != null && !ajR.target.equals(target)){
+                playerCharacter.getTimers().get("Attack" + mbEnums.EquipSlotType.RHELD).cancelJob();
+                addedDelay = ajR.getStopTime() - System.currentTimeMillis();
+            }else{
+                return true;
+            }
+        }
+
+        if (playerCharacter.getTimers().containsKey("Attack" + mbEnums.EquipSlotType.LHELD)) {
+            AttackJob ajL = ((AttackJob)playerCharacter.getTimers().get("Attack" + mbEnums.EquipSlotType.LHELD).getJob());
+            if(ajL.target != null && !ajL.target.equals(target)){
+                playerCharacter.getTimers().get("Attack" + mbEnums.EquipSlotType.LHELD).cancelJob();
+                addedDelay = ajL.getStopTime() - System.currentTimeMillis();
+            }else{
+                return true;
+            }
+        }
+
+        CombatManager.combatCycle(playerCharacter, target, addedDelay);
 
         return true;
     }

src/engine/objects/AbstractCharacter.java

@@ -31,6 +31,7 @@ import engine.net.client.msg.ApplyRuneMsg;
 import engine.net.client.msg.UpdateStateMsg;
 import engine.powers.EffectsBase;
 import engine.powers.PowersBase;
+import engine.powers.effectmodifiers.AbstractEffectModifier;
 import engine.server.MBServerStatics;
 import org.pmw.tinylog.Logger;
 
@@ -804,7 +805,25 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
         if (weapon != null)
             speed *= (1 + abstractCharacter.bonuses.getFloatPercentAll(ModType.WeaponSpeed, SourceType.None));
 
-        speed *= (1 + abstractCharacter.bonuses.getFloatPercentAll(ModType.AttackDelay, SourceType.None));
+        PlayerBonuses bonuses = abstractCharacter.bonuses;
+        if(bonuses != null){
+            ModType modType = ModType.AttackDelay;
+            for (AbstractEffectModifier mod : bonuses.bonusFloats.keySet()) {
+
+                if (mod.getPercentMod() == 0)
+                    continue;
+
+
+                if (!mod.modType.equals(modType))
+                    continue;
+
+                if (bonuses.bonusFloats.get(mod) == null)
+                    continue;
+
+                speed *= (1 + bonuses.bonusFloats.get(mod));
+            }
+        }
+        //speed *= (1 + abstractCharacter.bonuses.getFloatPercentAll(ModType.AttackDelay, SourceType.None));
 
         if (speed < 10)
             speed = 10;
@@ -1768,7 +1787,7 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
             final boolean fromCost) {
 
         try {
-
+            this.combatLock.writeLock().lock();
             try {
                 boolean ready = this.healthLock.writeLock().tryLock(1, TimeUnit.SECONDS);
 
@@ -1809,7 +1828,13 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
                     //handle hate value addition
                     Mob target = (Mob) this;
                     if (attacker.getObjectType().equals(GameObjectType.PlayerCharacter)) {
+
+                        if(target.playerAgroMap.containsKey(attacker.getObjectUUID()))
                             target.playerAgroMap.put(attacker.getObjectUUID(), target.playerAgroMap.get(attacker.getObjectUUID()) + value);
+                        else
+                            target.playerAgroMap.put(attacker.getObjectUUID(), value);
+
+
                         if (target.isPlayerGuard()) {
                             if (target.guardedCity != null && target.guardedCity.cityOutlaws.contains(attacker.getObjectUUID()) == false)
                                 target.guardedCity.cityOutlaws.add(attacker.getObjectUUID());
@@ -1827,6 +1852,7 @@ public abstract class AbstractCharacter extends AbstractWorldObject {
                 return newHealth - oldHealth;
             } finally {
                 this.healthLock.writeLock().unlock();
+                this.combatLock.writeLock().unlock();
             }
         } catch (InterruptedException e) {
             // TODO Auto-generated catch block

src/engine/objects/AbstractWorldObject.java

@@ -59,6 +59,7 @@ public abstract class AbstractWorldObject extends AbstractGameObject {
     private Vector3f rot = new Vector3f(0.0f, 0.0f, 0.0f);
     private int objectTypeMask = 0;
     private Bounds bounds;
+    public ReentrantReadWriteLock combatLock = new ReentrantReadWriteLock();
 
     /**
      * No Id Constructor

src/engine/objects/City.java

@@ -410,10 +410,9 @@ public class City extends AbstractWorldObject {
                 if(city.cityName.equals("Perdition") || city.cityName.equals("Bastion"))
                     continue; // cannot repledge to perdition or bastion
                 if (city.isNpc == 1 && city.getGuild().charter.canJoin(playerCharacter)) {
-                    cities.add(city); // anyone of the same charter can teleport to a safehold of that charter
+                    if(city.isNoobIsle == 1 && playerCharacter.level >= 21)
                         continue;
-                } else if (city.isNoobIsle == 1 && playerCharacter.level <= 20) {
-                    cities.add(city); // everyone can go to noob island if they are under level 20
+                    cities.add(city); // anyone of the same charter can teleport to a safehold of that charter
                     continue;
                 } else if (city.isOpen() && city.getTOL().rank > 4 && city.getGuild().charter.canJoin(playerCharacter))
                     if (!city.getTOL().reverseKOS) {
@@ -640,17 +639,17 @@ public class City extends AbstractWorldObject {
     public Guild getGuild() {
 
         if (this.getTOL() == null)
-            return null;
+            return Guild.getErrantGuild();
 
         if (this.isNpc == 1) {
 
             if (this.getTOL().getOwner() == null)
-                return null;
+                return Guild.getErrantGuild();
             return this.getTOL().getOwner().getGuild();
         } else {
 
             if (this.getTOL().getOwner() == null)
-                return null;
+                return Guild.getErrantGuild();
             return this.getTOL().getOwner().getGuild();
         }
     }

src/engine/objects/PlayerBonuses.java

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

src/engine/powers/PowersBase.java

@@ -633,4 +633,15 @@ public class PowersBase {
         return description;
     }
 
+    public boolean ignoreLore(){
+        switch(this.category){
+            case "HEAL":
+            case "BUFF":
+            case "DISPELL":
+            case "SUMMON":
+                return false;
+        }
+        return true;
+    }
+
 }