Using iterators for remove from knownlists.

L2_GameServer/java/com/l2jserver/gameserver/model/actor/knownlist/AirShipKnownList.java

@@ -18,27 +18,23 @@ import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.actor.L2Character;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
-
 /**
  * @author Kerberos
  *
  */
 public class AirShipKnownList extends CharKnownList
 {
-
-	/**
-	 * @param activeChar
-	 */
 	public AirShipKnownList(L2Character activeChar)
 	{
 		super(activeChar);
-		// TODO Auto-generated constructor stub
 	}
+
 	@Override
 	public int getDistanceToForgetObject(L2Object object)
     {
         if (!(object instanceof L2PcInstance))
             return 0;
+
         return 8000;
     }
 
@@ -47,7 +43,7 @@ public class AirShipKnownList extends CharKnownList
     {
         if (!(object instanceof L2PcInstance))
             return 0;
+
         return 4000;
     }
-
 }

L2_GameServer/java/com/l2jserver/gameserver/model/actor/knownlist/AttackableKnownList.java

@@ -17,7 +17,6 @@ package com.l2jserver.gameserver.model.actor.knownlist;
 import java.util.Collection;
 
 import com.l2jserver.gameserver.ai.CtrlIntention;
-import com.l2jserver.gameserver.ai.L2CharacterAI;
 import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.actor.L2Attackable;
 import com.l2jserver.gameserver.model.actor.L2Character;
@@ -25,73 +24,63 @@ import com.l2jserver.gameserver.model.actor.L2Playable;
 import com.l2jserver.gameserver.model.actor.instance.L2NpcInstance;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
-
 public class AttackableKnownList extends NpcKnownList
 {
-    // =========================================================
-    // Data Field
-
-    // =========================================================
-    // Constructor
-    public AttackableKnownList(L2Attackable activeChar)
-    {
-        super(activeChar);
-    }
-
-    // =========================================================
-    // Method - Public
-    @Override
-	public boolean removeKnownObject(L2Object object)
-    {
-        if (!super.removeKnownObject(object)) return false;
-
-        // Remove the L2Object from the _aggrolist of the L2Attackable
-        if (object instanceof L2Character)
-            getActiveChar().getAggroList().remove(object);
-        // Set the L2Attackable Intention to AI_INTENTION_IDLE
-        Collection<L2PcInstance> known = getKnownPlayers().values();
-
-        //FIXME: This is a temporary solution
-        L2CharacterAI ai = getActiveChar().getAI();
-        if (ai != null && (known == null || known.isEmpty()))
-        {
-            ai.setIntention(CtrlIntention.AI_INTENTION_IDLE, null);
-        }
-
-        return true;
-    }
-
-    // =========================================================
-    // Method - Private
-
-    // =========================================================
-    // Property - Public
-    @Override
-	public L2Attackable getActiveChar() { return (L2Attackable)super.getActiveChar(); }
-
-    @Override
+	public AttackableKnownList(L2Attackable activeChar)
+	{
+		super(activeChar);
+	}
+
+	@Override
+	protected boolean removeKnownObject(L2Object object, boolean forget)
+	{
+		if (!super.removeKnownObject(object, forget))
+			return false;
+
+		// Remove the L2Object from the _aggrolist of the L2Attackable
+		if (object instanceof L2Character)
+			getActiveChar().getAggroList().remove(object);
+		// Set the L2Attackable Intention to AI_INTENTION_IDLE
+		final Collection<L2PcInstance> known = getKnownPlayers().values();
+
+		//FIXME: This is a temporary solution
+		if (getActiveChar().hasAI() && (known == null || known.isEmpty()))
+			getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE, null);
+
+		return true;
+	}
+
+	@Override
+	public L2Attackable getActiveChar()
+	{
+		return (L2Attackable)super.getActiveChar();
+	}
+
+	@Override
 	public int getDistanceToForgetObject(L2Object object)
-    {
-       	if (getActiveChar().getAggroList().get(object) != null) 
-       		return 3000;
-        return Math.min(2200, 2 * getDistanceToWatchObject(object));
-    }
+	{
+		if (getActiveChar().getAggroList().get(object) != null) 
+			return 3000;
+
+		return Math.min(2200, 2 * getDistanceToWatchObject(object));
+	}
 
-    @Override
+	@Override
 	public int getDistanceToWatchObject(L2Object object)
-    {
-        if (object instanceof L2NpcInstance || !(object instanceof L2Character))
-            return 0;
+	{
+		if (object instanceof L2NpcInstance
+				|| !(object instanceof L2Character))
+			return 0;
 
-        if (object instanceof L2Playable)
-            return 1500;
+		if (object instanceof L2Playable)
+			return 1500;
 
-        if (getActiveChar().getAggroRange() > getActiveChar().getFactionRange())
-            return getActiveChar().getAggroRange();
+		if (getActiveChar().getAggroRange() > getActiveChar().getFactionRange())
+			return getActiveChar().getAggroRange();
 
-        if (getActiveChar().getFactionRange() > 300)
-            return getActiveChar().getFactionRange();
+		if (getActiveChar().getFactionRange() > 300)
+			return getActiveChar().getFactionRange();
 
-        return 300;
-    }
+		return 300;
+	}
 }

L2_GameServer/java/com/l2jserver/gameserver/model/actor/knownlist/BoatKnownList.java

