rendered paste bodyIndex: trunk/L2_Gameserver/java/net/sf/l2j/Config.java
===================================================================
--- trunk/L2_Gameserver/java/net/sf/l2j/Config.java (revision 2003)
+++ trunk/L2_Gameserver/java/net/sf/l2j/Config.java (revision 2019)
@@ -469,4 +469,7 @@
public static int MINIMUM_UPDATE_DISTANCE;
+ public static int KNOWNLIST_FORGET_DELAY;
+ public static int MINIMUN_UPDATE_TIME;
+
public static boolean ANNOUNCE_MAMMON_SPAWN;
public static boolean LAZY_CACHE;
@@ -601,5 +604,7 @@
MINIMUM_UPDATE_DISTANCE = Integer.parseInt(serverSettings.getProperty("MaximumUpdateDistance", "50"));
+ MINIMUN_UPDATE_TIME = Integer.parseInt(serverSettings.getProperty("MinimumUpdateTime", "500"));
CHECK_KNOWN = Boolean.valueOf(serverSettings.getProperty("CheckKnownList", "false"));
+ KNOWNLIST_FORGET_DELAY = Integer.parseInt(serverSettings.getProperty("KnownListForgetDelay", "10000"));
LAZY_CACHE = Boolean.valueOf(serverSettings.getProperty("LazyCache", "True"));
Index: trunk/L2_Gameserver/java/net/sf/l2j/gameserver/ai/L2DoorAI.java
===================================================================
--- trunk/L2_Gameserver/java/net/sf/l2j/gameserver/ai/L2DoorAI.java (revision 1854)
+++ trunk/L2_Gameserver/java/net/sf/l2j/gameserver/ai/L2DoorAI.java (revision 2019)
@@ -22,5 +22,4 @@
import net.sf.l2j.gameserver.model.L2Character;
import net.sf.l2j.gameserver.model.L2DoorInstance;
-import net.sf.l2j.gameserver.model.L2NpcInstance;
import net.sf.l2j.gameserver.model.L2Object;
import net.sf.l2j.gameserver.model.L2SiegeGuardInstance;
@@ -60,14 +59,14 @@
@SuppressWarnings("unused")
protected void onEvtAttacked(L2Character attacker) {
- _actor.updateKnownObjects();
- for (L2Object obj : _actor.getKnownObjects()) {
- if (obj == null || !(obj instanceof L2SiegeGuardInstance))
- continue;
-
- L2NpcInstance npc = (L2NpcInstance)obj;
- if (_actor.getDistance(npc.getX(), npc.getY()) < npc.getFactionRange()
- && Math.abs(getAttackTarget().getZ()-npc.getZ()) < 200)
+
+ L2DoorInstance me = (L2DoorInstance)_actor;
+
+ me.updateKnownObjects();
+
+ for (L2SiegeGuardInstance guard : me.getKnownSiegeGuards()) {
+ if (_actor.getDistance(guard.getX(), guard.getY()) < guard.getFactionRange()
+ && Math.abs(getAttackTarget().getZ()-guard.getZ()) < 200)
{
- npc.getAI().notifyEvent(CtrlEvent.EVT_AGGRESSION, getAttackTarget(), 1);
+ guard.getAI().notifyEvent(CtrlEvent.EVT_AGGRESSION, getAttackTarget(), 1);
}
}
Index: trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2Character.java
===================================================================
--- trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2Character.java (revision 2015)
+++ trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2Character.java (revision 2019)
@@ -20,5 +20,4 @@
import java.util.Collection;
-import java.util.Collections;
import java.util.Iterator;
import java.util.List;
@@ -34,5 +33,4 @@
import javolution.util.FastList;
import javolution.util.FastMap;
-import javolution.util.FastSet;
import net.sf.l2j.Config;
import net.sf.l2j.gameserver.ClientScheduler;
@@ -74,5 +72,4 @@
import net.sf.l2j.gameserver.templates.L2Weapon;
import net.sf.l2j.gameserver.templates.L2WeaponType;
-import net.sf.l2j.gameserver.util.Util;
/**
@@ -556,11 +553,4 @@
/** Table of Calculators containing all used calculator */
private Calculator[] _calculators;
-
- /** L2ObjectHashSet(L2Object) containing all L2Object detected by the L2Character */
- //private L2ObjectSet<L2Object> _knownObjects;
- protected Set<L2Object> _knownObjects;
-
- /** L2ObjectHashSet(L2PcInstance) containing all player ingame detected by the L2Character */
- protected Set<L2PcInstance> _knownPlayer;
protected L2CharacterAI _ai;
@@ -613,8 +603,5 @@
_isAttacked = false;
- _lastAttackChange = 0;
-
- _knownObjects = Collections.synchronizedSet(new FastSet<L2Object>());
- _knownPlayer = Collections.synchronizedSet(new FastSet<L2PcInstance>());
+ _lastAttackChange = 0;
if (template != null && this instanceof L2NpcInstance)
@@ -3087,30 +3074,5 @@
*
*/
- public boolean addKnownObject(L2Object object, @SuppressWarnings("unused") L2Character dropper)
- {
- if (object == null || !this.isVisible())
- return false;
-
- if (knowsObject(object))
- {
- if (!object.isVisible())
- removeKnownObject(object);
- return false;
- }
-
- double farAway = getDistanceToWatchObject(object); // Set to 4000
-
- if (getDistance(object.getX(), object.getY()) >= farAway)
- return false;
-
- //Add object to L2ObjectHashSet(L2Object) _knownObjects of the L2Character
- _knownObjects.add(object);
-
- //If object is a L2PcInstance, remove object from L2ObjectHashSet(L2PcInstance) _knownPlayer of the L2Character
- if (object instanceof L2PcInstance)
- _knownPlayer.add((L2PcInstance)object);
-
- return true;
- }
+ public abstract boolean addKnownObject(L2Object object, @SuppressWarnings("unused") L2Character dropper);
@@ -3124,15 +3086,6 @@
*
*/
- public void removeKnownObject(L2Object object)
- {
- //Remove object from _knownObjects of the L2Character
- _knownObjects.remove(object);
- // If object is a L2PcInstance, remove object from _knownPlayer of the L2Character
- if (object instanceof L2PcInstance)
- _knownPlayer.remove(object);
- // If object is targeted by the L2Character, cancel Attack or Cast
- if (object == getTarget())
- setTarget(null);
- }
+
+ public abstract void removeKnownObject(L2Object object);
/**
@@ -3142,78 +3095,22 @@
*
*/
- public final boolean knowsObject(L2Object object)
- {
- return this == object || _knownObjects.contains(object);
- }
+ public abstract boolean knowsObject(L2Object object);
- public Collection<L2Character> getKnownCharactersInRadius(long radius)
- {
- FastList<L2Character> result = new FastList<L2Character>();
-
- if (_knownPlayer != null)
- {
- for (L2PcInstance player : _knownPlayer)
- {
- if (player == null) continue;
- if (Util.checkIfInRange((int)radius, this, player, true))
- result.add(player);
- }
- }
-
- if (_knownObjects != null)
- {
- for (L2Object obj : _knownObjects)
- {
- if (obj instanceof L2MonsterInstance)
- {
- if (Util.checkIfInRange((int)radius, this, obj, true))
- result.add((L2MonsterInstance)obj);
- }
- else if (obj instanceof L2NpcInstance)
- {
- if (Util.checkIfInRange((int)radius, this, obj, true))
- result.add((L2NpcInstance)obj);
- }
-
- }
- }
-
- return result;
- }
-
+ public abstract Collection<L2Character> getKnownCharactersInRadius(int radius);
/**
* Remove all L2Object from _knownObjects and _knownPlayer of the L2Character then cancel Attak or Cast and notify AI.<BR><BR>
*/
- public final void removeAllKnownObjects()
- {
- // Remove all L2Object from L2ObjectHashSet(L2Object) containing all L2Object detected by the L2Character
- _knownObjects.clear();
- _knownPlayer.clear();
-
- // Set _target of the L2Character to null
- // Cancel Attack or Cast
- setTarget(null);
-
- // Cancel AI Task
- if (this.hasAI())
- _ai = null;
- }
+ public abstract void removeAllKnownObjects();
/**
* Return the _knownPlayer containing all players known by the L2Character.<BR><BR>
*/
- public final Collection<L2PcInstance> getKnownPlayers()
- {
- return _knownPlayer;
- }
+ public abstract Collection<L2PcInstance> getKnownPlayers();
/**
* Return the _knownObjects containing all L2Object known by the L2Character.<BR><BR>
*/
- public final Collection<L2Object> getKnownObjects()
- {
- return _knownObjects;
- }
+ public abstract Collection<L2Object> getKnownObjects();
/**
@@ -3223,45 +3120,5 @@
*
*/
- public final boolean knowsThePlayer(L2PcInstance player)
- {
- return this == player || _knownPlayer.contains(player);
- }
-
- /**
- * Remove invisible and too far L2Object from _knowObject and if necessary from _knownPlayers.<BR><BR>
- */
- private void forgetDistantObjects()
- {
- //Create an iterator to go through _knownObjects
- if (_knownObjects == null || _knownObjects.size() <= 0)
- return;
-
- Iterator<L2Object> iter = _knownObjects.iterator();
-
- // Go through _knownObjects
- while (iter != null && iter.hasNext())
- {
- L2Object object = iter.next();
-
- if (object == null) continue;
-
- // Remove all invisible object from _knownObjects is invisible
- if (object != null && !object.isVisible()) {
- removeKnownObject(object);
- continue;
- }
-
- double dx = getX() - object.getX();
- double dy = getY() - object.getY();
- double farAway = getDistanceToForgetObject(object);
-
- // Remove all too far object from _knownObjects
- if ( dx*dx+dy*dy > farAway*farAway ) {
- removeKnownObject(object);
- continue;
- }
-
- }
- }
+ public abstract boolean knowsThePlayer(L2PcInstance player);
/**
@@ -3302,56 +3159,5 @@
*/
- public final synchronized void updateKnownObjects()
- {
- // Remove invisible and too far L2Object from _knowObject and if necessary from _knownPlayers of the L2Character
- forgetDistantObjects();
-
- // Add visible L2Object near the L2Character to _knowObject and if necessary to _knownPlayers of the L2Character
- // Add L2Character to _knowObject and if necessary to _knownPlayers of L2Object alreday known by the L2Character
- findCloseObjects();
- }
-
- /**
- * Add visible L2Object near the L2Character to _knowObject and if necessary to _knownPlayers of L2Character.
- * Add L2Character to _knowObject and if necessary to _knownPlayers of L2Object alreday known by the L2Character.<BR><BR>
- */
- private void findCloseObjects()
- {
- if (isDead() || !isVisible())
- return;
-
- // Get all visible L2Object near the L2Character
- Collection<L2Object> objects = L2World.getInstance().getVisibleObjects(this);
-
- // Go through all visible L2Object near the L2Character
- for (L2Object object : objects)
- {
- // Check if the object is already known
- if (object != null && knowsObject(object))
- {
- if (!(object instanceof L2Character))
- continue;
-
- // Check if the object already know the L2Character
- if (!object.knowsObject(this))
- {
- L2Character tgt = (L2Character)object;
- // Add the L2Character in _knownObject and if necessary in _knownPlayers of the object
- tgt.addKnownObject(this, null);
- }
-
- }
- else
- {
- // Add the object in _knownObject and if necessary in _knownPlayers of the L2Character
- addKnownObject(object, null);
-
- //TODO Why don't we add the L2Character to the object _knowObject and if necessary _knowPlayers
-
- }
-
- }
-
- }
+ public abstract void updateKnownObjects();
/**
@@ -5862,3 +5668,4 @@
}
}
+
}
Index: trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2DoorInstance.java
===================================================================
--- trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2DoorInstance.java (revision 1901)
+++ trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2DoorInstance.java (revision 2019)
@@ -37,4 +37,5 @@
import net.sf.l2j.gameserver.templates.L2CharTemplate;
import net.sf.l2j.gameserver.templates.L2Weapon;
+import net.sf.l2j.gameserver.util.knownlist.DoorKnownList;
/**
@@ -55,4 +56,7 @@
private int _autoActionDelay = -1;
private ScheduledFuture _autoActionTask;
+
+ protected final DoorKnownList _knownList = new DoorKnownList(this);
+
/** This class may be created only by L2Character and only for AI */
@@ -428,3 +432,75 @@
return _name;
}
+
+ public boolean addKnownObject(L2Object object, @SuppressWarnings("unused") L2Character dropper)
+ {
+ return _knownList.add(object);
+ }
+
+ public void removeKnownObject(L2Object object)
+ {
+ _knownList.remove(object);
+
+ if (object == getTarget())
+ setTarget(null);
+ }
+
+ public boolean knowsObject(L2Object object)
+ {
+ return _knownList.knowsObject(object);
+ }
+
+ public Collection<L2Character> getKnownCharactersInRadius(int radius)
+ {
+ return _knownList.getKnownAllCharactersInRadius(radius);
+ }
+
+ public void removeAllKnownObjects()
+ {
+ _knownList.clear();
+
+ // Set _target of the L2Character to null
+ // Cancel Attack or Cast
+ setTarget(null);
+
+ // Cancel AI Task
+ if (this.hasAI())
+ _ai = null;
+ }
+
+ public Collection<L2PcInstance> getKnownPlayers()
+ {
+ return _knownList.getKnownPlayers();
+ }
+
+ public Collection<L2Object> getKnownObjects()
+ {
+ return _knownList.getKnownObjects();
+ }
+
+ public boolean knowsThePlayer(L2PcInstance player)
+ {
+ return _knownList.knowsPlayer(player);
+ }
+
+ public void updateKnownObjects()
+ {
+ _knownList.update();
+ }
+
+ public Collection<L2SiegeGuardInstance> getKnownSiegeGuards()
+ {
+ return _knownList.getKnownSiegeGuards();
+ }
+
+ public Collection<L2SiegeGuardInstance> getKnownSiegeGuardsInRadius(int radius)
+ {
+ return _knownList.getKnownSiegeGuardsInRadius(radius);
+ }
+
+ public boolean knowsSiegeGuard(L2SiegeGuardInstance guard)
+ {
+ return _knownList.knowsSiegeGuard(guard);
+ }
+
}
Index: trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2NpcInstance.java
===================================================================
--- trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2NpcInstance.java (revision 1960)
+++ trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2NpcInstance.java (revision 2019)
@@ -19,4 +19,5 @@
package net.sf.l2j.gameserver.model;
+import java.util.Collection;
import java.util.List;
import java.util.Random;
@@ -50,4 +51,5 @@
import net.sf.l2j.gameserver.templates.L2NpcTemplate;
import net.sf.l2j.gameserver.templates.L2Weapon;
+import net.sf.l2j.gameserver.util.knownlist.NpcKnownList;
/**
@@ -90,4 +92,6 @@
private int _CastleIndex = -2;
private L2Castle _Castle;
+
+ protected final NpcKnownList _knownList = new NpcKnownList(this);
/** Task lauching the function onRandomAnimation() */
@@ -1589,3 +1593,60 @@
this.onDecay();
}
+
+ public boolean addKnownObject(L2Object object, @SuppressWarnings("unused") L2Character dropper)
+ {
+ return _knownList.add(object);
+ }
+
+ public void removeKnownObject(L2Object object)
+ {
+ _knownList.remove(object);
+
+ if (object == getTarget())
+ setTarget(null);
+ }
+
+ public boolean knowsObject(L2Object object)
+ {
+ return _knownList.knowsObject(object);
+ }
+
+ public Collection<L2Character> getKnownCharactersInRadius(int radius)
+ {
+ return _knownList.getKnownAllCharactersInRadius(radius);
+ }
+
+ public void removeAllKnownObjects()
+ {
+ _knownList.clear();
+
+ // Set _target of the L2Character to null
+ // Cancel Attack or Cast
+ setTarget(null);
+
+ // Cancel AI Task
+ if (this.hasAI())
+ _ai = null;
+ }
+
+ public Collection<L2PcInstance> getKnownPlayers()
+ {
+ return _knownList.getKnownPlayers();
+ }
+
+ public Collection<L2Object> getKnownObjects()
+ {
+ return _knownList.getKnownObjects();
+ }
+
+ public boolean knowsThePlayer(L2PcInstance player)
+ {
+ return _knownList.knowsPlayer(player);
+ }
+
+ public void updateKnownObjects()
+ {
+ _knownList.update();
+ }
+
}
Index: trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2PcInstance.java
===================================================================
--- trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2PcInstance.java (revision 2013)
+++ trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2PcInstance.java (revision 2019)
@@ -26,4 +26,5 @@
import java.sql.ResultSet;
import java.util.Calendar;
+import java.util.Collection;
import java.util.Collections;
import java.util.List;
@@ -115,4 +116,5 @@
import net.sf.l2j.gameserver.templates.L2WeaponType;
import net.sf.l2j.gameserver.util.Broadcast;
+import net.sf.l2j.gameserver.util.knownlist.PcKnownList;
import net.sf.l2j.util.Point3D;
@@ -419,4 +421,7 @@
private long _lastAccess;
private int _boatId;
+
+ protected final PcKnownList _knownList = new PcKnownList(this);
+
/**
@@ -3089,5 +3094,5 @@
{
// Add a visible L2Object to _knownObjects and if necessary to _knownPlayer of the L2PcInstance
- boolean ret = super.addKnownObject(object, dropper);
+ boolean ret = _knownList.add(object);
if (!ret)
@@ -3173,20 +3178,20 @@
*
*/
- public void removeKnownObject(L2Object object)
- {
- if (knowsObject(object))
- {
- // Remove a L2Object from _knownObjects and if necessary from _knownPlayer of the L2PcInstance then cancel Attak or Cast if it was targeted
- super.removeKnownObject(object);
-
- // Send Server-Client Packet DeleteObject to the L2PcInstance
- sendPacket(new DeleteObject(object));
- if (Config.CHECK_KNOWN && object instanceof L2NpcInstance)
+ public void removeKnownObject(L2Object object)
+ {
+ if (_knownList.remove(object))
+ {
+ if (object == getTarget())
+ setTarget(null);
+
+ // Send Server-Client Packet DeleteObject to the L2PcInstance
+ sendPacket(new DeleteObject(object));
+ if (Config.CHECK_KNOWN && object instanceof L2NpcInstance)
{
- sendMessage("Removed NPC: "+((L2NpcInstance)object).getName());
+ sendMessage("Removed NPC: "+((L2NpcInstance)object).getName());
}
- }
-
- }
+ }
+
+ }
@@ -6644,3 +6649,77 @@
_boatId = boatId;
}
+
+ public boolean knowsObject(L2Object object)
+ {
+ return _knownList.knowsObject(object);
+ }
+
+ public Collection<L2Character> getKnownCharactersInRadius(int radius)
+ {
+ return _knownList.getKnownAllCharactersInRadius(radius);
+ }
+
+ public void removeAllKnownObjects()
+ {
+ _knownList.clear();
+
+ // Set _target of the L2Character to null
+ // Cancel Attack or Cast
+ setTarget(null);
+
+ // Cancel AI Task
+ if (this.hasAI())
+ _ai = null;
+ }
+
+ public Collection<L2PcInstance> getKnownPlayers()
+ {
+ return _knownList.getKnownPlayers();
+ }
+
+ public Collection<L2Object> getKnownObjects()
+ {
+ return _knownList.getKnownObjects();
+ }
+
+ public boolean knowsThePlayer(L2PcInstance player)
+ {
+ return _knownList.knowsPlayer(player);
+ }
+
+ public void updateKnownObjects()
+ {
+ _knownList.update();
+ }
+
+ public final Collection<L2Character> getKnownCharacters()
+ {
+ return _knownList.getKnownCharacters();
+ }
+
+ public final Collection<L2Object> getKnownOthers()
+ {
+ return _knownList.getKnownOthers();
+ }
+
+ public final Collection<L2Character> getKnownOnlyCharactersInRadius(int radius)
+ {
+ return _knownList.getKnownCharactersInRadius(radius);
+ }
+
+ public final Collection<L2Object> getKnownOthersInRadius(int radius)
+ {
+ return _knownList.getKnownOthersInRadius(radius);
+ }
+
+ public final boolean knowsCharacter(L2Character cha)
+ {
+ return _knownList.knowsCharacter(cha);
+ }
+
+ public final boolean knowsOtherObject(L2Object object)
+ {
+ return _knownList.knowsOtherObject(object);
+ }
+
}
Index: trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2PlayableInstance.java
===================================================================
--- trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2PlayableInstance.java (revision 655)
+++ trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2PlayableInstance.java (revision 2019)
@@ -1,3 +1,5 @@
package net.sf.l2j.gameserver.model;
+
+import java.util.Collection;
import net.sf.l2j.gameserver.templates.L2CharTemplate;
@@ -39,3 +41,15 @@
public abstract void removeItemFromInventory(L2ItemInstance item, int count);
+
+ /* KnownList implementation */
+ public abstract boolean addKnownObject(L2Object object, @SuppressWarnings("unused") L2Character dropper);
+ public abstract void removeKnownObject(L2Object object);
+ public abstract boolean knowsObject(L2Object object);
+ public abstract Collection<L2Character> getKnownCharactersInRadius(int radius);
+ public abstract void removeAllKnownObjects();
+ public abstract Collection<L2PcInstance> getKnownPlayers();
+ public abstract Collection<L2Object> getKnownObjects();
+ public abstract boolean knowsThePlayer(L2PcInstance player);
+ public abstract void updateKnownObjects();
+
}
Index: trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2Summon.java
===================================================================
--- trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2Summon.java (revision 1765)
+++ trunk/L2_Gameserver/java/net/sf/l2j/gameserver/model/L2Summon.java (revision 2019)
@@ -19,4 +19,5 @@
package net.sf.l2j.gameserver.model;
+import java.util.Collection;
import java.util.concurrent.Future;
import java.util.logging.Logger;
@@ -35,4 +36,5 @@
import net.sf.l2j.gameserver.templates.L2NpcTemplate;
import net.sf.l2j.gameserver.templates.L2Weapon;
+import net.sf.l2j.gameserver.util.knownlist.NpcKnownList;
public abstract class L2Summon extends L2PlayableInstance
@@ -55,4 +57,7 @@
private boolean _showSummonAnimation;
+ protected final NpcKnownList _knownList = new NpcKnownList(this);
+
+
public class AIAccessor extends L2Character.AIAccessor
{
@@ -393,3 +398,60 @@
super.useMagic(skill);
}
+
+ public boolean addKnownObject(L2Object object, @SuppressWarnings("unused") L2Character dropper)
+ {
+ return _knownList.add(object);
+ }
+
+ public void removeKnownObject(L2Object object)
+ {
+ _knownList.remove(object);
+
+ if (object == getTarget())
+ setTarget(null);
+ }
+
+ public boolean knowsObject(L2Object object)
+ {
+ return _knownList.knowsObject(object);
+ }
+
+ public Collection<L2Character> getKnownCharactersInRadius(int radius)
+ {
+ return _knownList.getKnownAllCharactersInRadius(radius);
+ }
+
+ public void removeAllKnownObjects()
+ {
+ _knownList.clear();
+
+ // Set _target of the L2Character to null
+ // Cancel Attack or Cast
+ setTarget(null);
+
+ // Cancel AI Task
+ if (this.hasAI())
+ _ai = null;
+ }
+
+ public Collection<L2PcInstance> getKnownPlayers()
+ {
+ return _knownList.getKnownPlayers();
+ }
+
+ public Collection<L2Object> getKnownObjects()
+ {
+ return _knownList.getKnownObjects();
+ }
+
+ public boolean knowsThePlayer(L2PcInstance player)
+ {
+ return _knownList.knowsPlayer(player);
+ }
+
+ public void updateKnownObjects()
+ {
+ _knownList.update();
+ }
+
}
Index: trunk/L2_Gameserver/java/net/sf/l2j/gameserver/util/CharacterKnownList.java
===================================================================
--- trunk/L2_Gameserver/java/net/sf/l2j/gameserver/util/CharacterKnownList.java (revision 2013)
+++ (revision )
@@ -1,204 +1,0 @@
-/*
- * $Header: CharacterKnownList.java, 4/12/2005 16:15:15 luisantonioa Exp $
- *
- * $Author: luisantonioa $
- * $Date: 4/12/2005 16:15:15 $
- * $Revision: 1 $
- * $Log: CharacterKnownList.java,v $
- * Revision 1 4/12/2005 16:15:15 luisantonioa
- * Added copyright notice
- *
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- *
- * http://www.gnu.org/copyleft/gpl.html
- */
-package net.sf.l2j.gameserver.util;
-
-import javolution.util.FastList;
-import javolution.util.FastSet;
-import javolution.util.FastCollection.Record;
-import net.sf.l2j.Config;
-import net.sf.l2j.gameserver.model.L2Character;
-import net.sf.l2j.gameserver.model.L2Object;
-import net.sf.l2j.gameserver.model.L2World;
-import net.sf.l2j.util.Point3D;
-
-/**
- * This class ...
- *
- * @version $Revision: 1.2 $ $Date: 2004/06/27 08:12:59 $
- */
-
-public class CharacterKnownList extends KnownList
-{
- private static final int MINIMUM_UPDATE_DISTANCE_SQUARED = Config.MINIMUM_UPDATE_DISTANCE * Config.MINIMUM_UPDATE_DISTANCE;
-
- private final L2Character owner;
- private final Point3D lastPosition;
-
- public CharacterKnownList(L2Character owner)
- {
- this.owner = owner;
- this.lastPosition = new Point3D(owner.getPosition().getWorldPosition());
- }
-
- public void updateKnownObjects()
- {
- boolean update = false;
-
- synchronized (this)
- {
- Point3D worldPosition = owner.getPosition().getWorldPosition();
- if (worldPosition.distanceSquaredTo(lastPosition) > MINIMUM_UPDATE_DISTANCE_SQUARED)
- {
- lastPosition.setTo(worldPosition);
- update = true;
- }
- }
-
- if (update)
- {
- forgetDistantObjects();
- findCloseObjects();
- }
- }
-
- private void forgetDistantObjects()
- {
- forgetDistantObjects(knownMonsters);
- forgetDistantObjects(knownNpcs);
- forgetDistantObjects(knownObjects);
- forgetDistantObjects(knownPlayers);
- forgetDistantObjects(knownCharacters);
- }
-
- private final <T extends L2Object> void forgetDistantObjects(FastSet<T> objectList)
- {
- FastList<T> toRemove = new FastList<T>();
-
- double dx = 0;
- double dy = 0;
- double distance = 0;
-
- int currentX = owner.getPosition().getWorldPosition().getX();
- int currentY = owner.getPosition().getWorldPosition().getY();
-
- if (objectList == null || objectList.size() <= 0)
- return;
-
- // Go through _knownObjects
- Record r = objectList.head(), end = objectList.tail();
-
- if (r == null)
- return;
-
- while ((r = r.getNext()) != end && r != null)
- {
- T object = objectList.valueOf(r);
- if (object == null)
- continue;
-
- // Remove all invisible object from _knownObjects is invisible
- if (!object.isVisible())
- {
- toRemove.add(object);
- object.removeKnownObject(owner);
- continue;
- }
-
- dx = currentX - object.getX();
- dy = currentY - object.getY();
- distance = owner.getDistanceToForgetObject(object);
-
- // Remove all too far object from _knownObjects
- if ((dx * dx) + (dy * dy) > (distance * distance))
- {
- toRemove.add(object);
- object.removeKnownObject(owner);
- continue;
- }
- }
-
- if (!toRemove.isEmpty()) objectList.removeAll(toRemove);
- }
-
- private void findCloseObjects()
- {
- if (owner.isDead() || !owner.isVisible())
- return;
-
- // Go through all visible L2Object near the L2Character
- for (L2Object object : L2World.getInstance().getVisibleObjects(owner))
- {
- //add object to our known list
- owner.addKnownObject(object, null);
-
- //Add owner to added objects 'known' list
- object.addKnownObject(owner, null);
- }
- }
-
- public void removeAllKnownCharacters()
- {
- removeKnownObjects(knownPlayers);
- removeKnownObjects(knownMonsters);
- removeKnownObjects(knownNpcs);
- removeKnownObjects(knownCharacters);
- }
-
- public void clear()
- {
- removeKnownObjects(knownPlayers);
- removeKnownObjects(knownMonsters);
- removeKnownObjects(knownNpcs);
- removeKnownObjects(knownCharacters);
- removeKnownObjects(knownObjects);
- }
-
- private final <T extends L2Object> void removeKnownObjects(FastSet<T> set)
- {
- if (set == null || set.size() <= 0)
- return;
-
- Record r = set.head(), end = set.tail();
- while (r != null && (r = r.getNext()) != end && r != null)
- {
- T object = set.valueOf(r);
- if (object != null)
- object.removeKnownObject(owner);
- }
- if (set != null && set.size() > 0) set.clear();
- }
-
- public KnownList addObject(L2Object object)
- {
- if (!object.equals(owner))
- {
- super.addObject(object);
- }
- return this;
- }
-
- public KnownList removeObject(L2Object object)
- {
- if (!object.equals(owner))
- {
- super.removeObject(object);
- }
- return this;
- }
-}
Index: trunk/L2_Gameserver/java/net/sf/l2j/gameserver/util/KnownList.java
===================================================================
--- trunk/L2_Gameserver/java/net/sf/l2j/gameserver/util/KnownList.java (revision 2013)
+++ (revision )
@@ -1,318 +1,0 @@
-/*
- * $Header: KnownList.java, 21/11/2005 15:53:22 luisantonioa Exp $
- *
- * $Author: luisantonioa $
- * $Date: 21/11/2005 15:53:22 $
- * $Revision: 1 $
- * $Log: KnownList.java,v $
- * Revision 1 21/11/2005 15:53:22 luisantonioa
- * Added copyright notice
- *
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
- * 02111-1307, USA.
- *
- * http://www.gnu.org/copyleft/gpl.html
- */
-package net.sf.l2j.gameserver.util;
-
-import java.util.Collection;
-
-import javolution.util.FastCollection;
-import javolution.util.FastList;
-import javolution.util.FastSet;
-import javolution.util.FastCollection.Record;
-import net.sf.l2j.gameserver.model.L2Character;
-import net.sf.l2j.gameserver.model.L2MonsterInstance;
-import net.sf.l2j.gameserver.model.L2NpcInstance;
-import net.sf.l2j.gameserver.model.L2Object;
-import net.sf.l2j.gameserver.model.L2PcInstance;
-import net.sf.l2j.util.Point3D;
-
-/**
- * This class ...
- *
- * @version $Revision: 1.2 $ $Date: 2004/06/27 08:12:59 $
- */
-
-public abstract class KnownList
-{
- protected final FastSet<L2PcInstance> knownPlayers = new FastSet<L2PcInstance>().preserve();
- protected final FastSet<L2Object> knownObjects = new FastSet<L2Object>().preserve();
- protected final FastSet<L2NpcInstance> knownNpcs = new FastSet<L2NpcInstance>().preserve();
- protected final FastSet<L2Character> knownCharacters = new FastSet<L2Character>().preserve();
- protected final FastSet<L2MonsterInstance> knownMonsters = new FastSet<L2MonsterInstance>().preserve();
-
- public KnownList addObject(L2Object object)
- {
- if (object instanceof L2MonsterInstance)
- {
- addMonster((L2MonsterInstance) object);
- }
- else if (object instanceof L2PcInstance)
- {
- addPlayer((L2PcInstance) object);
- }
- else if (object instanceof L2NpcInstance)
- {
- addNpc((L2NpcInstance) object);
- }
- else if (object instanceof L2Character)
- {
- addCharacter((L2Character) object);
- }
- else
- {
- addOtherObject(object);
- }
-
- return this;
- }
-
- public KnownList addOtherObject(L2Object object)
- {
- if (object != null)
- knownObjects.add(object);
-
- return this;
- }
-
- public KnownList addPlayer(L2PcInstance player)
- {
- if (player != null)
- knownPlayers.add(player);
-
- return this;
- }
-
- public KnownList addCharacter(L2Character character)
- {
- if (character != null)
- knownCharacters.add(character);
-
- return this;
- }
-
- public KnownList addNpc(L2NpcInstance npc)
- {
- if (npc != null)
- knownNpcs.add(npc);
-
- return this;
- }
-
- public KnownList addMonster(L2MonsterInstance monster)
- {
- if (monster != null)
- knownMonsters.add(monster);
-
- return this;
- }
-
- public KnownList removeObject(L2Object object)
- {
- if (object instanceof L2MonsterInstance)
- {
- removeMonster((L2MonsterInstance) object);
- }
- else if (object instanceof L2PcInstance)
- {
- removePlayer((L2PcInstance) object);
- }
- else if (object instanceof L2NpcInstance)
- {
- removeNpc((L2NpcInstance) object);
- }
- else if (object instanceof L2Character)
- {
- removeCharacter((L2Character) object);
- }
- else
- {
- removeOtherObject(object);
- }
-
- return this;
- }
-
- public KnownList removeOtherObject(L2Object object)
- {
- if (object != null)
- knownObjects.remove(object);
-
- return this;
- }
-
- public KnownList removePlayer(L2PcInstance player)
- {
- if (player != null)
- knownPlayers.remove(player);
-
- return this;
- }
-
- public KnownList removeCharacter(L2Character character)
- {
- if (character != null)
- knownCharacters.remove(character);
-
- return this;
- }
-
- public KnownList removeNpc(L2NpcInstance npc)
- {
- if (npc != null)
- knownNpcs.remove(npc);
-
- return this;
- }
-
- public KnownList removeMonster(L2MonsterInstance monster)
- {
- if (monster != null)
- knownMonsters.remove(monster);
-
- return this;
- }
-
- public Collection<L2PcInstance> getKnownPlayers()
- {
- return knownPlayers;
- }
-
- private Collection<L2Character> getKnownCharacters()
- {
- return knownCharacters;
- }
-
- public Collection<L2Character> getAllKnownCharacters()
- {
- FastList<L2Character> allObjects = new FastList<L2Character>();
-
- if (getKnownPlayers().size() > 0) allObjects.addAll(getKnownPlayers());
- if (getKnownMonsters().size() > 0) allObjects.addAll(getKnownMonsters());
- if (getKnownNpcs().size() > 0) allObjects.addAll(getKnownNpcs());
- if (getKnownCharacters().size() > 0) allObjects.addAll(getKnownCharacters());
-
- return allObjects;
- }
-
- public Collection<L2MonsterInstance> getKnownMonsters()
- {
- return knownMonsters;
- }
-
- public Collection<L2NpcInstance> getKnownNpcs()
- {
- return knownNpcs;
- }
-
- public Collection<L2Object> getOtherKnownObjects()
- {
- return knownObjects;
- }
-
- public Collection<L2Object> getAllKnownObjects()
- {
- FastList<L2Object> allObjects = new FastList<L2Object>();
-
- if (getOtherKnownObjects().size() > 0) allObjects.addAll(getOtherKnownObjects());
- if (getKnownPlayers().size() > 0) allObjects.addAll(getKnownPlayers());
- if (getKnownMonsters().size() > 0) allObjects.addAll(getKnownMonsters());
- if (getKnownNpcs().size() > 0) allObjects.addAll(getKnownNpcs());
- if (getKnownCharacters().size() > 0) allObjects.addAll(getKnownCharacters());
-
- return allObjects;
- }
-
- public static final <T extends L2Object> Collection<T> getKnownObjectInRange(FastCollection<T> list, int range, Point3D origin)
- {
- long rangeSquared = range * range;
-
- FastList<T> objectsInRange = new FastList<T>();
-
- Record r = list.head(), end = list.tail();
- while ( (r = r.getNext()) != end && r != null)
- {
- T object = list.valueOf(r);
- if (origin.distanceSquaredTo(object.getPosition().getWorldPosition()) < rangeSquared)
- {
- objectsInRange.add(object);
- }
- }
-
- return objectsInRange;
- }
-
- public Collection<L2PcInstance> getKnownPlayers(int range, Point3D origin)
- {
- return getKnownObjectInRange(knownPlayers, range, origin);
- }
-
- public Collection<L2MonsterInstance> getKnownMonsters(int range, Point3D origin)
- {
- return getKnownObjectInRange(knownMonsters, range, origin);
- }
-
- public Collection<L2NpcInstance> getKnownNpcs(int range, Point3D origin)
- {
- return getKnownObjectInRange(knownNpcs, range, origin);
- }
-
- public Collection<L2Object> getOtherKnownObjects(int range, Point3D origin)
- {
- return getKnownObjectInRange(knownObjects, range, origin);
- }
-
- public Collection<L2Object> getAllKnownObjects(int range, Point3D origin)
- {
- return getKnownObjectInRange((FastList<L2Object>)getAllKnownObjects(), range, origin);
- }
-
- public boolean knowsObject(L2Object object)
- {
- if (object == null)
- return false;
-
- return knownPlayers.contains(object)
- || knownMonsters.contains(object)
- || knownNpcs.contains(object)
- || knownCharacters.contains(object)
- || knownObjects.contains(object);
- }
-
- public boolean knowsPlayer(L2PcInstance player)
- {
- if (player == null)
- return false;
- return knownPlayers.contains(player);
- }
-
- public void clear()
- {
- if (knownPlayers.size() > 0)
- knownPlayers.clear();
- if (knownMonsters.size() > 0)
- knownMonsters.clear();
- if (knownNpcs.size() > 0)
- knownNpcs.clear();
- if (knownCharacters.size() > 0)
- knownCharacters.clear();
- if (knownObjects.size() > 0)
- knownObjects.clear();
- }
-
- public abstract void updateKnownObjects();
-}
Index: trunk/L2_Gameserver/java/net/sf/l2j/gameserver/util/knownlist/DoorKnownList.java
===================================================================
--- (revision )
+++ trunk/L2_Gameserver/java/net/sf/l2j/gameserver/util/knownlist/DoorKnownList.java (revision 2019)
@@ -1,0 +1,202 @@
+/**
+ *
+ */
+package net.sf.l2j.gameserver.util.knownlist;
+
+import static java.util.Collections.EMPTY_LIST;
+
+import java.util.Collection;
+
+import javolution.util.FastMap;
+import javolution.util.FastList;
+import net.sf.l2j.gameserver.model.L2Character;
+import net.sf.l2j.gameserver.model.L2DoorInstance;
+import net.sf.l2j.gameserver.model.L2PcInstance;
+import net.sf.l2j.gameserver.model.L2SiegeGuardInstance;
+import net.sf.l2j.gameserver.model.L2Object;
+import net.sf.l2j.gameserver.util.Util;
+
+/**
+ * @author Layane
+ *
+ */
+public class DoorKnownList extends NpcKnownList
+{
+ protected FastMap<L2Object,L2SiegeGuardInstance> _knownSiegeGuards;
+
+ public DoorKnownList(L2DoorInstance door)
+ {
+ super(door);
+ }
+
+ public boolean add(L2Object object)
+ {
+ if (object == null || !_owner.isVisible() || object == _owner)
+ return false;
+
+ if (knowsObject(object))
+ {
+ if (!object.isVisible())
+ _owner.removeKnownObject(object);
+ return false;
+ }
+
+ if (_owner.getDistance(object.getX(), object.getY()) > _owner.getDistanceToWatchObject(object))
+ return false;
+
+ if (object instanceof L2PcInstance)
+ {
+ addPlayer((L2PcInstance)object);
+ }
+ else if (object instanceof L2SiegeGuardInstance)
+ {
+ addSiegeGuard((L2SiegeGuardInstance)object);
+ }
+
+ return true;
+ }
+
+ public synchronized final void addSiegeGuard(L2SiegeGuardInstance guard)
+ {
+ if (guard == null || guard == _owner)
+ return;
+
+ if (_knownSiegeGuards == null)
+ _knownSiegeGuards = new FastMap<L2Object,L2SiegeGuardInstance>();
+
+ startForgetTask();
+ _knownSiegeGuards.put(guard,guard);
+ }
+
+ public boolean remove(L2Object object)
+ {
+ if (object instanceof L2PcInstance)
+ {
+ return removePlayer((L2PcInstance)object);
+ }
+ else if (object instanceof L2SiegeGuardInstance)
+ {
+ removeSiegeGuard((L2SiegeGuardInstance)object);
+ }
+
+ return false;
+ }
+
+ public final boolean removeSiegeGuard(L2SiegeGuardInstance guard)
+ {
+ if (guard == null || _knownSiegeGuards == null)
+ return false;
+
+ boolean result = (_knownSiegeGuards.remove(guard) != null);
+
+ if (result && size() <= 0)
+ {
+ stopForgetTask();
+ _knownSiegeGuards = null;
+ }
+
+ return result;
+ }
+
+ public boolean knowsObject(L2Object object)
+ {
+ if (object == null)
+ return false;
+
+ if (_knownSiegeGuards != null && _knownSiegeGuards.containsKey(object))
+ return true;
+
+ if (_knownPlayers != null && _knownPlayers.containsKey(object))
+ return true;
+
+ return false;
+ }
+
+ public final boolean knowsSiegeGuard(L2SiegeGuardInstance guard)
+ {
+ if (guard == null || _knownSiegeGuards == null)
+ return false;
+
+ return _knownSiegeGuards.containsKey(guard);
+ }
+
+ @SuppressWarnings("unchecked")
+ public Collection<L2Object> getKnownObjects()
+ {
+ if (_knownPlayers == null && _knownSiegeGuards == null)
+ return EMPTY_LIST;
+
+ FastList<L2Object> result = new FastList<L2Object>();
+
+ if (_knownSiegeGuards != null)
+ result.addAll(_knownSiegeGuards.values());
+
+ return result;
+ }
+
+ @SuppressWarnings("unchecked")
+ public Collection<L2SiegeGuardInstance> getKnownSiegeGuards()
+ {
+ if (_knownSiegeGuards == null)
+ return EMPTY_LIST;
+
+ return _knownSiegeGuards.values();
+ }
+
+ public Collection<L2Character> getKnownAllCharactersInRadius(int radius)
+ {
+ FastList<L2Character> result = new FastList<L2Character>();
+
+ for (L2PcInstance player : _knownPlayers.values())
+ {
+ if (Util.checkIfInRange(radius, _owner, player, true))
+ result.add(player);
+ }
+
+ for (L2SiegeGuardInstance guard : _knownSiegeGuards.values())
+ {
+ if (Util.checkIfInRange(radius, _owner, guard, true))
+ result.add(guard);
+ }
+
+ return result;
+ }
+
+ public final Collection<L2SiegeGuardInstance> getKnownSiegeGuardsInRadius(int radius)
+ {
+ FastList<L2SiegeGuardInstance> result = new FastList<L2SiegeGuardInstance>();
+
+ for (L2SiegeGuardInstance guard : _knownSiegeGuards.values())
+ {
+ if (Util.checkIfInRange(radius, _owner, guard, true))
+ result.add(guard);
+ }
+
+ return result;
+ }
+
+ public void clear()
+ {
+ stopForgetTask();
+
+ if (_knownSiegeGuards != null)
+ _knownSiegeGuards.clear();
+
+ if (_knownPlayers != null)
+ _knownPlayers.clear();
+ }
+
+ public int size()
+ {
+ int result = 0;
+
+ if (_knownSiegeGuards != null)
+ result = _knownSiegeGuards.size();
+
+ if (_knownPlayers != null)
+ result += _knownPlayers.size();
+
+ return 0;
+ }
+
+}
Index: trunk/L2_Gameserver/java/net/sf/l2j/gameserver/util/knownlist/NpcKnownList.java
===================================================================
--- (revision )
+++ trunk/L2_Gameserver/java/net/sf/l2j/gameserver/util/knownlist/NpcKnownList.java (revision 2019)
@@ -1,0 +1,225 @@
+/**
+ *
+ */
+package net.sf.l2j.gameserver.util.knownlist;
+
+import static java.util.Collections.EMPTY_LIST;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.Future;
+
+import javolution.util.FastList;
+import javolution.util.FastMap;
+import net.sf.l2j.Config;
+import net.sf.l2j.gameserver.ClientScheduler;
+import net.sf.l2j.gameserver.model.L2Character;
+import net.sf.l2j.gameserver.model.L2Object;
+import net.sf.l2j.gameserver.model.L2PcInstance;
+import net.sf.l2j.gameserver.util.Util;
+import net.sf.l2j.util.Point3D;
+
+
+/**
+ * @author Layane
+ * $version: $
+ */
+public class NpcKnownList
+{
+ public static final int MINIMUM_UPDATE_DISTANCE_SQUARED = Config.MINIMUM_UPDATE_DISTANCE * Config.MINIMUM_UPDATE_DISTANCE;
+
+ protected Map<L2Object,L2PcInstance> _knownPlayers;
+
+ protected final L2Character _owner;
+
+ protected long _lastUpdate;
+ protected Point3D _lastUpdatePosition;
+
+ private Future _forgetTask;
+
+ class ForgetTask implements Runnable
+ {
+ public void run()
+ {
+ forgetKnownObjects();
+ }
+ }
+
+
+ public NpcKnownList(L2Character owner)
+ {
+ _owner = owner;
+ _lastUpdate = System.currentTimeMillis();
+ _lastUpdatePosition = new Point3D(owner.getPosition().getWorldPosition());
+ }
+
+ public boolean add(L2Object object)
+ {
+ if (object == null || !_owner.isVisible() || object == _owner)
+ return false;
+
+ if (knowsObject(object))
+ {
+ if (!object.isVisible())
+ _owner.removeKnownObject(object);
+ return false;
+ }
+
+ if (_owner.getDistance(object.getX(), object.getY()) > _owner.getDistanceToWatchObject(object))
+ return false;
+
+ if (object instanceof L2PcInstance)
+ {
+ addPlayer((L2PcInstance)object);
+ }
+
+ return true;
+ }
+
+ public synchronized final void addPlayer(L2PcInstance player)
+ {
+ if (player == null)
+ return;
+
+ if (_knownPlayers == null)
+ _knownPlayers = new FastMap<L2Object,L2PcInstance>();
+
+ startForgetTask();
+ _knownPlayers.put(player,player);
+ }
+
+ public boolean remove(L2Object object)
+ {
+ if (object instanceof L2PcInstance)
+ {
+ return removePlayer((L2PcInstance)object);
+ }
+ return false;
+ }
+
+ public final boolean removePlayer(L2PcInstance player)
+ {
+ if (player == null || _knownPlayers == null)
+ return false;
+
+ boolean result = (_knownPlayers.remove(player) != null);
+
+ if (result && size() <= 0)
+ {
+ stopForgetTask();
+ _knownPlayers = null;
+ }
+
+ return result;
+ }
+
+ public boolean knowsObject(L2Object object)
+ {
+ if (object == null || _knownPlayers == null)
+ return false;
+
+ return _knownPlayers.containsKey(object);
+ }
+
+ public final boolean knowsPlayer(L2PcInstance player)
+ {
+ if (player == null || _knownPlayers == null)
+ return false;
+
+ return _knownPlayers.containsKey(player);
+ }
+
+ @SuppressWarnings("unchecked")
+ public Collection<L2Object> getKnownObjects()
+ {
+ if (_knownPlayers == null)
+ return EMPTY_LIST;
+
+ return _knownPlayers.keySet();
+ }
+
+ @SuppressWarnings("unchecked")
+ public final Collection<L2PcInstance> getKnownPlayers()
+ {
+ if (_knownPlayers == null)
+ return EMPTY_LIST;
+
+ return _knownPlayers.values();
+ }
+
+ public Collection<L2Character> getKnownAllCharactersInRadius(int radius)
+ {
+ FastList<L2Character> result = new FastList<L2Character>();
+
+ for (L2PcInstance player : _knownPlayers.values())
+ {
+ if (Util.checkIfInRange(radius, _owner, player, true))
+ result.add(player);
+ }
+
+ return result;
+ }
+
+ public final Collection<L2PcInstance> getKnownPlayersInRange(int radius)
+ {
+ FastList<L2PcInstance> result = new FastList<L2PcInstance>();
+
+ for (L2PcInstance player : _knownPlayers.values())
+ {
+ if (Util.checkIfInRange(radius, _owner, player, true))
+ result.add(player);
+ }
+
+ return result;
+ }
+
+ public void clear()
+ {
+ stopForgetTask();
+
+ if (_knownPlayers != null)
+ _knownPlayers.clear();
+ }
+
+ public int size()
+ {
+ if (_knownPlayers != null)
+ return _knownPlayers.size();
+ return 0;
+ }
+
+ public void update()
+ {
+ }
+
+ private void forgetKnownObjects()
+ {
+ for (L2PcInstance player : _knownPlayers.values())
+ {
+ // Remove all invisible object from _knownObjects is invisible
+ if (!player.isVisible())
+ {
+ _owner.removeKnownObject(player);
+ continue;
+ }
+
+ long distance = _owner.getDistanceToForgetObject(player);
+
+ if (_owner.getPosition().getWorldPosition().distanceSquaredTo(player.getPosition().getWorldPosition()) > (distance*distance))
+ _owner.removeKnownObject(player);
+ }
+ }
+
+ protected synchronized void startForgetTask()
+ {
+ if (_forgetTask == null)
+ _forgetTask = ClientScheduler.getInstance().scheduleLowAtFixedRate(new ForgetTask(),Config.KNOWNLIST_FORGET_DELAY,Config.KNOWNLIST_FORGET_DELAY);
+ }
+
+ protected synchronized void stopForgetTask()
+ {
+ if (_forgetTask != null)
+ _forgetTask.cancel(true);
+ }
+
+}
Index: trunk/L2_Gameserver/java/net/sf/l2j/gameserver/util/knownlist/PcKnownList.java
===================================================================
--- (revision )
+++ trunk/L2_Gameserver/java/net/sf/l2j/gameserver/util/knownlist/PcKnownList.java (revision 2019)
@@ -1,0 +1,399 @@
+/**
+ *
+ */
+package net.sf.l2j.gameserver.util.knownlist;
+
+import static java.util.Collections.EMPTY_LIST;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+
+import javolution.util.FastList;
+import javolution.util.FastMap;
+import javolution.util.FastSet;
+import net.sf.l2j.Config;
+import net.sf.l2j.gameserver.model.L2Character;
+import net.sf.l2j.gameserver.model.L2Object;
+import net.sf.l2j.gameserver.model.L2PcInstance;
+import net.sf.l2j.gameserver.model.L2World;
+import net.sf.l2j.gameserver.model.L2WorldRegion;
+import net.sf.l2j.gameserver.util.Util;
+import net.sf.l2j.util.Point3D;
+
+/**
+ * @author Layane
+ * $version: $
+ *
+ * Lot of duplicate code on all redefined classes to optimize the call stack
+ * because knownlist a critical routine.
+ */
+public class PcKnownList extends NpcKnownList
+{
+ protected Map<L2Object,L2Character> _knownCharacters;
+ protected Map<L2Object,L2Object> _knownOthers;
+
+ protected final int _vision;
+
+ public PcKnownList(L2PcInstance owner)
+ {
+ super(owner);
+ _vision = _owner.getDistanceToWatchObject(null);
+ }
+
+ public boolean add(L2Object object)
+ {
+ if (object == null || !_owner.isVisible())
+ return false;
+
+ if (!object.isVisible() && knowsObject(object))
+ {
+ _owner.removeKnownObject(object);
+ return false;
+ }
+
+ if (_owner.getDistance(object.getX(), object.getY()) > _owner.getDistanceToWatchObject(object))
+ return false;
+
+ if (object instanceof L2PcInstance)
+ {
+ addPlayer((L2PcInstance)object);
+ }
+ else if (object instanceof L2Character)
+ {
+ addCharacter((L2Character)object);
+ }
+ else
+ {
+ addOtherObject(object);
+ }
+
+ return true;
+ }
+
+ public final void addCharacter(L2Character cha)
+ {
+ if (cha == null)
+ return;
+
+ if (_knownCharacters == null)
+ _knownCharacters = new FastMap<L2Object,L2Character>();
+
+ startForgetTask();
+ _knownCharacters.put(cha,cha);
+ }
+
+ public final void addOtherObject(L2Object object)
+ {
+ if (object == null)
+ return;
+
+ if (_knownOthers == null)
+ _knownOthers = new FastMap<L2Object,L2Object>();
+
+ startForgetTask();
+ _knownOthers.put(object,object);
+ }
+
+ public boolean remove(L2Object object)
+ {
+ if (object instanceof L2PcInstance)
+ {
+ return removePlayer((L2PcInstance)object);
+ }
+ else if (object instanceof L2Character)
+ {
+ return removeCharacter((L2Character)object);
+ }
+
+ return removeOtherObject(object);
+ }
+
+ public final boolean removeCharacter(L2Character cha)
+ {
+ if (cha == null || _knownCharacters == null)
+ return false;
+
+ boolean result = (_knownCharacters.remove(cha) != null);
+
+ if (result && size() <= 0)
+ {
+ stopForgetTask();
+ _knownCharacters = null;
+ }
+
+ return result;
+ }
+
+ public final boolean removeOtherObject(L2Object object)
+ {
+ if (object == null || _knownOthers == null)
+ return false;
+
+ boolean result = (_knownOthers.remove(object) != null);
+
+ if (result && size() <= 0)
+ {
+ stopForgetTask();
+ _knownOthers = null;
+ }
+
+ return result;
+ }
+
+ public boolean knowsObject(L2Object object)
+ {
+ if (object == null)
+ return false;
+
+ if (_knownCharacters != null && _knownCharacters.containsKey(object))
+ return true;
+
+ if (_knownPlayers != null && _knownPlayers.containsKey(object))
+ return true;
+
+ if (_knownOthers != null && _knownOthers.containsKey(object))
+ return true;
+
+ return false;
+ }
+
+ public final boolean knowsCharacter(L2Character cha)
+ {
+ if (cha == null || _knownCharacters == null)
+ return false;
+
+ return _knownCharacters.containsKey(cha);
+ }
+
+ public final boolean knowsOtherObject(L2Object object)
+ {
+ if (object == null || _knownOthers == null)
+ return false;
+
+ return _knownOthers.containsKey(object);
+ }
+
+ @SuppressWarnings("unchecked")
+ public Collection<L2Object> getKnownObjects()
+ {
+ if (_knownPlayers == null && _knownCharacters == null)
+ return EMPTY_LIST;
+
+ FastList<L2Object> result = new FastList<L2Object>();
+
+ if (_knownCharacters != null)
+ result.addAll(_knownCharacters.values());
+
+ if (_knownPlayers != null)
+ result.addAll(_knownPlayers.values());
+
+ if (_knownOthers != null)
+ result.addAll(_knownOthers.values());
+
+ return result;
+ }
+
+ @SuppressWarnings("unchecked")
+ public final Collection<L2Character> getKnownCharacters()
+ {
+ if (_knownCharacters == null)
+ return EMPTY_LIST;
+
+ return _knownCharacters.values();
+ }
+
+ @SuppressWarnings("unchecked")
+ public final Collection<L2Object> getKnownOthers()
+ {
+ if (_knownOthers == null)
+ return EMPTY_LIST;
+
+ return _knownOthers.values();
+ }
+
+ public Collection<L2Character> getKnownAllCharactersInRadius(int radius)
+ {
+ FastList<L2Character> result = new FastList<L2Character>();
+
+ for (L2PcInstance player : _knownPlayers.values())
+ {
+ if (Util.checkIfInRange(radius, _owner, player, true))
+ result.add(player);
+ }
+
+ for (L2Character cha : _knownCharacters.values())
+ {
+ if (Util.checkIfInRange(radius, _owner, cha, true))
+ result.add(cha);
+ }
+
+ return result;
+ }
+
+ public final Collection<L2Character> getKnownCharactersInRadius(int radius)
+ {
+ FastList<L2Character> result = new FastList<L2Character>();
+
+ for (L2Character cha : _knownCharacters.values())
+ {
+ if (Util.checkIfInRange(radius, _owner, cha, true))
+ result.add(cha);
+ }
+
+ return result;
+ }
+
+ public final Collection<L2Object> getKnownOthersInRadius(int radius)
+ {
+ FastList<L2Object> result = new FastList<L2Object>();
+
+ for (L2Object object : _knownOthers.values())
+ {
+ if (Util.checkIfInRange(radius, _owner, object, true))
+ result.add(object);
+ }
+
+ return result;
+ }
+
+ public void clear()
+ {
+ stopForgetTask();
+
+ if (_knownPlayers != null)
+ _knownPlayers.clear();
+
+ if (_knownCharacters != null)
+ _knownCharacters.clear();
+
+ if (_knownOthers != null)
+ _knownOthers.clear();
+ }
+
+ public int size()
+ {
+ int result = 0;
+
+ if (_knownPlayers != null)
+ result = _knownPlayers.size();
+
+ if (_knownCharacters != null)
+ result += _knownCharacters.size();
+
+ if (_knownOthers != null)
+ result += _knownOthers.size();
+
+ return result;
+ }
+
+ public void update()
+ {
+ Point3D myPosition;
+ synchronized (this)
+ {
+ //Temporal check to minimize fallout mob problem and limbo fall bugs
+ if ((System.currentTimeMillis() - _lastUpdate) < Config.MINIMUM_UPDATE_DISTANCE)
+ return;
+
+ //Coordinate check to evaluate the position
+ myPosition = _owner.getPosition().getWorldPosition();
+ if (myPosition.distanceSquaredTo(_lastUpdatePosition) <= MINIMUM_UPDATE_DISTANCE_SQUARED)
+ return;
+
+ _lastUpdate = System.currentTimeMillis();
+ _lastUpdatePosition.setTo(myPosition);
+ }
+
+ //Find close objects
+ L2World world = L2World.getInstance();
+
+ int x = myPosition.getX();
+ int y = myPosition.getY();
+
+ //Minimized regions to iterate
+
+ FastSet<L2WorldRegion> adjZones = new FastSet<L2WorldRegion>();
+ L2WorldRegion eval;
+
+ adjZones.add(_owner.getPosition().getWorldRegion());
+
+ //top left
+ if ((eval = world.getRegion(x - _vision, y + _vision)) != null)
+ adjZones.add(eval);
+
+ //left
+ if ((eval = world.getRegion(x - _vision, y)) != null)
+ adjZones.add(eval);
+
+ //left bottom
+ if ((eval = world.getRegion(x - _vision, y - _vision)) != null)
+ adjZones.add(eval);
+
+ //bottom
+ if ((eval = world.getRegion(x, y - _vision)) != null)
+ adjZones.add(eval);
+
+ //right bottom
+ if ((world.getRegion(x + _vision, y - _vision)) != null)
+ adjZones.add(eval);
+
+ //right
+ if ((world.getRegion(x + _vision, y)) != null)
+ adjZones.add(eval);
+
+ //right top
+ if ((world.getRegion(x + _vision, y + _vision)) != null)
+ adjZones.add(eval);
+
+ //top
+ if ((world.getRegion(x, y + _vision)) != null)
+ adjZones.add(eval);
+
+
+ for (L2WorldRegion region : adjZones)
+ {
+ L2Object object;
+ for (Iterator<L2Object> it = region.iterateVisibleObjects();it.hasNext();)
+ {
+ object = it.next();
+ if (Point3D.distanceLessThan(myPosition,object.getPosition().getWorldPosition(),_vision))
+ {
+ object.addKnownObject(_owner,null);
+ _owner.addKnownObject(object, null);
+ }
+ }
+ }
+
+ }
+
+ public void forgetKnownObjects()
+ {
+ for (L2PcInstance player : _knownPlayers.values())
+ {
+ // Remove all invisible object from _knownObjects is invisible
+ if (!player.isVisible())
+ _owner.removeKnownObject(player);
+ else if (_owner.getDistanceToForgetObject(player) > MINIMUM_UPDATE_DISTANCE_SQUARED)
+ _owner.removeKnownObject(player);
+ }
+
+ for (L2Character cha : _knownCharacters.values())
+ {
+ if (!cha.isVisible())
+ _owner.removeKnownObject(cha);
+ if (_owner.getDistanceToForgetObject(cha) > MINIMUM_UPDATE_DISTANCE_SQUARED)
+ _owner.removeKnownObject(cha);
+ }
+
+ for (L2Object object : _knownOthers.values())
+ {
+ if (!object.isVisible())
+ _owner.removeKnownObject(object);
+ if (_owner.getDistanceToForgetObject(object) > MINIMUM_UPDATE_DISTANCE_SQUARED)
+ _owner.removeKnownObject(object);
+ }
+
+ }
+
+}
Index: trunk/L2_Gameserver/java/net/sf/l2j/util/Point3D.java
===================================================================
--- trunk/L2_Gameserver/java/net/sf/l2j/util/Point3D.java (revision 1925)
+++ trunk/L2_Gameserver/java/net/sf/l2j/util/Point3D.java (revision 2019)
@@ -89,5 +89,5 @@
public int hashCode()
{
- return (x+y+z)%Integer.MAX_VALUE;
+ return x^y^z;
}