BETA: L2Party, L2CommandChannel refactoring by Battlecruiser

More info: http://www.l2jserver.com/forum/viewtopic.php?f=69&t=24878

L2J_Server_BETA/java/com/l2jserver/gameserver/model/AbstractPlayerGroup.java

@@ -0,0 +1,192 @@
+/*
+ * 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 3 of the License, 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, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jserver.gameserver.model;
+
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.CreatureSay;
+import com.l2jserver.gameserver.network.serverpackets.L2GameServerPacket;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+import com.l2jserver.util.Rnd;
+
+/**
+ * @author Battlecruiser
+ * @thx Probe for comments
+ */
+public abstract class AbstractPlayerGroup
+{
+	/**
+	 * @return all members of this group
+	 */
+	public abstract List<L2PcInstance> getMembers();
+	
+	/**
+	 * @return object IDs of all members of this group
+	 */
+	public List<Integer> getMembersObjectId()
+	{
+		final List<Integer> ids = new FastList<>();
+		forEachMember(new IL2Procedure<L2PcInstance>()
+		{
+			
+			@Override
+			public boolean execute(L2PcInstance member)
+			{
+				ids.add(member.getObjectId());
+				return true;
+			}
+		});
+		return ids;
+	}
+	
+	/**
+	 * @return leader of this group
+	 */
+	public abstract L2PcInstance getLeader();
+	
+	/**
+	 * @return the leader's object ID
+	 */
+	public int getLeaderObjectId()
+	{
+		return getLeader().getObjectId();
+	}
+	
+	/**
+	 * @return count of all players in this group
+	 */
+	public int getMemberCount()
+	{
+		return getMembers().size();
+	}
+	
+	/**
+	 * @return level of this group
+	 */
+	public abstract int getLevel();
+	
+	/**
+	 * Broadcast packet to every member of this group
+	 * @param packet packet to broadcast
+	 */
+	public void broadcastPacket(final L2GameServerPacket packet)
+	{
+		forEachMember(new IL2Procedure<L2PcInstance>()
+		{
+			
+			@Override
+			public boolean execute(L2PcInstance member)
+			{
+				if (member != null)
+				{
+					member.sendPacket(packet);
+				}
+				return true;
+			}
+		});
+	}
+	
+	/**
+	 * Broadcasts a System Message to this group
+	 * @param message System Message to bradcast
+	 */
+	public void broadcastMessage(SystemMessageId message)
+	{
+		broadcastPacket(SystemMessage.getSystemMessage(message));
+	}
+	
+	/**
+	 * Broadcasts a string message to this group
+	 * @param text to broadcast
+	 */
+	public void broadcastString(String text)
+	{
+		broadcastPacket(SystemMessage.sendString(text));
+	}
+	
+	public void broadcastCreatureSay(final CreatureSay msg, final L2PcInstance broadcaster)
+	{
+		forEachMember(new IL2Procedure<L2PcInstance>()
+		{
+			
+			@Override
+			public boolean execute(L2PcInstance member)
+			{
+				if ((member != null) && !BlockList.isBlocked(member, broadcaster))
+				{
+					member.sendPacket(msg);
+				}
+				return true;
+			}
+		});
+	}
+	
+	/**
+	 * @param player to be contained
+	 * @return {@code true} if this group contains player
+	 */
+	public boolean containsPlayer(L2PcInstance player)
+	{
+		return getMembers().contains(player);
+	}
+	
+	/**
+	 * @return random member of this group
+	 */
+	public L2PcInstance getRandomPlayer()
+	{
+		return getMembers().get(Rnd.get(getMemberCount()));
+	}
+	
+	/**
+	 * Iterates over the group and executes procedure on each member
+	 * @param procedure to be executed on members, <br>
+	 *            if it returns {@code true}, loop will continue, <br>
+	 *            if it returns {@code false}, loop will break
+	 * @return {@code false} if it was interupted by a {@code false} return of the procedure
+	 */
+	public boolean forEachMember(IL2Procedure<L2PcInstance> procedure)
+	{
+		for (L2PcInstance player : getMembers())
+		{
+			if (!procedure.execute(player))
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+	
+	@Override
+	public boolean equals(Object obj)
+	{
+		if (getClass().equals(obj.getClass()))
+		{
+			return getLeader().equals(((AbstractPlayerGroup) obj).getLeader());
+			
+		}
+		return false;
+	}
+	
+	@Override
+	public int hashCode()
+	{
+		return getLeader().hashCode();
+	}
+}

L2J_Server_BETA/java/com/l2jserver/gameserver/model/IL2Procedure.java

@@ -0,0 +1,30 @@
+/*
+ * 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 3 of the License, 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, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jserver.gameserver.model;
+
+/**
+ * Interface for procedures with one Object parameter.
+ * @author Battlecruiser
+ * @param <T> the type of object on which the procedure will be executed
+ */
+public interface IL2Procedure<T>
+{
+	/**
+	 * Executes this procedure. A false return value indicates that the application executing this procedure should not invoke this procedure again.
+	 * @param arg the object on which the procedure will be executed
+	 * @return {@code true} if additional invocations of the procedure are allowed.
+	 */
+	public boolean execute(T arg);
+}

L2J_Server_BETA/java/com/l2jserver/gameserver/model/L2CommandChannel.java

@@ -30,9 +30,9 @@ import com.l2jserver.gameserver.network.serverpackets.L2GameServerPacket;
 import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
 
 /**
- * @author  chris_00
+ * @author chris_00
  */
-public class L2CommandChannel
+public class L2CommandChannel extends AbstractPlayerGroup
 {
 	private final List<L2Party> _partys;
 	private L2PcInstance _commandLeader = null;
@@ -40,18 +40,17 @@ public class L2CommandChannel
 	
 	/**
 	 * Creates a New Command Channel and Add the Leaders party to the CC
-	 *
 	 * @param leader
 	 */
 	public L2CommandChannel(L2PcInstance leader)
 	{
 		_commandLeader = leader;
-		_partys = new FastList<L2Party>();
+		_partys = new FastList<L2Party>().shared();
 		_partys.add(leader.getParty());
 		_channelLvl = leader.getParty().getLevel();
 		leader.getParty().setCommandChannel(this);
-		leader.getParty().broadcastToPartyMembers(SystemMessage.getSystemMessage(SystemMessageId.COMMAND_CHANNEL_FORMED));
-		leader.getParty().broadcastToPartyMembers(new ExOpenMPCC());
+		leader.getParty().broadcastMessage(SystemMessageId.COMMAND_CHANNEL_FORMED);
+		leader.getParty().broadcastPacket(new ExOpenMPCC());
 	}
 	
 	/**
@@ -61,16 +60,20 @@ public class L2CommandChannel
 	public void addParty(L2Party party)
 	{
 		if (party == null)
+		{
 			return;
+		}
 		// Update the CCinfo for existing players
-		this.broadcastToChannelMembers(new ExMPCCPartyInfoUpdate(party, 1));
+		broadcastPacket(new ExMPCCPartyInfoUpdate(party, 1));
 		
 		_partys.add(party);
 		if (party.getLevel() > _channelLvl)
+		{
 			_channelLvl = party.getLevel();
+		}
 		party.setCommandChannel(this);
-		party.broadcastToPartyMembers(SystemMessage.getSystemMessage(SystemMessageId.JOINED_COMMAND_CHANNEL));
-		party.broadcastToPartyMembers(new ExOpenMPCC());
+		party.broadcastPacket(SystemMessage.getSystemMessage(SystemMessageId.JOINED_COMMAND_CHANNEL));
+		party.broadcastPacket(new ExOpenMPCC());
 	}
 	
 	/**
@@ -80,26 +83,30 @@ public class L2CommandChannel
 	public void removeParty(L2Party party)
 	{
 		if (party == null)
+		{
 			return;
+		}
 		
 		_partys.remove(party);
 		_channelLvl = 0;
 		for (L2Party pty : _partys)
 		{
 			if (pty.getLevel() > _channelLvl)
+			{
 				_channelLvl = pty.getLevel();
+			}
 		}
 		party.setCommandChannel(null);
-		party.broadcastToPartyMembers(new ExCloseMPCC());
-		if(_partys.size() < 2)
+		party.broadcastPacket(new ExCloseMPCC());
+		if (_partys.size() < 2)
 		{
-			broadcastToChannelMembers(SystemMessage.getSystemMessage(SystemMessageId.COMMAND_CHANNEL_DISBANDED));
+			broadcastPacket(SystemMessage.getSystemMessage(SystemMessageId.COMMAND_CHANNEL_DISBANDED));
 			disbandChannel();
 		}
 		else
 		{
 			// Update the CCinfo for existing players
-			this.broadcastToChannelMembers(new ExMPCCPartyInfoUpdate(party, 0));
+			broadcastPacket(new ExMPCCPartyInfoUpdate(party, 0));
 		}
 	}
 	
@@ -112,8 +119,10 @@ public class L2CommandChannel
 		{
 			for (L2Party party : _partys)
 			{
-				if(party != null)
+				if (party != null)
+				{
 					removeParty(party);
+				}
 			}
 			_partys.clear();
 		}
@@ -122,13 +131,16 @@ public class L2CommandChannel
 	/**
 	 * @return overall member count of the Command Channel
 	 */
+	@Override
 	public int getMemberCount()
 	{
 		int count = 0;
 		for (L2Party party : _partys)
 		{
-			if(party != null)
+			if (party != null)
+			{
 				count += party.getMemberCount();
+			}
 		}
 		return count;
 	}
@@ -136,32 +148,21 @@ public class L2CommandChannel
 	/**
 	 * Broadcast packet to every channel member
 	 * @param gsp
+	 * @deprecated
+	 * @see L2CommandChannel#broadcastPacket(L2GameServerPacket)
 	 */
+	@Deprecated
 	public void broadcastToChannelMembers(L2GameServerPacket gsp)
 	{
-		if (_partys != null && !_partys.isEmpty())
-		{
-			for (L2Party party : _partys)
-			{
-				if(party != null)
-					party.broadcastToPartyMembers(gsp);
-			}
-		}
+		broadcastPacket(gsp);
 	}
 	
+	@Deprecated
 	public void broadcastCSToChannelMembers(CreatureSay gsp, L2PcInstance broadcaster)
 	{
-		if (_partys != null && !_partys.isEmpty())
-		{
-			for (L2Party party : _partys)
-			{
-				if(party != null)
-					party.broadcastCSToPartyMembers(gsp, broadcaster);
-			}
-		}
+		broadcastCreatureSay(gsp, broadcaster);
 	}
 	
-	
 	/**
 	 * @return list of Parties in Command Channel
 	 */
@@ -173,21 +174,25 @@ public class L2CommandChannel
 	/**
 	 * @return list of all Members in Command Channel
 	 */
+	@Override
 	public List<L2PcInstance> getMembers()
 	{
-		List<L2PcInstance> members = new FastList<L2PcInstance>();
+		List<L2PcInstance> members = new FastList<L2PcInstance>().shared();
 		for (L2Party party : getPartys())
 		{
-			members.addAll(party.getPartyMembers());
+			members.addAll(party.getMembers());
 		}
 		return members;
 	}
 	
 	/**
-	 *
 	 * @return Level of CC
 	 */
-	public int getLevel() { return _channelLvl; }
+	@Override
+	public int getLevel()
+	{
+		return _channelLvl;
+	}
 	
 	/**
 	 * @param leader the leader of the Command Channel
@@ -199,22 +204,70 @@ public class L2CommandChannel
 	
 	/**
 	 * @return the leader of the Command Channel
+	 * @deprecated
+	 * @see L2CommandChannel#getLeader()
 	 */
+	@Deprecated
 	public L2PcInstance getChannelLeader()
 	{
-		return _commandLeader;
+		return getLeader();
 	}
 	
 	/**
-	 *
-	 *
 	 * @param obj
 	 * @return true if proper condition for RaidWar
 	 */
 	public boolean meetRaidWarCondition(L2Object obj)
 	{
-		if (!(obj instanceof L2Character && ((L2Character)obj).isRaid()))
+		if (!((obj instanceof L2Character) && ((L2Character) obj).isRaid()))
+		{
 			return false;
+		}
 		return (getMemberCount() >= Config.LOOT_RAIDS_PRIVILEGE_CC_SIZE);
 	}
+	
+	/**
+	 * @return the leader of the Command Channel
+	 */
+	@Override
+	public L2PcInstance getLeader()
+	{
+		return _commandLeader;
+	}
+	
+	@Override
+	public boolean containsPlayer(L2PcInstance player)
+	{
+		if ((_partys != null) && !_partys.isEmpty())
+		{
+			for (L2Party party : _partys)
+			{
+				if (party.containsPlayer(player))
+				{
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+	
+	/**
+	 * Iterates over CC without need to allocate any new list
+	 * @see com.l2jserver.gameserver.model.AbstractPlayerGroup#forEachMember(IL2Procedure)
+	 */
+	@Override
+	public boolean forEachMember(IL2Procedure<L2PcInstance> procedure)
+	{
+		if ((_partys != null) && !_partys.isEmpty())
+		{
+			for (L2Party party : _partys)
+			{
+				if (!party.forEachMember(procedure))
+				{
+					return false;
+				}
+			}
+		}
+		return true;
+	}
 }

L2J_Server_BETA/java/com/l2jserver/gameserver/model/L2Object.java

@@ -40,19 +40,18 @@ import com.l2jserver.gameserver.network.serverpackets.ExSendUIEvent;
 import com.l2jserver.gameserver.network.serverpackets.L2GameServerPacket;
 
 /**
- * Mother class of all objects in the world which ones is it possible
- * to interact (PC, NPC, Item...)<BR><BR>
- *
- * L2Object :<BR><BR>
- * <li>L2Character</li>
- * <li>L2ItemInstance</li>
+ * Mother class of all objects in the world which ones is it possible to interact (PC, NPC, Item...)<BR>
+ * <BR>
+ * L2Object :<BR>
+ * <BR>
+ * <li>L2Character</li> <li>L2ItemInstance</li>
  */
 public abstract class L2Object
 {
-	private boolean _isVisible;                 // Object visibility
+	private boolean _isVisible; // Object visibility
 	private ObjectKnownList _knownList;
 	private String _name;
-	private int _objectId;                      // Object identifier
+	private int _objectId; // Object identifier
 	private ObjectPoly _poly;
 	private ObjectPosition _position;
 	private int _instanceId = 0;
@@ -296,12 +295,12 @@ public abstract class L2Object
 	}
 	
 	/**
-	 * Do Nothing.<BR><BR>
-	 *
-	 * <B><U> Overridden in </U> :</B><BR><BR>
-	 * <li> L2GuardInstance :  Set the home location of its L2GuardInstance </li>
-	 * <li> L2Attackable    :  Reset the Spoiled flag </li><BR><BR>
-	 *
+	 * Do Nothing.<BR>
+	 * <BR>
+	 * <B><U> Overridden in </U> :</B><BR>
+	 * <BR>
+	 * <li>L2GuardInstance : Set the home location of its L2GuardInstance</li> <li>L2Attackable : Reset the Spoiled flag</li><BR>
+	 * <BR>
 	 */
 	public void onSpawn()
 	{
@@ -325,8 +324,7 @@ public abstract class L2Object
 	}
 	
 	/**
-	 * @return The id of the instance zone the object is in - id 0 is global
-	 * since everything like dropped items, mobs, players can be in a instanciated area, it must be in l2object
+	 * @return The id of the instance zone the object is in - id 0 is global since everything like dropped items, mobs, players can be in a instanciated area, it must be in l2object
 	 */
 	public int getInstanceId()
 	{
@@ -376,15 +374,15 @@ public abstract class L2Object
 				}
 			}
 			
-			if (((L2PcInstance)this).getPet() != null)
-				((L2PcInstance)this).getPet().setInstanceId(instanceId);
+			if (((L2PcInstance) this).getPet() != null)
+				((L2PcInstance) this).getPet().setInstanceId(instanceId);
 		}
 		else if (this instanceof L2Npc)
 		{
 			if (_instanceId > 0 && oldI != null)
-				oldI.removeNpc(((L2Npc)this));
+				oldI.removeNpc(((L2Npc) this));
 			if (instanceId > 0)
-				newI.addNpc(((L2Npc)this));
+				newI.addNpc(((L2Npc) this));
 		}
 		
 		_instanceId = instanceId;
@@ -420,20 +418,23 @@ public abstract class L2Object
 	}
 	
 	/**
-	 * Remove a L2Object from the world.<BR><BR>
-	 *
-	 * <B><U> Actions</U> :</B><BR><BR>
-	 * <li>Remove the L2Object from the world</li><BR><BR>
-	 *
+	 * Remove a L2Object from the world.<BR>
+	 * <BR>
+	 * <B><U> Actions</U> :</B><BR>
+	 * <BR>
+	 * <li>Remove the L2Object from the world</li><BR>
+	 * <BR>
 	 * <FONT COLOR=#FF0000><B> <U>Caution</U> : This method DOESN'T REMOVE the object from _allObjects of L2World </B></FONT><BR>
-	 * <FONT COLOR=#FF0000><B> <U>Caution</U> : This method DOESN'T SEND Server->Client packets to players</B></FONT><BR><BR>
-	 *
-	 * <B><U> Assert </U> :</B><BR><BR>
-	 * <li> _worldRegion != null <I>(L2Object is visible at the beginning)</I></li><BR><BR>
-	 *
-	 * <B><U> Example of use </U> :</B><BR><BR>
-	 * <li> Delete NPC/PC or Unsummon</li><BR><BR>
-	 *
+	 * <FONT COLOR=#FF0000><B> <U>Caution</U> : This method DOESN'T SEND Server->Client packets to players</B></FONT><BR>
+	 * <BR>
+	 * <B><U> Assert </U> :</B><BR>
+	 * <BR>
+	 * <li>_worldRegion != null <I>(L2Object is visible at the beginning)</I></li><BR>
+	 * <BR>
+	 * <B><U> Example of use </U> :</B><BR>
+	 * <BR>
+	 * <li>Delete NPC/PC or Unsummon</li><BR>
+	 * <BR>
 	 */
 	public void decayMe()
 	{
@@ -462,21 +463,19 @@ public abstract class L2Object
 	}
 	
 	/**
-	 * Init the position of a L2Object spawn and add it in the world as a visible object.<BR><BR>
-	 *
-	 * <B><U> Actions</U> :</B><BR><BR>
-	 * <li>Set the x,y,z position of the L2Object spawn and update its _worldregion </li>
-	 * <li>Add the L2Object spawn in the _allobjects of L2World </li>
-	 * <li>Add the L2Object spawn to _visibleObjects of its L2WorldRegion</li>
-	 * <li>Add the L2Object spawn in the world as a <B>visible</B> object</li><BR><BR>
-	 *
-	 * <B><U> Assert </U> :</B><BR><BR>
-	 * <li> _worldRegion == null <I>(L2Object is invisible at the beginning)</I></li><BR><BR>
-	 *
-	 * <B><U> Example of use </U> :</B><BR><BR>
-	 * <li> Create Door</li>
-	 * <li> Spawn : Monster, Minion, CTs, Summon...</li><BR>
-	 *
+	 * Init the position of a L2Object spawn and add it in the world as a visible object.<BR>
+	 * <BR>
+	 * <B><U> Actions</U> :</B><BR>
+	 * <BR>
+	 * <li>Set the x,y,z position of the L2Object spawn and update its _worldregion</li> <li>Add the L2Object spawn in the _allobjects of L2World</li> <li>Add the L2Object spawn to _visibleObjects of its L2WorldRegion</li> <li>Add the L2Object spawn in the world as a <B>visible</B> object</li><BR>
+	 * <BR>
+	 * <B><U> Assert </U> :</B><BR>
+	 * <BR>
+	 * <li>_worldRegion == null <I>(L2Object is invisible at the beginning)</I></li><BR>
+	 * <BR>
+	 * <B><U> Example of use </U> :</B><BR>
+	 * <BR>
+	 * <li>Create Door</li> <li>Spawn : Monster, Minion, CTs, Summon...</li><BR>
 	 */
 	public final void spawnMe()
 	{
@@ -512,12 +511,16 @@ public abstract class L2Object
 			// Set the x,y,z position of the L2Object spawn and update its _worldregion
 			_isVisible = true;
 			
-			if (x > L2World.MAP_MAX_X) x = L2World.MAP_MAX_X - 5000;
-			if (x < L2World.MAP_MIN_X) x = L2World.MAP_MIN_X + 5000;
-			if (y > L2World.MAP_MAX_Y) y = L2World.MAP_MAX_Y - 5000;
-			if (y < L2World.MAP_MIN_Y) y = L2World.MAP_MIN_Y + 5000;
+			if (x > L2World.MAP_MAX_X)
+				x = L2World.MAP_MAX_X - 5000;
+			if (x < L2World.MAP_MIN_X)
+				x = L2World.MAP_MIN_X + 5000;
+			if (y > L2World.MAP_MAX_Y)
+				y = L2World.MAP_MAX_Y - 5000;
+			if (y < L2World.MAP_MIN_Y)
+				y = L2World.MAP_MIN_Y + 5000;
 			
-			getPosition().setWorldPosition(x, y ,z);
+			getPosition().setWorldPosition(x, y, z);
 			getPosition().setWorldRegion(L2World.getInstance().getRegion(getPosition().getWorldPosition()));
 			
 			// Add the L2Object spawn in the _allobjects of L2World
@@ -558,19 +561,22 @@ public abstract class L2Object
 	}
 	
 	/**
-	 * Return the visibility state of the L2Object.
-	 * <B><U> Concept</U> :</B><BR><BR>
-	 * A L2Object is visible if <B>__IsVisible</B>=true and <B>_worldregion</B>!=null <BR><BR>
-	 * @return 
+	 * Return the visibility state of the L2Object. <B><U> Concept</U> :</B><BR>
+	 * <BR>
+	 * A L2Object is visible if <B>__IsVisible</B>=true and <B>_worldregion</B>!=null <BR>
+	 * <BR>
+	 * @return
 	 */
 	public final boolean isVisible()
 	{
 		return getPosition().getWorldRegion() != null;
 	}
+	
 	public final void setIsVisible(boolean value)
 	{
 		_isVisible = value;
-		if (!_isVisible) getPosition().setWorldRegion(null);
+		if (!_isVisible)
+			getPosition().setWorldRegion(null);
 	}
 	
 	public ObjectKnownList getKnownList()
@@ -579,10 +585,7 @@ public abstract class L2Object
 	}
 	
 	/**
-	 * Initializes the KnownList of the L2Object,
-	 * is overwritten in classes that require a different knownlist Type.
-	 * 
-	 * Removes the need for instanceof checks.
+	 * Initializes the KnownList of the L2Object, is overwritten in classes that require a different knownlist Type. Removes the need for instanceof checks.
 	 */
 	public void initKnownList()
 	{
@@ -622,10 +625,7 @@ public abstract class L2Object
 	}
 	
 	/**
-	 * Initializes the Position class of the L2Object,
-	 * is overwritten in classes that require a different position Type.
-	 * 
-	 * Removes the need for instanceof checks.
+	 * Initializes the Position class of the L2Object, is overwritten in classes that require a different position Type. Removes the need for instanceof checks.
 	 */
 	public void initPosition()
 	{
@@ -651,19 +651,10 @@ public abstract class L2Object
 	}
 	
 	/**
-	 * Sends the Server->Client info packet for the object.<br><br>
-	 * Is Overridden in:
-	 * <li>L2AirShipInstance</li>
-	 * <li>L2BoatInstance</li>
-	 * <li>L2DoorInstance</li>
-	 * <li>L2PcInstance</li>
-	 * <li>L2StaticObjectInstance</li>
-	 * <li>L2Decoy</li>
-	 * <li>L2Npc</li>
-	 * <li>L2Summon</li>
-	 * <li>L2Trap</li>
-	 * <li>L2ItemInstance</li>
-	 * @param activeChar 
+	 * Sends the Server->Client info packet for the object.<br>
+	 * <br>
+	 * Is Overridden in: <li>L2AirShipInstance</li> <li>L2BoatInstance</li> <li>L2DoorInstance</li> <li>L2PcInstance</li> <li>L2StaticObjectInstance</li> <li>L2Decoy</li> <li>L2Npc</li> <li>L2Summon</li> <li>L2Trap</li> <li>L2ItemInstance</li>
+	 * @param activeChar
 	 */
 	public void sendInfo(L2PcInstance activeChar)
 	{
@@ -673,33 +664,37 @@ public abstract class L2Object
 	@Override
 	public String toString()
 	{
-		return (getClass().getSimpleName() + ":"+getName()+"[" + getObjectId() + "]");
+		return (getClass().getSimpleName() + ":" + getName() + "[" + getObjectId() + "]");
 	}
 	
 	/**
-	 * Not Implemented.<BR><BR>
-	 *
-	 * <B><U> Overridden in </U> :</B><BR><BR>
-	 * <li> L2PcInstance</li><BR><BR>
-	 * @param mov 
+	 * Not Implemented.<BR>
+	 * <BR>
+	 * <B><U> Overridden in </U> :</B><BR>
+	 * <BR>
+	 * <li>L2PcInstance</li><BR>
+	 * <BR>
+	 * @param mov
 	 */
 	public void sendPacket(L2GameServerPacket mov)
 	{
 		// default implementation
 	}
-
+	
 	/**
-	 * Not Implemented.<BR><BR>
-	 *
-	 * <B><U> Overridden in </U> :</B><BR><BR>
-	 * <li> L2PcInstance</li><BR><BR>
-	 * @param id 
+	 * Not Implemented.<BR>
+	 * <BR>
+	 * <B><U> Overridden in </U> :</B><BR>
+	 * <BR>
+	 * <li>L2PcInstance</li><BR>
+	 * <BR>
+	 * @param id
 	 */
 	public void sendPacket(SystemMessageId id)
 	{
 		// default implementation
 	}
-
+	
 	/**
 	 * @return {@code true} if object is instance of {@link L2PcInstance}
 	 */
@@ -723,7 +718,7 @@ public abstract class L2Object
 	{
 		return false;
 	}
-
+	
 	/**
 	 * @return {@code true} if object is instance of {@link L2PetInstance}
 	 */
@@ -779,4 +774,20 @@ public abstract class L2Object
 	{
 		return false;
 	}
+	
+	@Override
+	public boolean equals(Object obj)
+	{
+		if (obj instanceof L2Object)
+		{
+			return _objectId == ((L2Object) obj)._objectId;
+		}
+		return false;
+	}
+	
+	@Override
+	public int hashCode()
+	{
+		return _objectId;
+	}
 }

L2J_Server_BETA/java/com/l2jserver/gameserver/model/L2Party.java

@@ -61,16 +61,21 @@ import com.l2jserver.util.Rnd;
 
 /**
  * This class ...
- *
  * @author nuocnam
  * @version $Revision: 1.6.2.2.2.6 $ $Date: 2005/04/11 19:12:16 $
  */
-public class L2Party
+public class L2Party extends AbstractPlayerGroup
 {
 	private static final Logger _log = Logger.getLogger(L2Party.class.getName());
-	private static final double[] BONUS_EXP_SP = { 1, 1.10, 1.20, 1.30, 1.40, 1.50, 2.0, 2.10, 2.20 };
-	//TODO: JIV - unhardcode to some SysString enum (sysstring-e.dat)
-	private static final int[] LOOT_SYSSTRINGS = { 487, 488, 798, 799, 800 };
+	private static final double[] BONUS_EXP_SP =
+	{
+		1, 1.10, 1.20, 1.30, 1.40, 1.50, 2.0, 2.10, 2.20
+	};
+	// TODO: JIV - unhardcode to some SysString enum (sysstring-e.dat)
+	private static final int[] LOOT_SYSSTRINGS =
+	{
+		487, 488, 798, 799, 800
+	};
 	private static final int PARTY_POSITION_BROADCAST = 12000;
 	
 	public static final byte ITEM_LOOTER = 0;
@@ -113,33 +118,29 @@ public class L2Party
 	 */
 	public L2Party(L2PcInstance leader, int itemDistribution)
 	{
-		_members = new FastList<L2PcInstance>();
+		_members = new FastList<L2PcInstance>().shared();
 		_itemDistribution = itemDistribution;
-		getPartyMembers().add(leader);
+		getMembers().add(leader);
 		_partyLvl = leader.getLevel();
 	}
 	
-	/**
-	 * returns number of party members
-	 * @return
-	 */
-	public int getMemberCount() { return getPartyMembers().size(); }
-	
 	/**
 	 * Check if another player can start invitation process
 	 * @return boolean if party waits for invitation respond
 	 */
-	public boolean getPendingInvitation() { return _pendingInvitation; }
+	public boolean getPendingInvitation()
+	{
+		return _pendingInvitation;
+	}
 	
 	/**
-	 * set invitation process flag and store time for expiration
-	 * happens when: player join party or player decline to join
-	 * @param val 
+	 * set invitation process flag and store time for expiration happens when: player join party or player decline to join
+	 * @param val
 	 */
 	public void setPendingInvitation(boolean val)
 	{
 		_pendingInvitation = val;
-		_pendingInviteTimeout = GameTimeController.getGameTicks() + L2PcInstance.REQUEST_TIMEOUT * GameTimeController.TICKS_PER_SECOND;
+		_pendingInviteTimeout = GameTimeController.getGameTicks() + (L2PcInstance.REQUEST_TIMEOUT * GameTimeController.TICKS_PER_SECOND);
 	}
 	
 	/**
@@ -155,49 +156,59 @@ public class L2Party
 	/**
 	 * returns all party members
 	 * @return
+	 * @deprecated
 	 */
+	@Deprecated
 	public final FastList<L2PcInstance> getPartyMembers()
 	{
-		return _members;
+		return (FastList<L2PcInstance>) getMembers();
 	}
 	
 	/**
 	 * get random member from party
-	 * @param ItemId 
-	 * @param target 
+	 * @param ItemId
+	 * @param target
 	 * @return
 	 */
 	private L2PcInstance getCheckedRandomMember(int ItemId, L2Character target)
 	{
 		List<L2PcInstance> availableMembers = new FastList<L2PcInstance>();
-		for (L2PcInstance member : getPartyMembers())
+		for (L2PcInstance member : getMembers())
 		{
-			if (member.getInventory().validateCapacityByItemId(ItemId) &&
-					Util.checkIfInRange(Config.ALT_PARTY_RANGE2, target, member, true)) availableMembers.add(member);
+			if (member.getInventory().validateCapacityByItemId(ItemId) && Util.checkIfInRange(Config.ALT_PARTY_RANGE2, target, member, true))
+			{
+				availableMembers.add(member);
+			}
 		}
 		if (!availableMembers.isEmpty())
+		{
 			return availableMembers.get(Rnd.get(availableMembers.size()));
+		}
 		return null;
 	}
 	
 	/**
 	 * get next item looter
-	 * @param ItemId 
-	 * @param target 
+	 * @param ItemId
+	 * @param target
 	 * @return
 	 */
 	private L2PcInstance getCheckedNextLooter(int ItemId, L2Character target)
 	{
 		for (int i = 0; i < getMemberCount(); i++)
 		{
-			if (++_itemLastLoot >= getMemberCount()) _itemLastLoot = 0;
+			if (++_itemLastLoot >= getMemberCount())
+			{
+				_itemLastLoot = 0;
+			}
 			L2PcInstance member;
 			try
 			{
-				member = getPartyMembers().get(_itemLastLoot);
-				if (member.getInventory().validateCapacityByItemId(ItemId) &&
-						Util.checkIfInRange(Config.ALT_PARTY_RANGE2, target, member, true))
+				member = getMembers().get(_itemLastLoot);
+				if (member.getInventory().validateCapacityByItemId(ItemId) && Util.checkIfInRange(Config.ALT_PARTY_RANGE2, target, member, true))
+				{
 					return member;
+				}
 			}
 			catch (Exception e)
 			{
@@ -210,10 +221,10 @@ public class L2Party
 	
 	/**
 	 * get next item looter
-	 * @param player 
-	 * @param ItemId 
-	 * @param spoil 
-	 * @param target 
+	 * @param player
+	 * @param ItemId
+	 * @param spoil
+	 * @param target
 	 * @return
 	 */
 	private L2PcInstance getActualLooter(L2PcInstance player, int ItemId, boolean spoil, L2Character target)
@@ -223,25 +234,33 @@ public class L2Party
 		switch (_itemDistribution)
 		{
 			case ITEM_RANDOM:
-				if (!spoil) looter = getCheckedRandomMember(ItemId, target);
+				if (!spoil)
+				{
+					looter = getCheckedRandomMember(ItemId, target);
+				}
 				break;
 			case ITEM_RANDOM_SPOIL:
 				looter = getCheckedRandomMember(ItemId, target);
 				break;
 			case ITEM_ORDER:
-				if (!spoil) looter = getCheckedNextLooter(ItemId, target);
+				if (!spoil)
+				{
+					looter = getCheckedNextLooter(ItemId, target);
+				}
 				break;
 			case ITEM_ORDER_SPOIL:
 				looter = getCheckedNextLooter(ItemId, target);
 				break;
 		}
 		
-		if (looter == null) looter = player;
+		if (looter == null)
+		{
+			looter = player;
+		}
 		return looter;
 	}
 	
 	/**
-	 * 
 	 * @param player the player to check.
 	 * @return {code true} if player is party leader.
 	 */
@@ -252,25 +271,22 @@ public class L2Party
 	
 	/**
 	 * @return the Object ID for the party leader to be used as a unique identifier of this party-
+	 * @deprecated use {@link #getLeaderObjectId()}
 	 */
+	@Deprecated
 	public int getPartyLeaderOID()
 	{
-		return getLeader().getObjectId();
+		return getLeaderObjectId();
 	}
 	
 	/**
 	 * Broadcasts packet to all party member.
 	 * @param packet the packet to be broadcasted.
 	 */
+	@Deprecated
 	public void broadcastToPartyMembers(L2GameServerPacket packet)
 	{
-		for (L2PcInstance member : getPartyMembers())
-		{
-			if (member != null)
-			{
-				member.sendPacket(packet);
-			}
-		}
+		broadcastPacket(packet);
 	}
 	
 	/**
@@ -278,7 +294,7 @@ public class L2Party
 	 */
 	public void broadcastToPartyMembersNewLeader()
 	{
-		for (L2PcInstance member : getPartyMembers())
+		for (L2PcInstance member : getMembers())
 		{
 			if (member != null)
 			{
@@ -289,27 +305,26 @@ public class L2Party
 		}
 	}
 	
+	@Deprecated
 	public void broadcastCSToPartyMembers(CreatureSay msg, L2PcInstance broadcaster)
 	{
-		for (L2PcInstance member : getPartyMembers())
-		{
-			if (member != null && !BlockList.isBlocked(member, broadcaster))
-				member.sendPacket(msg);
-		}
+		broadcastCreatureSay(msg, broadcaster);
 	}
 	
-	
 	/**
-	 * Send a Server->Client packet to all other L2PcInstance of the Party.<BR><BR>
-	 * @param player 
-	 * @param msg 
+	 * Send a Server->Client packet to all other L2PcInstance of the Party.<BR>
+	 * <BR>
+	 * @param player
+	 * @param msg
 	 */
 	public void broadcastToPartyMembers(L2PcInstance player, L2GameServerPacket msg)
 	{
-		for(L2PcInstance member : getPartyMembers())
+		for (L2PcInstance member : getMembers())
 		{
-			if (member != null && !member.equals(player))
+			if ((member != null) && !member.equals(player))
+			{
 				member.sendPacket(msg);
+			}
 		}
 	}
 	
@@ -317,22 +332,26 @@ public class L2Party
 	 * adds new member to party
 	 * @param player
 	 */
-	public synchronized void addPartyMember(L2PcInstance player)
+	public void addPartyMember(L2PcInstance player)
 	{
-		if (getPartyMembers().contains(player))
+		if (getMembers().contains(player))
+		{
 			return;
+		}
 		
 		if (_requestChangeLoot != -1)
+		{
 			finishLootRequest(false); // cancel on invite
-		//sends new member party window for all members
-		//we do all actions before adding member to a list, this speeds things up a little
+		}
+		// sends new member party window for all members
+		// we do all actions before adding member to a list, this speeds things up a little
 		player.sendPacket(new PartySmallWindowAll(player, this));
 		
 		// sends pets/summons of party members
 		L2Summon summon;
-		for (L2PcInstance pMember : getPartyMembers())
+		for (L2PcInstance pMember : getMembers())
 		{
-			if (pMember != null && (summon = pMember.getPet()) != null)
+			if ((pMember != null) && ((summon = pMember.getPet()) != null))
 			{
 				player.sendPacket(new ExPartyPetWindowAdd(summon));
 			}
@@ -344,28 +363,28 @@ public class L2Party
 		
 		msg = SystemMessage.getSystemMessage(SystemMessageId.C1_JOINED_PARTY);
 		msg.addString(player.getName());
-		broadcastToPartyMembers(msg);
-		broadcastToPartyMembers(new PartySmallWindowAdd(player, this));
+		broadcastPacket(msg);
+		broadcastPacket(new PartySmallWindowAdd(player, this));
 		// send the position of all party members to the new party member
-		//player.sendPacket(new PartyMemberPosition(this));
+		// player.sendPacket(new PartyMemberPosition(this));
 		// send the position of the new party member to all party members (except the new one - he knows his own position)
-		//broadcastToPartyMembers(player, new PartyMemberPosition(this));
+		// broadcastToPartyMembers(player, new PartyMemberPosition(this));
 		
 		// if member has pet/summon add it to other as well
 		if (player.getPet() != null)
 		{
-			broadcastToPartyMembers(new ExPartyPetWindowAdd(player.getPet()));
+			broadcastPacket(new ExPartyPetWindowAdd(player.getPet()));
 		}
 		
-		//add player to party, adjust party level
-		getPartyMembers().add(player);
+		// add player to party, adjust party level
+		getMembers().add(player);
 		if (player.getLevel() > _partyLvl)
 		{
 			_partyLvl = player.getLevel();
 		}
 		
 		// update partySpelled
-		for(L2PcInstance member : getPartyMembers())
+		for (L2PcInstance member : getMembers())
 		{
 			if (member != null)
 			{
@@ -391,7 +410,9 @@ public class L2Party
 		}
 		
 		if (_positionBroadcastTask == null)
-			_positionBroadcastTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new PositionBroadcast(), PARTY_POSITION_BROADCAST/2, PARTY_POSITION_BROADCAST);
+		{
+			_positionBroadcastTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new PositionBroadcast(), PARTY_POSITION_BROADCAST / 2, PARTY_POSITION_BROADCAST);
+		}
 	}
 	
 	/**
@@ -399,7 +420,7 @@ public class L2Party
 	 * @param name player the player to be removed from the party.
 	 * @param type the message type {@link messageType}.
 	 */
-	public synchronized void removePartyMember(String name, messageType type)
+	public void removePartyMember(String name, messageType type)
 	{
 		removePartyMember(getPlayerByName(name), type);
 	}
@@ -409,21 +430,21 @@ public class L2Party
 	 * @param player the player to be removed from the party.
 	 * @param type the message type {@link messageType}.
 	 */
-	public synchronized void removePartyMember(L2PcInstance player, messageType type)
+	public void removePartyMember(L2PcInstance player, messageType type)
 	{
-		if (getPartyMembers().contains(player))
+		if (getMembers().contains(player))
 		{
 			final boolean isLeader = isLeader(player);
 			if (!_disbanding)
 			{
-				if ((getPartyMembers().size() == 2) || isLeader && !Config.ALT_LEAVE_PARTY_LEADER && (type != messageType.Disconnected))
+				if ((getMembers().size() == 2) || (isLeader && !Config.ALT_LEAVE_PARTY_LEADER && (type != messageType.Disconnected)))
 				{
 					disbandParty();
 					return;
 				}
 			}
 			
-			getPartyMembers().remove(player);
+			getMembers().remove(player);
 			recalculatePartyLevel();
 			
 			if (player.isFestivalParticipant())
@@ -431,7 +452,7 @@ public class L2Party
 				SevenSignsFestival.getInstance().updateParticipants(player, this);
 			}
 			
-			if(player.isInDuel())
+			if (player.isInDuel())
 			{
 				DuelManager.getInstance().onRemoveFromParty(player);
 			}
@@ -462,24 +483,24 @@ public class L2Party
 				player.sendPacket(SystemMessageId.HAVE_BEEN_EXPELLED_FROM_PARTY);
 				msg = SystemMessage.getSystemMessage(SystemMessageId.C1_WAS_EXPELLED_FROM_PARTY);
 				msg.addString(player.getName());
-				broadcastToPartyMembers(msg);
+				broadcastPacket(msg);
 			}
 			else if ((type == messageType.Left) || (type == messageType.Disconnected))
 			{
 				player.sendPacket(SystemMessageId.YOU_LEFT_PARTY);
 				msg = SystemMessage.getSystemMessage(SystemMessageId.C1_LEFT_PARTY);
 				msg.addString(player.getName());
-				broadcastToPartyMembers(msg);
+				broadcastPacket(msg);
 			}
 			
-			//UI update.
+			// UI update.
 			player.sendPacket(new PartySmallWindowDeleteAll());
 			player.setParty(null);
-			broadcastToPartyMembers(new PartySmallWindowDelete(player));
+			broadcastPacket(new PartySmallWindowDelete(player));
 			final L2Summon summon = player.getPet();
 			if (summon != null)
 			{
-				broadcastToPartyMembers(new ExPartyPetWindowDelete(summon));
+				broadcastPacket(new ExPartyPetWindowDelete(summon));
 			}
 			
 			if (isInDimensionalRift())
@@ -492,19 +513,19 @@ public class L2Party
 			{
 				player.sendPacket(new ExCloseMPCC());
 			}
-			if (isLeader && (getPartyMembers().size() > 1) && (Config.ALT_LEAVE_PARTY_LEADER || (type == messageType.Disconnected)))
+			if (isLeader && (getMembers().size() > 1) && (Config.ALT_LEAVE_PARTY_LEADER || (type == messageType.Disconnected)))
 			{
 				msg = SystemMessage.getSystemMessage(SystemMessageId.C1_HAS_BECOME_A_PARTY_LEADER);
 				msg.addString(getLeader().getName());
-				broadcastToPartyMembers(msg);
+				broadcastPacket(msg);
 				broadcastToPartyMembersNewLeader();
 			}
-			else if (getPartyMembers().size() == 1)
+			else if (getMembers().size() == 1)
 			{
 				if (isInCommandChannel())
 				{
 					// delete the whole command channel when the party who opened the channel is disbanded
-					if (getCommandChannel().getChannelLeader().equals(getLeader()))
+					if (getCommandChannel().getLeader().equals(getLeader()))
 					{
 						getCommandChannel().disbandChannel();
 					}
@@ -545,7 +566,7 @@ public class L2Party
 		_disbanding = true;
 		if (_members != null)
 		{
-			broadcastToPartyMembers(SystemMessage.getSystemMessage(SystemMessageId.PARTY_DISPERSED));
+			broadcastPacket(SystemMessage.getSystemMessage(SystemMessageId.PARTY_DISPERSED));
 			for (L2PcInstance member : _members)
 			{
 				if (member != null)
@@ -564,9 +585,9 @@ public class L2Party
 	{
 		L2PcInstance player = getPlayerByName(name);
 		
-		if (player != null && !player.isInDuel())
+		if ((player != null) && !player.isInDuel())
 		{
-			if (getPartyMembers().contains(player))
+			if (getMembers().contains(player))
 			{
 				if (isLeader(player))
 				{
@@ -574,26 +595,25 @@ public class L2Party
 				}
 				else
 				{
-					//Swap party members
+					// Swap party members
 					L2PcInstance temp;
-					int p1 = getPartyMembers().indexOf(player);
+					int p1 = getMembers().indexOf(player);
 					temp = getLeader();
-					getPartyMembers().set(0,getPartyMembers().get(p1));
-					getPartyMembers().set(p1,temp);
-					
+					getMembers().set(0, getMembers().get(p1));
+					getMembers().set(p1, temp);
 					
 					SystemMessage msg = SystemMessage.getSystemMessage(SystemMessageId.C1_HAS_BECOME_A_PARTY_LEADER);
 					msg.addString(getLeader().getName());
-					broadcastToPartyMembers(msg);
+					broadcastPacket(msg);
 					broadcastToPartyMembersNewLeader();
-					if (isInCommandChannel() && temp.equals(_commandChannel.getChannelLeader()))
+					if (isInCommandChannel() && temp.equals(_commandChannel.getLeader()))
 					{
 						_commandChannel.setChannelLeader(getLeader());
 						msg = SystemMessage.getSystemMessage(SystemMessageId.COMMAND_CHANNEL_LEADER_NOW_C1);
-						msg.addString(_commandChannel.getChannelLeader().getName());
-						_commandChannel.broadcastToChannelMembers(msg);
+						msg.addString(_commandChannel.getLeader().getName());
+						_commandChannel.broadcastPacket(msg);
 					}
-					if(player.isInPartyMatchRoom())
+					if (player.isInPartyMatchRoom())
 					{
 						PartyMatchRoom room = PartyMatchRoomList.getInstance().getPlayerRoom(player);
 						room.changeLeader(player);
@@ -615,10 +635,12 @@ public class L2Party
 	 */
 	private L2PcInstance getPlayerByName(String name)
 	{
-		for(L2PcInstance member : getPartyMembers())
+		for (L2PcInstance member : getMembers())
 		{
 			if (member.getName().equalsIgnoreCase(name))
+			{
 				return member;
+			}
 		}
 		return null;
 	}
@@ -662,12 +684,15 @@ public class L2Party
 	 * distribute item(s) to party members
 	 * @param player
 	 * @param item
-	 * @param spoil 
-	 * @param target 
+	 * @param spoil
+	 * @param target
 	 */
 	public void distributeItem(L2PcInstance player, L2Attackable.RewardItem item, boolean spoil, L2Attackable target)
 	{
-		if (item == null) return;
+		if (item == null)
+		{
+			return;
+		}
 		
 		if (item.getItemId() == PcInventory.ADENA_ID)
 		{
@@ -677,13 +702,12 @@ public class L2Party
 		
 		L2PcInstance looter = getActualLooter(player, item.getItemId(), spoil, target);
 		
-		looter.addItem(spoil?"Sweep":"Party", item.getItemId(), item.getCount(), player, true);
+		looter.addItem(spoil ? "Sweep" : "Party", item.getItemId(), item.getCount(), player, true);
 		
 		// Send messages to other aprty members about reward
 		if (item.getCount() > 1)
 		{
-			SystemMessage msg = spoil ?  SystemMessage.getSystemMessage(SystemMessageId.C1_SWEEPED_UP_S3_S2)
-			: SystemMessage.getSystemMessage(SystemMessageId.C1_OBTAINED_S3_S2);
+			SystemMessage msg = spoil ? SystemMessage.getSystemMessage(SystemMessageId.C1_SWEEPED_UP_S3_S2) : SystemMessage.getSystemMessage(SystemMessageId.C1_OBTAINED_S3_S2);
 			msg.addString(looter.getName());
 			msg.addItemName(item.getItemId());
 			msg.addItemNumber(item.getCount());
@@ -691,8 +715,7 @@ public class L2Party
 		}
 		else
 		{
-			SystemMessage msg = spoil ?  SystemMessage.getSystemMessage(SystemMessageId.C1_SWEEPED_UP_S2)
-			: SystemMessage.getSystemMessage(SystemMessageId.C1_OBTAINED_S2);
+			SystemMessage msg = spoil ? SystemMessage.getSystemMessage(SystemMessageId.C1_SWEEPED_UP_S2) : SystemMessage.getSystemMessage(SystemMessageId.C1_OBTAINED_S2);
 			msg.addString(looter.getName());
 			msg.addItemName(item.getItemId());
 			broadcastToPartyMembers(looter, msg);
@@ -701,26 +724,32 @@ public class L2Party
 	
 	/**
 	 * distribute adena to party members
-	 * @param player 
+	 * @param player
 	 * @param adena
-	 * @param target 
+	 * @param target
 	 */
 	public void distributeAdena(L2PcInstance player, long adena, L2Character target)
 	{
 		// Get all the party members
-		List<L2PcInstance> membersList = getPartyMembers();
+		List<L2PcInstance> membersList = getMembers();
 		
 		// Check the number of party members that must be rewarded
 		// (The party member must be in range to receive its reward)
 		List<L2PcInstance> ToReward = FastList.newInstance();
-		for(L2PcInstance member : membersList)
+		for (L2PcInstance member : membersList)
 		{
-			if (!Util.checkIfInRange(Config.ALT_PARTY_RANGE2, target, member, true)) continue;
+			if (!Util.checkIfInRange(Config.ALT_PARTY_RANGE2, target, member, true))
+			{
+				continue;
+			}
 			ToReward.add(member);
 		}
 		
 		// Avoid null exceptions, if any
-		if (ToReward.isEmpty()) return;
+		if (ToReward.isEmpty())
+		{
+			return;
+		}
 		
 		// Now we can actually distribute the adena reward
 		// (Total adena splitted by the number of party members that are in range and must be rewarded)
@@ -734,22 +763,21 @@ public class L2Party
 	}
 	
 	/**
-	 * Distribute Experience and SP rewards to L2PcInstance Party members in the known area of the last attacker.<BR><BR>
-	 *
-	 * <B><U> Actions</U> :</B><BR><BR>
-	 * <li>Get the L2PcInstance owner of the L2ServitorInstance (if necessary) </li>
-	 * <li>Calculate the Experience and SP reward distribution rate </li>
-	 * <li>Add Experience and SP to the L2PcInstance </li><BR><BR>
-	 *
-	 * <FONT COLOR=#FF0000><B> <U>Caution</U> : This method DOESN'T GIVE rewards to L2PetInstance</B></FONT><BR><BR>
+	 * Distribute Experience and SP rewards to L2PcInstance Party members in the known area of the last attacker.<BR>
+	 * <BR>
+	 * <B><U> Actions</U> :</B><BR>
+	 * <BR>
+	 * <li>Get the L2PcInstance owner of the L2ServitorInstance (if necessary)</li> <li>Calculate the Experience and SP reward distribution rate</li> <li>Add Experience and SP to the L2PcInstance</li><BR>
+	 * <BR>
+	 * <FONT COLOR=#FF0000><B> <U>Caution</U> : This method DOESN'T GIVE rewards to L2PetInstance</B></FONT><BR>
+	 * <BR>
 	 * Exception are L2PetInstances that leech from the owner's XP; they get the exp indirectly, via the owner's exp gain<BR>
-	 *
 	 * @param xpReward The Experience reward to distribute
 	 * @param spReward The SP reward to distribute
 	 * @param rewardedMembers The list of L2PcInstance to reward
-	 * @param topLvl 
-	 * @param partyDmg 
-	 * @param target 
+	 * @param topLvl
+	 * @param partyDmg
+	 * @param target
 	 */
 	public void distributeXpAndSp(long xpReward, int spReward, List<L2Playable> rewardedMembers, int topLvl, int partyDmg, L2Attackable target)
 	{
@@ -765,31 +793,38 @@ public class L2Party
 		
 		double sqLevelSum = 0;
 		for (L2Playable character : validMembers)
+		{
 			sqLevelSum += (character.getLevel() * character.getLevel());
+		}
 		
-		final float vitalityPoints = target.getVitalityPoints(partyDmg) * Config.RATE_PARTY_XP / validMembers.size();
+		final float vitalityPoints = (target.getVitalityPoints(partyDmg) * Config.RATE_PARTY_XP) / validMembers.size();
 		final boolean useVitalityRate = target.useVitalityRate();
 		
 		// Go through the L2PcInstances and L2PetInstances (not L2ServitorInstances) that must be rewarded
-		synchronized(rewardedMembers)
+		synchronized (rewardedMembers)
 		{
 			for (L2Character member : rewardedMembers)
 			{
-				if(member.isDead()) continue;
+				if (member.isDead())
+				{
+					continue;
+				}
 				
 				penalty = 0;
 				
 				// The L2ServitorInstance penalty
 				if (member.getPet() instanceof L2ServitorInstance)
 				{
-					summon     = (L2ServitorInstance)member.getPet();
-					penalty    = summon.getExpPenalty();
+					summon = (L2ServitorInstance) member.getPet();
+					penalty = summon.getExpPenalty();
 				}
 				// Pets that leech xp from the owner (like babypets) do not get rewarded directly
 				if (member instanceof L2PetInstance)
 				{
-					if (((L2PetInstance)member).getPetLevelData().getOwnerExpTaken() > 0)
+					if (((L2PetInstance) member).getPetLevelData().getOwnerExpTaken() > 0)
+					{
 						continue;
+					}
 					// TODO: This is a temporary fix while correct pet xp in party is figured out
 					penalty = (float) 0.85;
 				}
@@ -804,22 +839,28 @@ public class L2Party
 					if (!member.isDead())
 					{
 						long addexp = Math.round(member.calcStat(Stats.EXPSP_RATE, xpReward * preCalculation, null, null));
-						int addsp = (int)member.calcStat(Stats.EXPSP_RATE, spReward * preCalculation, null, null);
+						int addsp = (int) member.calcStat(Stats.EXPSP_RATE, spReward * preCalculation, null, null);
 						if (member instanceof L2PcInstance)
 						{
-							if (((L2PcInstance)member).getSkillLevel(467) > 0)
+							if (((L2PcInstance) member).getSkillLevel(467) > 0)
 							{
-								L2Skill skill = SkillTable.getInstance().getInfo(467,((L2PcInstance)member).getSkillLevel(467));
+								L2Skill skill = SkillTable.getInstance().getInfo(467, ((L2PcInstance) member).getSkillLevel(467));
 								
 								if (skill.getExpNeeded() <= addexp)
-									((L2PcInstance)member).absorbSoul(skill,target);
+								{
+									((L2PcInstance) member).absorbSoul(skill, target);
+								}
 							}
-							((L2PcInstance)member).addExpAndSp(addexp, addsp, useVitalityRate);
+							((L2PcInstance) member).addExpAndSp(addexp, addsp, useVitalityRate);
 							if (addexp > 0)
-								((L2PcInstance)member).updateVitalityPoints(vitalityPoints, true, false);
+							{
+								((L2PcInstance) member).updateVitalityPoints(vitalityPoints, true, false);
+							}
 						}
 						else
+						{
 							member.addExpAndSp(addexp, addsp);
+						}
 					}
 				}
 				else
@@ -832,21 +873,22 @@ public class L2Party
 	
 	/**
 	 * refresh party level
-	 *
 	 */
 	public void recalculatePartyLevel()
 	{
 		int newLevel = 0;
-		for (L2PcInstance member : getPartyMembers())
+		for (L2PcInstance member : getMembers())
 		{
 			if (member == null)
 			{
-				getPartyMembers().remove(member);
+				getMembers().remove(member);
 				continue;
 			}
 			
 			if (member.getLevel() > newLevel)
+			{
 				newLevel = member.getLevel();
+			}
 		}
 		_partyLvl = newLevel;
 	}
@@ -855,16 +897,18 @@ public class L2Party
 	{
 		List<L2Playable> validMembers = new FastList<L2Playable>();
 		
-		//		Fixed LevelDiff cutoff point
+		// Fixed LevelDiff cutoff point
 		if (Config.PARTY_XP_CUTOFF_METHOD.equalsIgnoreCase("level"))
 		{
 			for (L2Playable member : members)
 			{
-				if (topLvl - member.getLevel() <= Config.PARTY_XP_CUTOFF_LEVEL)
+				if ((topLvl - member.getLevel()) <= Config.PARTY_XP_CUTOFF_LEVEL)
+				{
 					validMembers.add(member);
+				}
 			}
 		}
-		//		Fixed MinPercentage cutoff point
+		// Fixed MinPercentage cutoff point
 		else if (Config.PARTY_XP_CUTOFF_METHOD.equalsIgnoreCase("percentage"))
 		{
 			int sqLevelSum = 0;
@@ -876,11 +920,13 @@ public class L2Party
 			for (L2Playable member : members)
 			{
 				int sqLevel = member.getLevel() * member.getLevel();
-				if (sqLevel * 100 >= sqLevelSum * Config.PARTY_XP_CUTOFF_PERCENT)
+				if ((sqLevel * 100) >= (sqLevelSum * Config.PARTY_XP_CUTOFF_PERCENT))
+				{
 					validMembers.add(member);
+				}
 			}
 		}
-		//		Automatic cutoff method
+		// Automatic cutoff method
 		else if (Config.PARTY_XP_CUTOFF_METHOD.equalsIgnoreCase("auto"))
 		{
 			int sqLevelSum = 0;
@@ -890,14 +936,22 @@ public class L2Party
 			}
 			
 			int i = members.size() - 1;
-			if (i < 1 ) return members;
-			if (i >= BONUS_EXP_SP.length) i = BONUS_EXP_SP.length -1;
+			if (i < 1)
+			{
+				return members;
+			}
+			if (i >= BONUS_EXP_SP.length)
+			{
+				i = BONUS_EXP_SP.length - 1;
+			}
 			
 			for (L2Playable member : members)
 			{
 				int sqLevel = member.getLevel() * member.getLevel();
-				if (sqLevel >= sqLevelSum * (1-1/(1 +BONUS_EXP_SP[i] -BONUS_EXP_SP[i-1])))
+				if (sqLevel >= (sqLevelSum / (members.size() * members.size())))
+				{
 					validMembers.add(member);
+				}
 			}
 		}
 		else if (Config.PARTY_XP_CUTOFF_METHOD.equalsIgnoreCase("none"))
@@ -909,18 +963,24 @@ public class L2Party
 	
 	private double getBaseExpSpBonus(int membersCount)
 	{
-		int i = membersCount -1;
-		if (i < 1 ) return 1;
-		if (i >= BONUS_EXP_SP.length) i = BONUS_EXP_SP.length -1;
+		int i = membersCount - 1;
+		if (i < 1)
+		{
+			return 1;
+		}
+		if (i >= BONUS_EXP_SP.length)
+		{
+			i = BONUS_EXP_SP.length - 1;
+		}
 		
 		return BONUS_EXP_SP[i];
 	}
 	
 	private double getExpBonus(int membersCount)
 	{
-		if(membersCount < 2)
+		if (membersCount < 2)
 		{
-			//not is a valid party
+			// not is a valid party
 			return getBaseExpSpBonus(membersCount);
 		}
 		return getBaseExpSpBonus(membersCount) * Config.RATE_PARTY_XP;
@@ -928,17 +988,24 @@ public class L2Party
 	
 	private double getSpBonus(int membersCount)
 	{
-		if(membersCount < 2)
+		if (membersCount < 2)
 		{
-			//not is a valid party
+			// not is a valid party
 			return getBaseExpSpBonus(membersCount);
 		}
 		return getBaseExpSpBonus(membersCount) * Config.RATE_PARTY_SP;
 	}
 	
-	public int getLevel() { return _partyLvl; }
+	@Override
+	public int getLevel()
+	{
+		return _partyLvl;
+	}
 	
-	public int getLootDistribution() { return _itemDistribution; }
+	public int getLootDistribution()
+	{
+		return _itemDistribution;
+	}
 	
 	public boolean isInCommandChannel()
 	{
@@ -955,19 +1022,29 @@ public class L2Party
 		_commandChannel = channel;
 	}
 	
-	public boolean isInDimensionalRift() { return _dr != null; }
+	public boolean isInDimensionalRift()
+	{
+		return _dr != null;
+	}
 	
-	public void setDimensionalRift(DimensionalRift dr) { _dr = dr; }
+	public void setDimensionalRift(DimensionalRift dr)
+	{
+		_dr = dr;
+	}
 	
-	public DimensionalRift getDimensionalRift() { return _dr; }
+	public DimensionalRift getDimensionalRift()
+	{
+		return _dr;
+	}
 	
+	@Override
 	public L2PcInstance getLeader()
 	{
 		try
 		{
 			return _members.getFirst();
 		}
-		catch(NoSuchElementException e)
+		catch (NoSuchElementException e)
 		{
 			return null;
 		}
@@ -978,15 +1055,19 @@ public class L2Party
 		if (_requestChangeLoot != -1)
 		{
 			if (System.currentTimeMillis() > _requestChangeLootTimer)
+			{
 				finishLootRequest(false); // timeout 45sec, guess
+			}
 			else
+			{
 				return;
+			}
 		}
 		_requestChangeLoot = type;
 		int additionalTime = L2PcInstance.REQUEST_TIMEOUT * 3000;
 		_requestChangeLootTimer = System.currentTimeMillis() + additionalTime;
 		_changeLootAnswers = FastList.newInstance();
-		_checkTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new ChangeLootCheck(), additionalTime+1000, 5000);
+		_checkTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new ChangeLootCheck(), additionalTime + 1000, 5000);
 		broadcastToPartyMembers(getLeader(), new ExAskModifyPartyLooting(getLeader().getName(), type));
 		SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.REQUESTING_APPROVAL_CHANGE_PARTY_LOOT_S1);
 		sm.addSystemString(LOOT_SYSSTRINGS[type]);
@@ -996,16 +1077,20 @@ public class L2Party
 	public synchronized void answerLootChangeRequest(L2PcInstance member, boolean answer)
 	{
 		if (_requestChangeLoot == -1)
+		{
 			return;
+		}
 		if (_changeLootAnswers.contains(member.getObjectId()))
+		{
 			return;
+		}
 		if (!answer)
 		{
 			finishLootRequest(false);
 			return;
 		}
 		_changeLootAnswers.add(member.getObjectId());
-		if (_changeLootAnswers.size() >= getMemberCount() - 1)
+		if (_changeLootAnswers.size() >= (getMemberCount() - 1))
 		{
 			finishLootRequest(true);
 		}
@@ -1014,7 +1099,9 @@ public class L2Party
 	private synchronized void finishLootRequest(boolean success)
 	{
 		if (_requestChangeLoot == -1)
+		{
 			return;
+		}
 		if (_checkTask != null)
 		{
 			_checkTask.cancel(false);
@@ -1022,16 +1109,16 @@ public class L2Party
 		}
 		if (success)
 		{
-			broadcastToPartyMembers(new ExSetPartyLooting(1, _requestChangeLoot));
+			broadcastPacket(new ExSetPartyLooting(1, _requestChangeLoot));
 			_itemDistribution = _requestChangeLoot;
 			SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.PARTY_LOOT_CHANGED_S1);
 			sm.addSystemString(LOOT_SYSSTRINGS[_requestChangeLoot]);
-			broadcastToPartyMembers(sm);
+			broadcastPacket(sm);
 		}
 		else
 		{
-			broadcastToPartyMembers(new ExSetPartyLooting(0, (byte) 0));
-			broadcastToPartyMembers(SystemMessage.getSystemMessage(SystemMessageId.PARTY_LOOT_CHANGE_CANCELLED));
+			broadcastPacket(new ExSetPartyLooting(0, (byte) 0));
+			broadcastPacket(SystemMessage.getSystemMessage(SystemMessageId.PARTY_LOOT_CHANGE_CANCELLED));
 		}
 		_requestChangeLoot = -1;
 		FastList.recycle((FastList<?>) _changeLootAnswers);
@@ -1043,9 +1130,9 @@ public class L2Party
 		@Override
 		public void run()
 		{
-			if (System.currentTimeMillis() > L2Party.this._requestChangeLootTimer)
+			if (System.currentTimeMillis() > _requestChangeLootTimer)
 			{
-				L2Party.this.finishLootRequest(false);
+				finishLootRequest(false);
 			}
 		}
 	}
@@ -1056,10 +1143,24 @@ public class L2Party
 		public void run()
 		{
 			if (_positionPacket == null)
+			{
 				_positionPacket = new PartyMemberPosition(L2Party.this);
+			}
 			else
+			{
 				_positionPacket.reuse(L2Party.this);
-			broadcastToPartyMembers(L2Party.this._positionPacket);
+			}
+			broadcastPacket(_positionPacket);
 		}
 	}
+	
+	/**
+	 * @return reurns all party members
+	 */
+	@Override
+	public List<L2PcInstance> getMembers()
+	{
+		return _members;
+	}
+	
 }