@@ -18,27 +18,23 @@ import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.actor.L2Character;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
-
 /**
  * @author Maktakien
  *
  */
 public class BoatKnownList extends CharKnownList
 {
-
-	/**
-	 * @param activeChar
-	 */
 	public BoatKnownList(L2Character activeChar)
 	{
 		super(activeChar);
-		// TODO Auto-generated constructor stub
 	}
+
 	@Override
 	public int getDistanceToForgetObject(L2Object object)
     {
         if (!(object instanceof L2PcInstance))
             return 0;
+
         return 8000;
     }
 
@@ -47,7 +43,7 @@ public class BoatKnownList extends CharKnownList
     {
         if (!(object instanceof L2PcInstance))
             return 0;
+
         return 4000;
     }
-
 }

L2_GameServer/java/com/l2jserver/gameserver/model/actor/knownlist/CharKnownList.java

@@ -15,13 +15,12 @@
 package com.l2jserver.gameserver.model.actor.knownlist;
 
 import java.util.Collection;
+import java.util.Iterator;
 import java.util.Map;
 
 import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.actor.L2Character;
 import com.l2jserver.gameserver.model.actor.L2Summon;
-import com.l2jserver.gameserver.model.actor.instance.L2AirShipInstance;
-import com.l2jserver.gameserver.model.actor.instance.L2BoatInstance;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 import com.l2jserver.gameserver.util.Util;
 
@@ -30,178 +29,160 @@ import javolution.util.FastMap;
 
 public class CharKnownList extends ObjectKnownList
 {
-    // =========================================================
-    // Data Field
-    private Map<Integer, L2PcInstance> _knownPlayers;
-    private Map<Integer, L2Summon> _knownSummons;
-    private Map<Integer, Integer> _knownRelations;
+	private Map<Integer, L2PcInstance> _knownPlayers;
+	private Map<Integer, L2Summon> _knownSummons;
+	private Map<Integer, Integer> _knownRelations;
 
-    // =========================================================
-    // Constructor
-    public CharKnownList(L2Character activeChar)
-    {
-        super(activeChar);
-    }
+	public CharKnownList(L2Character activeChar)
+	{
+		super(activeChar);
+	}
 
-    // =========================================================
-    // Method - Public
-    @Override
+	@Override
 	public boolean addKnownObject(L2Object object)
-    {
-        if (!super.addKnownObject(object)) return false;
-        if (object instanceof L2PcInstance) {
-        	getKnownPlayers().put(object.getObjectId(), (L2PcInstance)object);
-        	getKnownRelations().put(object.getObjectId(), -1);
-        }
-        else if (object instanceof L2Summon)
-        	getKnownSummons().put(object.getObjectId(), (L2Summon)object);
-        	
-        return true;
-    }
+	{
+		if (!super.addKnownObject(object))
+			return false;
+		if (object instanceof L2PcInstance)
+		{
+			getKnownPlayers().put(object.getObjectId(), (L2PcInstance)object);
+			getKnownRelations().put(object.getObjectId(), -1);
+		}
+		else if (object instanceof L2Summon)
+			getKnownSummons().put(object.getObjectId(), (L2Summon)object);
 
-    /**
-     * Return True if the L2PcInstance is in _knownPlayer of the L2Character.<BR><BR>
-     * @param player The L2PcInstance to search in _knownPlayer
-     */
-    public final boolean knowsThePlayer(L2PcInstance player) { return getActiveChar() == player || getKnownPlayers().containsKey(player.getObjectId()); }
+		return true;
+	}
 
-    /** Remove all L2Object from _knownObjects and _knownPlayer of the L2Character then cancel Attak or Cast and notify AI. */
-    @Override
-	public final void removeAllKnownObjects()
-    {
-        super.removeAllKnownObjects();
-        getKnownPlayers().clear();
-        getKnownRelations().clear();
-        getKnownSummons().clear();
+	/**
+	 * Return True if the L2PcInstance is in _knownPlayer of the L2Character.<BR><BR>
+	 * @param player The L2PcInstance to search in _knownPlayer
+	 */
+	public final boolean knowsThePlayer(L2PcInstance player) { return getActiveChar() == player || getKnownPlayers().containsKey(player.getObjectId()); }
 
-        // Set _target of the L2Character to null
-        // Cancel Attack or Cast
-        getActiveChar().setTarget(null);
+	/** Remove all L2Object from _knownObjects and _knownPlayer of the L2Character then cancel Attack or Cast and notify AI. */
+	@Override
+	public final void removeAllKnownObjects()
+	{
+		super.removeAllKnownObjects();
+		getKnownPlayers().clear();
+		getKnownRelations().clear();
+		getKnownSummons().clear();
+
+		// Set _target of the L2Character to null
+		// Cancel Attack or Cast
+		getActiveChar().setTarget(null);
+
+		// Cancel AI Task
+		if (getActiveChar().hasAI())
+			getActiveChar().setAI(null);
+	}
+
+	@Override
+	protected boolean removeKnownObject(L2Object object, boolean forget)
+	{
+		if (!super.removeKnownObject(object, forget))
+			return false;
+
+		if (!forget) // on forget objects removed by iterator
+		{
+			if (object instanceof L2PcInstance)
+			{
+				getKnownPlayers().remove(object.getObjectId());
+				getKnownRelations().remove(object.getObjectId());
+			}
+			else if (object instanceof L2Summon)
+				getKnownSummons().remove(object.getObjectId());
+		}
 
-        // Cancel AI Task
-        if (getActiveChar().hasAI()) getActiveChar().setAI(null);
-    }
+		// If object is targeted by the L2Character, cancel Attack or Cast
+		if (object == getActiveChar().getTarget())
+			getActiveChar().setTarget(null);
 
-    @Override
-	public boolean removeKnownObject(L2Object object)
-    {
-        if (!super.removeKnownObject(object)) return false;
-        if (object instanceof L2PcInstance) {
-        	getKnownPlayers().remove(object.getObjectId());
-        	getKnownRelations().remove(object.getObjectId());
-        }
-        else if (object instanceof L2Summon)
-        {
-        	getKnownSummons().remove(object.getObjectId());
-        }
-        // If object is targeted by the L2Character, cancel Attack or Cast
-        if (object == getActiveChar().getTarget()) getActiveChar().setTarget(null);
+		return true;
+	}
 
-        return true;
-    }
-    
-    @Override
-    public void forgetObjects(boolean fullCheck)
-    {
-    	if (!fullCheck)
-    	{
-    		Collection<L2PcInstance> plrs = getKnownPlayers().values();
-    		//synchronized (getKnownPlayers())
+	@Override
+	public void forgetObjects(boolean fullCheck)
+	{
+		if (!fullCheck)
+		{
+			final Collection<L2PcInstance> plrs = getKnownPlayers().values();
+			final Iterator<L2PcInstance> pIter = plrs.iterator();
+			L2PcInstance player;
+			//synchronized (getKnownPlayers())
 			{
-				for (L2PcInstance player : plrs)
+				while (pIter.hasNext())
 				{
-					// Remove all objects invisible or too far
+					player = pIter.next();
 					if (!player.isVisible()
 					        || !Util.checkIfInShortRadius(getDistanceToForgetObject(player), getActiveObject(), player, true))
-						removeKnownObject(player);
+					{
+						pIter.remove();
+						removeKnownObject(player, true);
+						getKnownRelations().remove(player.getObjectId());
+						getKnownObjects().remove(player.getObjectId());
+					}
 				}
 			}
-    		Collection<L2Summon> sums = getKnownSummons().values();
-    		//synchronized (sums)
+
+			final Collection<L2Summon> sums = getKnownSummons().values();
+			final Iterator<L2Summon> sIter = sums.iterator();
+			L2Summon summon;
+			//synchronized (sums)
 			{
-				for (L2Summon summon : sums)
+				while (sIter.hasNext())
 				{
-					// Remove all objects invisible or too far
+					summon = sIter.next();
 					if (!summon.isVisible()
 					        || !Util.checkIfInShortRadius(getDistanceToForgetObject(summon), getActiveObject(), summon, true))
-						removeKnownObject(summon);
+					{
+						sIter.remove();
+						removeKnownObject(summon, true);
+						getKnownObjects().remove(summon.getObjectId());
+					}
 				}
 			}
-        	return;
-    	}
-    	// Go through knownObjects
-    	Collection<L2Object> objs = getKnownObjects().values();
-    	//synchronized (getKnownObjects())
+			return;
+		}
+		// Go through knownObjects
+		final Collection<L2Object> objs = getKnownObjects().values();
+		final Iterator<L2Object> oIter = objs.iterator();
+		L2Object object;
+		//synchronized (getKnownObjects())
 		{
-			for (L2Object object : objs)
+			while (oIter.hasNext())
 			{
-				// Remove all objects invisible or too far
-				if (!object.isVisible() || !Util.checkIfInShortRadius(getDistanceToForgetObject(object), getActiveObject(), object, true))
+				object = oIter.next();
+				if (!object.isVisible()
+						|| !Util.checkIfInShortRadius(getDistanceToForgetObject(object), getActiveObject(), object, true))
 				{
-					if (object instanceof L2BoatInstance && getActiveObject() instanceof L2PcInstance)
-					{
-						if (((L2BoatInstance) (object)).getVehicleDeparture() == null)
-						{
-							//
-						}
-						else if (((L2PcInstance) getActiveObject()).isInBoat())
-						{
-							if (((L2PcInstance) getActiveObject()).getBoat() != object)
-							{
-								removeKnownObject(object);
-							}
-						}
-						else
-						{
-							removeKnownObject(object);
-						}
-					}
-					else if (object instanceof L2AirShipInstance && getActiveObject() instanceof L2PcInstance)
-					{
-						if (((L2AirShipInstance) (object)).getAirShipInfo() == null)
-						{
-							//
-						}
-						else if (((L2PcInstance) getActiveObject()).isInAirShip())
-						{
-							if (((L2PcInstance) getActiveObject()).getAirShip() != object)
-							{
-								removeKnownObject(object);
-							}
-						}
-						else
-						{
-							removeKnownObject(object);
-						}
-					}
-					else
+					oIter.remove();
+					removeKnownObject(object, true);
+
+					if (object instanceof L2PcInstance)
 					{
-						removeKnownObject(object);
+						getKnownPlayers().remove(object.getObjectId());
+						getKnownRelations().remove(object.getObjectId());
 					}
+					else if (object instanceof L2Summon)
+						getKnownSummons().remove(object.getObjectId());
 				}
 			}
 		}
-    }
-
-    // =========================================================
-    // Method - Private
-
-    // =========================================================
-    // Property - Public
-    public L2Character getActiveChar() { return (L2Character)super.getActiveObject(); }
+	}
 
-    @Override
-	public int getDistanceToForgetObject(L2Object object) { return 0; }
+	public L2Character getActiveChar()
+	{
+		return (L2Character)super.getActiveObject();
+	}
 
-    @Override
-	public int getDistanceToWatchObject(L2Object object) { return 0; }
+	public Collection<L2Character> getKnownCharacters()
+	{
+		FastList<L2Character> result = new FastList<L2Character>();
 
-    public Collection<L2Character> getKnownCharacters()
-    {
-        FastList<L2Character> result = new FastList<L2Character>();
-
-        Collection<L2Object> objs = getKnownObjects().values();
-        //synchronized (getKnownObjects())
+		final Collection<L2Object> objs = getKnownObjects().values();
+		//synchronized (getKnownObjects())
 		{
 			for (L2Object obj : objs)
 			{
@@ -209,17 +190,16 @@ public class CharKnownList extends ObjectKnownList
 					result.add((L2Character) obj);
 			}
 		}
-        return result;
-    }
+		return result;
+	}
 
-    public Collection<L2Character> getKnownCharactersInRadius(long radius)
-    {
-       FastList<L2Character> result = new FastList<L2Character>();
+	public Collection<L2Character> getKnownCharactersInRadius(long radius)
+	{
+		FastList<L2Character> result = new FastList<L2Character>();
 
-       Collection<L2Object> objs = getKnownObjects().values();
-       //synchronized (getKnownObjects())
-       if (objs != null && !objs.isEmpty())
-       {
+		final Collection<L2Object> objs = getKnownObjects().values();
+		//synchronized (getKnownObjects())
+		{
 			for (L2Object obj : objs)
 			{
 				if (obj instanceof L2Character)
@@ -229,39 +209,41 @@ public class CharKnownList extends ObjectKnownList
 				}
 			}
 		}
-
-       return result;
-    }
-
-    public final Map<Integer, L2PcInstance> getKnownPlayers()
-    {
-        if (_knownPlayers == null) _knownPlayers = new FastMap<Integer, L2PcInstance>().shared();
-        return _knownPlayers;
-    }
-
-    public final Map<Integer, Integer> getKnownRelations()
-    {
-        if (_knownRelations == null) _knownRelations = new FastMap<Integer, Integer>().shared();
-        return _knownRelations;
-    }
-
-    public final Map<Integer, L2Summon> getKnownSummons()
-    {
-        if (_knownSummons == null) _knownSummons = new FastMap<Integer, L2Summon>().shared();
-        return _knownSummons;
-    }
-    
-    public final Collection<L2PcInstance> getKnownPlayersInRadius(long radius)
-    {
-        FastList<L2PcInstance> result = new FastList<L2PcInstance>();
-
-        Collection<L2PcInstance> plrs = getKnownPlayers().values();
-        //synchronized (getKnownPlayers())
+		return result;
+	}
+
+	public final Map<Integer, L2PcInstance> getKnownPlayers()
+	{
+		if (_knownPlayers == null)
+			_knownPlayers = new FastMap<Integer, L2PcInstance>().shared();
+		return _knownPlayers;
+	}
+
+	public final Map<Integer, Integer> getKnownRelations()
+	{
+		if (_knownRelations == null)
+			_knownRelations = new FastMap<Integer, Integer>().shared();
+		return _knownRelations;
+	}
+
+	public final Map<Integer, L2Summon> getKnownSummons()
+	{
+		if (_knownSummons == null)
+			_knownSummons = new FastMap<Integer, L2Summon>().shared();
+		return _knownSummons;
+	}
+
+	public final Collection<L2PcInstance> getKnownPlayersInRadius(long radius)
+	{
+		FastList<L2PcInstance> result = new FastList<L2PcInstance>();
+
+		final Collection<L2PcInstance> plrs = getKnownPlayers().values();
+		//synchronized (getKnownPlayers())
 		{
 			for (L2PcInstance player : plrs)
 				if (Util.checkIfInRange((int) radius, getActiveChar(), player, true))
 					result.add(player);
 		}
-        return result;
-    }
+		return result;
+	}
 }

L2_GameServer/java/com/l2jserver/gameserver/model/actor/knownlist/FriendlyMobKnownList.java

@@ -23,57 +23,56 @@ import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 public class FriendlyMobKnownList extends AttackableKnownList
 {
-    // =========================================================
-    // Data Field
+	public FriendlyMobKnownList(L2FriendlyMobInstance activeChar)
+	{
+		super(activeChar);
+	}
 
-    // =========================================================
-    // Constructor
-    public FriendlyMobKnownList(L2FriendlyMobInstance activeChar)
-    {
-        super(activeChar);
-    }
-
-    // =========================================================
-    // Method - Public
-    @Override
+	@Override
 	public boolean addKnownObject(L2Object object)
-    {
-        if (!super.addKnownObject(object)) return false;
-
-        if (object instanceof L2PcInstance && getActiveChar().getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE)
-            getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE, null);
+	{
+		if (!super.addKnownObject(object))
+			return false;
 
-        return true;
-    }
+		if (object instanceof L2PcInstance
+				&& getActiveChar().getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE)
+			getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE, null);
 
-    @Override
-	public boolean removeKnownObject(L2Object object)
-    {
-        if (!super.removeKnownObject(object)) return false;
+		return true;
+	}
 
-        if (!(object instanceof L2Character)) return true;
+	@Override
+	protected boolean removeKnownObject(L2Object object, boolean forget)
+	{
+		if (!super.removeKnownObject(object, forget))
+			return false;
 
-        if (getActiveChar().hasAI()) {
-            L2Character temp = (L2Character)object;
-            getActiveChar().getAI().notifyEvent(CtrlEvent.EVT_FORGET_OBJECT, object);
-            if (getActiveChar().getTarget() == temp) getActiveChar().setTarget(null);
-        }
+		if (!(object instanceof L2Character))
+			return true;
 
-        if (getActiveChar().isVisible() && getKnownPlayers().isEmpty() && getKnownSummons().isEmpty())
-        {
-            getActiveChar().clearAggroList();
-            //removeAllKnownObjects();
-            if (getActiveChar().hasAI()) getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE, null);
-        }
+		if (getActiveChar().hasAI())
+		{
+			getActiveChar().getAI().notifyEvent(CtrlEvent.EVT_FORGET_OBJECT, object);
+			if (getActiveChar().getTarget() == (L2Character)object)
+				getActiveChar().setTarget(null);
+		}
 
-        return true;
-    }
+		if (getActiveChar().isVisible()
+				&& getKnownPlayers().isEmpty()
+				&& getKnownSummons().isEmpty())
+		{
+			getActiveChar().clearAggroList();
+			//removeAllKnownObjects();
+			if (getActiveChar().hasAI())
+				getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE, null);
+		}
 
-    // =========================================================
-    // Method - Private
+		return true;
+	}
 
-    // =========================================================
-    // Property - Public
-    @Override
-	public final L2FriendlyMobInstance getActiveChar() { return (L2FriendlyMobInstance)super.getActiveChar(); }
+	@Override
+	public final L2FriendlyMobInstance getActiveChar()
+	{
+		return (L2FriendlyMobInstance)super.getActiveChar();
+	}
 }

L2_GameServer/java/com/l2jserver/gameserver/model/actor/knownlist/GuardKnownList.java

@@ -18,7 +18,6 @@ import java.util.logging.Logger;
 
 import com.l2jserver.Config;
 import com.l2jserver.gameserver.ai.CtrlIntention;
-import com.l2jserver.gameserver.ai.L2CharacterAI;
 import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.actor.instance.L2GuardInstance;
 import com.l2jserver.gameserver.model.actor.instance.L2MonsterInstance;
@@ -27,80 +26,72 @@ import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 public class GuardKnownList extends AttackableKnownList
 {
-    private static Logger _log = Logger.getLogger(GuardKnownList.class.getName());
+	private static final Logger _log = Logger.getLogger(GuardKnownList.class.getName());
 
-    // =========================================================
-    // Data Field
+	public GuardKnownList(L2GuardInstance activeChar)
+	{
+		super(activeChar);
+	}
 
-    // =========================================================
-    // Constructor
-    public GuardKnownList(L2GuardInstance activeChar)
-    {
-        super(activeChar);
-    }
-
-    // =========================================================
-    // Method - Public
-    @Override
+	@Override
 	public boolean addKnownObject(L2Object object)
-    {
-        if (!super.addKnownObject(object)) return false;
-
-        if (object instanceof L2PcInstance)
-        {
-            // Check if the object added is a L2PcInstance that owns Karma
-            L2PcInstance player = (L2PcInstance) object;
-
-            if ( (player.getKarma() > 0) )
-            {
-                if (Config.DEBUG) _log.fine(getActiveChar().getObjectId()+": PK "+player.getObjectId()+" entered scan range");
-
-                // Set the L2GuardInstance Intention to AI_INTENTION_ACTIVE
-                if (getActiveChar().getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE)
-                    getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE, null);
-            }
-        }
-        else if ((Config.GUARD_ATTACK_AGGRO_MOB && getActiveChar().isInActiveRegion()) && object instanceof L2MonsterInstance)
-        {
-            // Check if the object added is an aggressive L2MonsterInstance
-            L2MonsterInstance mob = (L2MonsterInstance) object;
-
-            if (mob.isAggressive() )
-            {
-                if (Config.DEBUG) _log.fine(getActiveChar().getObjectId()+": Aggressive mob "+mob.getObjectId()+" entered scan range");
-
-                // Set the L2GuardInstance Intention to AI_INTENTION_ACTIVE
-                if (getActiveChar().getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE)
-                    getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE, null);
-            }
-        }
-
-        return true;
-    }
-
-    @Override
-	public boolean removeKnownObject(L2Object object)
-    {
-        if (!super.removeKnownObject(object)) return false;
-
-        // Check if the _aggroList of the L2GuardInstance is Empty
-        if (getActiveChar().noTarget())
-        {
-            //removeAllKnownObjects();
-
-            // Set the L2GuardInstance to AI_INTENTION_IDLE
-            L2CharacterAI ai = getActiveChar().getAI();
-            if (ai != null) ai.setIntention(CtrlIntention.AI_INTENTION_IDLE, null);
-        }
-
-        return true;
-    }
-
-    // =========================================================
-    // Method - Private
-
-    // =========================================================
-    // Property - Public
-    @Override
-	public final L2GuardInstance getActiveChar() { return (L2GuardInstance)super.getActiveChar(); }
+	{
+		if (!super.addKnownObject(object))
+			return false;
+
+		if (object instanceof L2PcInstance)
+		{
+			// Check if the object added is a L2PcInstance that owns Karma
+			if (((L2PcInstance)object).getKarma() > 0)
+			{
+				if (Config.DEBUG)
+					_log.fine(getActiveChar().getObjectId()+": PK "+object.getObjectId()+" entered scan range");
+
+				// Set the L2GuardInstance Intention to AI_INTENTION_ACTIVE
+				if (getActiveChar().getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE)
+					getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE, null);
+			}
+		}
+		else if ((Config.GUARD_ATTACK_AGGRO_MOB && getActiveChar().isInActiveRegion())
+				&& object instanceof L2MonsterInstance)
+		{
+			// Check if the object added is an aggressive L2MonsterInstance
+			if (((L2MonsterInstance)object).isAggressive())
+			{
+				if (Config.DEBUG)
+					_log.fine(getActiveChar().getObjectId()+": Aggressive mob "+object.getObjectId()+" entered scan range");
+
+				// Set the L2GuardInstance Intention to AI_INTENTION_ACTIVE
+				if (getActiveChar().getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE)
+					getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE, null);
+			}
+		}
+
+		return true;
+	}
+
+	@Override
+	protected boolean removeKnownObject(L2Object object, boolean forget)
+	{
+		if (!super.removeKnownObject(object, forget))
+			return false;
+
+		// Check if the _aggroList of the L2GuardInstance is Empty
+		if (getActiveChar().noTarget())
+		{
+			//removeAllKnownObjects();
+
+			// Set the L2GuardInstance to AI_INTENTION_IDLE
+			if (getActiveChar().hasAI())
+				getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE, null);
+		}
+
+		return true;
+	}
+
+	@Override
+	public final L2GuardInstance getActiveChar()
+	{
+		return (L2GuardInstance)super.getActiveChar();
+	}
 }

L2_GameServer/java/com/l2jserver/gameserver/model/actor/knownlist/MonsterKnownList.java

@@ -23,71 +23,58 @@ import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 public class MonsterKnownList extends AttackableKnownList
 {
-    // =========================================================
-    // Data Field
+	public MonsterKnownList(L2MonsterInstance activeChar)
+	{
+		super(activeChar);
+	}
 
-    // =========================================================
-    // Constructor
-    public MonsterKnownList(L2MonsterInstance activeChar)
-    {
-        super(activeChar);
-    }
-
-    // =========================================================
-    // Method - Public
-    @Override
+	@Override
 	public boolean addKnownObject(L2Object object)
-    {
-        if (!super.addKnownObject(object)) return false;
-
-        // Set the L2MonsterInstance Intention to AI_INTENTION_ACTIVE if the state was AI_INTENTION_IDLE
-        if (object instanceof L2PcInstance && getActiveChar().getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE)
-            getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE, null);
-        return true;
-    }
-
-    @Override
-	public boolean removeKnownObject(L2Object object)
-    {
-        if (!super.removeKnownObject(object)) return false;
+	{
+		if (!super.addKnownObject(object))
+			return false;
 
-        if (!(object instanceof L2Character)) return true;
+		// Set the L2MonsterInstance Intention to AI_INTENTION_ACTIVE if the state was AI_INTENTION_IDLE
+		if (object instanceof L2PcInstance
+				&& getActiveChar().hasAI()
+				&& getActiveChar().getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE)
+			getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE, null);
 
-        if (getActiveChar().hasAI())
-        {
-            // Notify the L2MonsterInstance AI with EVT_FORGET_OBJECT
-            getActiveChar().getAI().notifyEvent(CtrlEvent.EVT_FORGET_OBJECT, object);
+		return true;
+	}
 
-            //TODO Remove this function because it's already done in L2Character.removeKnownObject
-            // Set the current target to null if the forgotten L2Object was the targeted L2Object
-            // L2Character temp = (L2Character)object;
-
-            //if (getTarget() == temp)
-            //  setTarget(null);
-        }
-
-        if (getActiveChar().isVisible() && getKnownPlayers().isEmpty() && getKnownSummons().isEmpty())
-        {
-            // Clear the _aggroList of the L2MonsterInstance
-            getActiveChar().clearAggroList();
-
-            // Remove all L2Object from _knownObjects and _knownPlayer of the L2MonsterInstance then cancel Attak or Cast and notify AI
-            //removeAllKnownObjects();
-
-            //TODO Remove this function because it's already done in L2Attackable.removeKnownObject
-            // Set the L2MonsterInstance AI to AI_INTENTION_IDLE
-            // if (hasAI())
-            // getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE, null);
-        }
-
-        return true;
+	@Override
+	protected boolean removeKnownObject(L2Object object, boolean forget)
+    {
+		if (!super.removeKnownObject(object, forget))
+			return false;
+
+		if (!(object instanceof L2Character))
+			return true;
+
+		if (getActiveChar().hasAI())
+		{
+			// Notify the L2MonsterInstance AI with EVT_FORGET_OBJECT
+			getActiveChar().getAI().notifyEvent(CtrlEvent.EVT_FORGET_OBJECT, object);
+		}
+
+		if (getActiveChar().isVisible()
+				&& getKnownPlayers().isEmpty()
+				&& getKnownSummons().isEmpty())
+		{
+			// Clear the _aggroList of the L2MonsterInstance
+			getActiveChar().clearAggroList();
+
+			// Remove all L2Object from _knownObjects and _knownPlayer of the L2MonsterInstance then cancel Attak or Cast and notify AI
+			//removeAllKnownObjects();
+		}
+
+		return true;
     }
 
-    // =========================================================
-    // Method - Private
-
-    // =========================================================
-    // Property - Public
-    @Override
-	public final L2MonsterInstance getActiveChar() { return (L2MonsterInstance)super.getActiveChar(); }
+	@Override
+	public final L2MonsterInstance getActiveChar()
+	{
+		return (L2MonsterInstance)super.getActiveChar();
+	}
 }

L2_GameServer/java/com/l2jserver/gameserver/model/actor/knownlist/NullKnownList.java

@@ -77,7 +77,7 @@ public class NullKnownList extends ObjectKnownList
 	 * @see com.l2jserver.gameserver.model.actor.knownlist.ObjectKnownList#removeKnownObject(com.l2jserver.gameserver.model.L2Object)
 	 */
 	@Override
-	public boolean removeKnownObject(L2Object object)
+	protected boolean removeKnownObject(L2Object object, boolean forget)
 	{
 		return false;
 	}

L2_GameServer/java/com/l2jserver/gameserver/model/actor/knownlist/ObjectKnownList.java

@@ -15,13 +15,13 @@
 package com.l2jserver.gameserver.model.actor.knownlist;
 
 import java.util.Collection;
+import java.util.Iterator;
 import java.util.Map;
 
 import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.L2WorldRegion;
 import com.l2jserver.gameserver.model.actor.L2Character;
 import com.l2jserver.gameserver.model.actor.L2Playable;
-import com.l2jserver.gameserver.model.actor.instance.L2BoatInstance;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 import com.l2jserver.gameserver.util.Util;
 
@@ -29,72 +29,84 @@ import javolution.util.FastMap;
 
 public class ObjectKnownList
 {
-    // =========================================================
-    // Data Field
-    private L2Object _activeObject;
-    private Map<Integer, L2Object> _knownObjects;
-
-    // =========================================================
-    // Constructor
-    public ObjectKnownList(L2Object activeObject)
-    {
-        _activeObject = activeObject;
-    }
-
-    // =========================================================
-    // Method - Public
-    public boolean addKnownObject(L2Object object)
-    {
-        if (object == null) return false;
-        
-        // Instance -1 is for GMs that can see everything on all instances
-        if(getActiveObject().getInstanceId() != -1 && (object.getInstanceId() != getActiveObject().getInstanceId()))
-        	return false;
-
-        // Check if the object is an L2PcInstance in ghost mode
-        if(object instanceof L2PcInstance && ((L2PcInstance)object).getAppearance().isGhost())
-        	return false;
- 	 	
-        // Check if already know object
-        if (knowsObject(object))
-            return false;
-
-        // Check if object is not inside distance to watch object
-        if (!Util.checkIfInShortRadius(getDistanceToWatchObject(object), getActiveObject(), object, true)) return false;
-
-        return (getKnownObjects().put(object.getObjectId(), object) == null);
-    }
-
-    public final boolean knowsObject(L2Object object)
+	private L2Object _activeObject;
+	private Map<Integer, L2Object> _knownObjects;
+
+	public ObjectKnownList(L2Object activeObject)
+	{
+		_activeObject = activeObject;
+	}
+
+	public boolean addKnownObject(L2Object object)
+	{
+		if (object == null)
+			return false;
+
+		// Instance -1 is for GMs that can see everything on all instances
+		if(getActiveObject().getInstanceId() != -1
+				&& (object.getInstanceId() != getActiveObject().getInstanceId()))
+			return false;
+
+		// Check if the object is an L2PcInstance in ghost mode
+		if(object instanceof L2PcInstance
+				&& ((L2PcInstance)object).getAppearance().isGhost())
+			return false;
+
+		// Check if already know object
+		if (knowsObject(object))
+			return false;
+
+		// Check if object is not inside distance to watch object
+		if (!Util.checkIfInShortRadius(getDistanceToWatchObject(object), getActiveObject(), object, true))
+			return false;
+
+		return (getKnownObjects().put(object.getObjectId(), object) == null);
+	}
+
+	public final boolean knowsObject(L2Object object)
 	{
 		if (object == null)
 			return false;
-		
+
 		return getActiveObject() == object || getKnownObjects().containsKey(object.getObjectId());
 	}
 
-    /** Remove all L2Object from _knownObjects */
-    public void removeAllKnownObjects() { getKnownObjects().clear(); }
-
-    public boolean removeKnownObject(L2Object object)
-    {
-    	if (object == null) return false;
-    	return (getKnownObjects().remove(object.getObjectId()) != null);
-    }
-
-    // used only in Config.MOVE_BASED_KNOWNLIST and does not support guards seeing
-    // moving monsters
-    public final void findObjects()
-    {
-    	L2WorldRegion region = getActiveObject().getWorldRegion();
-    	if (region == null) return;
-    	
-    	if (getActiveObject() instanceof L2Playable)
-    	{
-    		for (L2WorldRegion regi : region.getSurroundingRegions()) // offer members of this and surrounding regions
-    		{
-    			Collection<L2Object> vObj = regi.getVisibleObjects().values();
-    	    	//synchronized (KnownListUpdateTaskManager.getInstance().getSync())
+	/** Remove all L2Object from _knownObjects */
+	public void removeAllKnownObjects()
+	{
+		getKnownObjects().clear();
+	}
+
+	public final boolean removeKnownObject(L2Object object)
+	{
+		return removeKnownObject(object, false);
+	}
+
+	protected boolean removeKnownObject(L2Object object, boolean forget)
+	{
+		if (object == null)
+			return false;
+
+		if (forget) // on forget objects removed from list by iterator
+			return true;
+
+		return getKnownObjects().remove(object.getObjectId()) != null;
+	}
+
+	// used only in Config.MOVE_BASED_KNOWNLIST and does not support guards seeing
+	// moving monsters
+	public final void findObjects()
+	{
+		final L2WorldRegion region = getActiveObject().getWorldRegion();
+		if (region == null)
+			return;
+
+		if (getActiveObject() instanceof L2Playable)
+		{
+			for (L2WorldRegion regi : region.getSurroundingRegions()) // offer members of this and surrounding regions
+			{
+				Collection<L2Object> vObj = regi.getVisibleObjects().values();
+				//synchronized (KnownListUpdateTaskManager.getInstance().getSync())
 				{
 					//synchronized (regi.getVisibleObjects())
 					{
@@ -109,15 +121,16 @@ public class ObjectKnownList
 						}
 					}
 				}
-    		}
-    	}
-    	else if (getActiveObject() instanceof L2Character)
-    	{
-    		for (L2WorldRegion regi : region.getSurroundingRegions()) // offer members of this and surrounding regions
-    		{
-    			if (regi.isActive()) {
-    				Collection<L2Playable> vPls = regi.getVisiblePlayable().values();
-    		    	//synchronized (KnownListUpdateTaskManager.getInstance().getSync())
+			}
+		}
+		else if (getActiveObject() instanceof L2Character)
+		{
+			for (L2WorldRegion regi : region.getSurroundingRegions()) // offer members of this and surrounding regions
+			{
+				if (regi.isActive())
+				{
+					Collection<L2Playable> vPls = regi.getVisiblePlayable().values();
+					//synchronized (KnownListUpdateTaskManager.getInstance().getSync())
 					{
 						//synchronized (regi.getVisiblePlayable())
 						{
@@ -126,72 +139,60 @@ public class ObjectKnownList
 									addKnownObject(_object);
 						}
 					}
-    			}
-    		}
-    	}
-    }
-    
-    // Remove invisible and too far L2Object from _knowObject and if necessary from _knownPlayers of the L2Character
-    public void forgetObjects(boolean fullCheck)
-    {
-    	//synchronized (KnownListUpdateTaskManager.getInstance().getSync())
+				}
+			}
+		}
+	}
+
+	// Remove invisible and too far L2Object from _knowObject and if necessary from _knownPlayers of the L2Character
+	public void forgetObjects(boolean fullCheck)
+	{
+		//synchronized (KnownListUpdateTaskManager.getInstance().getSync())
 		{
 			// Go through knownObjects
-			Collection<L2Object> objs = getKnownObjects().values();
+			final Collection<L2Object> objs = getKnownObjects().values();
+			final Iterator<L2Object> oIter = objs.iterator();
+			L2Object object;
 			//synchronized (getKnownObjects())
 			{
-				for (L2Object object : objs)
+				while (oIter.hasNext())
 				{
+					object = oIter.next();
 					if (!fullCheck && !(object instanceof L2Playable))
 						continue;
-					
+
 					// Remove all objects invisible or too far
 					if (!object.isVisible()
 					        || !Util.checkIfInShortRadius(getDistanceToForgetObject(object), getActiveObject(), object, true))
-						if (object instanceof L2BoatInstance
-						        && getActiveObject() instanceof L2PcInstance)
-						{
-							if (((L2BoatInstance) (object)).getVehicleDeparture() == null)
-							{
-								//
-							}
-							else if (((L2PcInstance) getActiveObject()).isInBoat())
-							{
-								if (((L2PcInstance) getActiveObject()).getBoat() != object)
-								{
-									removeKnownObject(object);
-								}
-							}
-							else
-							{
-								removeKnownObject(object);
-							}
-						}
-						else
-						{
-							removeKnownObject(object);
-						}
+					{
+						oIter.remove();
+						removeKnownObject(object, true);
+					}
 				}
 			}
 		}
-    }
-
-    // =========================================================
-    // Property - Public
-    public L2Object getActiveObject()
-    {
-        return _activeObject;
-    }
+	}
 
-    public int getDistanceToForgetObject(L2Object object) { return 0; }
+	public L2Object getActiveObject()
+	{
+		return _activeObject;
+	}
 
-    public int getDistanceToWatchObject(L2Object object) { return 0; }
+	public int getDistanceToForgetObject(L2Object object)
+	{
+		return 0;
+	}
 
-    /** Return the _knownObjects containing all L2Object known by the L2Character. */
-    public final Map<Integer, L2Object> getKnownObjects()
-    {
-        if (_knownObjects == null) _knownObjects = new FastMap<Integer, L2Object>().shared();
-        return _knownObjects;
-    }
+	public int getDistanceToWatchObject(L2Object object)
+	{
+		return 0;
+	}
 
+	/** Return the _knownObjects containing all L2Object known by the L2Character. */
+	public final Map<Integer, L2Object> getKnownObjects()
+	{
+		if (_knownObjects == null)
+			_knownObjects = new FastMap<Integer, L2Object>().shared();
+		return _knownObjects;
+	}
 }

L2_GameServer/java/com/l2jserver/gameserver/model/actor/knownlist/PcKnownList.java

@@ -99,9 +99,9 @@ public class PcKnownList extends PlayableKnownList
      *
      */
     @Override
-	public boolean removeKnownObject(L2Object object)
+	protected boolean removeKnownObject(L2Object object, boolean forget)
     {
-            if (!super.removeKnownObject(object)) return false;
+            if (!super.removeKnownObject(object, forget)) return false;
         // Send Server-Client Packet DeleteObject to the L2PcInstance
         getActiveChar().sendPacket(new DeleteObject(object));
        if (Config.CHECK_KNOWN && object instanceof L2Npc) getActiveChar().sendMessage("Removed NPC: "+((L2Npc)object).getName());

L2_GameServer/java/com/l2jserver/gameserver/model/actor/knownlist/RaceManagerKnownList.java

@@ -54,9 +54,9 @@ public class RaceManagerKnownList extends NpcKnownList
     }
 
     @Override
-	public boolean removeKnownObject(L2Object object)
+	protected boolean removeKnownObject(L2Object object, boolean forget)
     {
-        if (!super.removeKnownObject(object)) return false;
+        if (!super.removeKnownObject(object, forget)) return false;
 
         if (object instanceof L2PcInstance)
         {