Gnacik: PartyMatching implementation.

L2_GameServer/java/com/l2jserver/gameserver/GameServer.java

@@ -112,6 +112,8 @@ import com.l2jserver.gameserver.model.AutoSpawnHandler;
 import com.l2jserver.gameserver.model.L2Manor;
 import com.l2jserver.gameserver.model.L2Multisell;
 import com.l2jserver.gameserver.model.L2World;
+import com.l2jserver.gameserver.model.PartyMatchRoomList;
+import com.l2jserver.gameserver.model.PartyMatchWaitingList;
 import com.l2jserver.gameserver.model.entity.Hero;
 import com.l2jserver.gameserver.model.entity.TvTManager;
 import com.l2jserver.gameserver.model.olympiad.Olympiad;
@@ -291,6 +293,8 @@ public class GameServer
 		CastleManorManager.getInstance();
 		MercTicketManager.getInstance();
 		// PartyCommandManager.getInstance();
+		PartyMatchWaitingList.getInstance();
+		PartyMatchRoomList.getInstance();
 		PetitionManager.getInstance();
 		QuestManager.getInstance();
 		TransformationManager.getInstance();

L2_GameServer/java/com/l2jserver/gameserver/instancemanager/TownManager.java

@@ -188,7 +188,88 @@ public class TownManager
 
         return getTown(16); // Default to floran
     }
-    
+
+    public final static int getClosestLocation(L2Object activeObject)
+    {
+        switch (MapRegionTable.getInstance().getMapRegion(activeObject.getPosition().getX(), activeObject.getPosition().getY()))
+		{
+			case 0:
+				return 1; // TI
+			case 1:
+				return 4; // Elven
+			case 2:
+				return 3; // DE
+			case 3:
+				return 9; // Orc
+			case 4:
+				return 9; // Dwarven
+			case 5:
+				return 2; // Gludio
+			case 6:
+				return 2; // Gludin
+			case 7:
+				return 5; // Dion
+			case 8:
+				return 6; // Giran
+			case 9:
+				return 10; // Oren
+			case 10:
+				return 13; // Aden
+			case 11:
+				return 11; // HV
+			case 12:
+				return 6; // Giran Harbour
+			case 13:
+				return 12; // Heine
+			case 14:
+				return 14; // Rune
+			case 15:
+				return 15; // Goddard
+			case 16:
+				return 9; // Schuttgart
+			/*
+			case 17:
+				return getTown(16); // Floran
+			case 18:
+				return getTown(19); //Primeval Isle
+            case 19:
+                return getTown(20); //Kamael Village
+            case 20:
+                return getTown(21); //South of Wastelands Camp
+            case 21:
+                return getTown(22); //Fantasy Island
+            case 22:
+                return 7; //Neutral Zone
+            case 23:
+                return getTown(24);//Coliseum
+            case 24:
+                return getTown(25);//GM Consultation service
+            case 25:
+                return getTown(26);//Dimensional Gap
+            case 26:
+                return getTown(27);//Cemetery of the Empire
+            case 27:
+                return getTown(28);//inside the Steel Citadel
+            case 28:
+                return getTown(29);//Steel Citadel Resistance
+            case 29:
+                return getTown(30);//Inside Kamaloka
+            case 30:
+                return getTown(31);//Inside Nia Kamaloka
+            case 31:
+                return getTown(32);//Inside Rim Kamaloka
+            case 32:
+                return getTown(33);//near the Keucereus clan association location
+            case 33:
+                return getTown(34);//inside the Seed of Infinity
+            case 34:
+                return getTown(35);//outside the Seed of Infinity
+            case 35:
+                return getTown(36);//inside Aerial Cleft
+                */
+		}
+        return 0;
+    }
     
     public final static boolean townHasCastleInSiege(int townId)
     {

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

@@ -475,6 +475,11 @@ public class L2Party {
 						msg.addString(_commandChannel.getChannelLeader().getName());
 						_commandChannel.broadcastToChannelMembers(msg);
 					}
+					if(player.isInPartyMatchRoom())
+					{
+						PartyMatchRoom room = PartyMatchRoomList.getInstance().getPlayerRoom(player);
+						room.changeLeader(player);
+					}
 				}
 			}
 			else
@@ -704,16 +709,6 @@ public class L2Party {
 		}
 	}
 
-	/**
-	 * Calculates and gives final XP and SP rewards to the party member.<BR>
-	 * This method takes in consideration number of members, members' levels, rewarder's level and bonus modifier for the actual party.<BR><BR>
-	 *
-	 * @param member is the L2Character to be rewarded
-	 * @param xpReward is the total amount of XP to be "splited" and given to the member
-	 * @param spReward is the total amount of SP to be "splited" and given to the member
-	 * @param penalty is the penalty that must be applied to the XP rewards of the requested member
-	 */
-
 	/**
 	 * refresh party level
 	 *

L2_GameServer/java/com/l2jserver/gameserver/model/PartyMatchRoom.java

@@ -0,0 +1,188 @@
+/*
+ * 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.instancemanager.TownManager;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.ExManagePartyRoomMember;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+
+/**
+ * @author Gnacik
+ *
+ */
+public class PartyMatchRoom
+{
+	private int _id;
+	private String _title;
+	private int _loot;
+	private int _location;
+	private int _minlvl;
+	private int _maxlvl;
+	private int _maxmem;
+	private final List<L2PcInstance> _members = new FastList<L2PcInstance>();
+	
+	public PartyMatchRoom(int id, String title, int loot, int minlvl, int maxlvl, int maxmem, L2PcInstance owner)
+	{
+		_id = id;
+		_title = title;
+		_loot = loot;
+		_location = TownManager.getClosestLocation(owner);
+		_minlvl = minlvl;
+		_maxlvl = maxlvl;
+		_maxmem = maxmem;
+		_members.add(owner);
+	}
+
+	public List<L2PcInstance> getPartyMembers()
+	{
+		return _members;
+	}
+	
+	public void addMember(L2PcInstance player)
+	{
+		_members.add(player);
+	}
+	
+	public void deleteMember(L2PcInstance player)
+	{
+		if (player != getOwner())
+		{
+			_members.remove(player);
+			notifyMembersAboutExit(player);
+		}
+		else if (_members.size() == 1)
+		{
+			PartyMatchRoomList.getInstance().deleteRoom(_id);
+		}
+		else
+		{
+			changeLeader(_members.get(1));
+			deleteMember(player);
+		}
+	}
+	
+	public void notifyMembersAboutExit(L2PcInstance player)
+	{
+		for(L2PcInstance _member : getPartyMembers())
+		{
+			SystemMessage sm = new SystemMessage(SystemMessageId.C1_LEFT_PARTY_ROOM);
+			sm.addCharName(player);
+			_member.sendPacket(sm);
+			_member.sendPacket(new ExManagePartyRoomMember(player, this, 2));
+		}
+	}
+	
+	public void changeLeader(L2PcInstance newLeader)
+	{
+		// Get current leader
+		L2PcInstance oldLeader = _members.get(0);
+		// Remove new leader
+		_members.remove(newLeader);
+		// Move him to first position
+		_members.set(0,newLeader);
+		// Add old leader as normal member
+		_members.add(oldLeader);
+		// Broadcast change
+		for(L2PcInstance member : getPartyMembers())
+		{
+			member.sendPacket(new ExManagePartyRoomMember(newLeader, this, 1));
+			member.sendPacket(new ExManagePartyRoomMember(oldLeader, this, 1));
+			member.sendPacket(SystemMessageId.PARTY_ROOM_LEADER_CHANGED);
+		}
+	}
+	
+	public int getId()
+	{
+		return _id;
+	}
+	
+	public int getLootType()
+	{
+		return _loot;
+	}
+	
+	public int getMinLvl()
+	{
+		return _minlvl;
+	}
+
+	public int getMaxLvl()
+	{
+		return _maxlvl;
+	}
+
+	public int getLocation()
+	{
+		return _location;
+	}
+	
+	public int getMembers()
+	{
+		return _members.size();
+	}
+
+	public int getMaxMembers()
+	{
+		return _maxmem;
+	}
+
+	public String getTitle()
+	{
+		return _title;
+	}
+
+	public L2PcInstance getOwner()
+	{
+		return _members.get(0);
+	}
+
+	/* SET  */
+
+	public void setMinLvl(int minlvl)
+	{
+		_minlvl = minlvl;
+	}
+
+	public void setMaxLvl(int maxlvl)
+	{
+		_maxlvl = maxlvl;
+	}
+
+	public void setLocation(int loc)
+	{
+		_location = loc;
+	}
+	
+	public void setLootType(int loot)
+	{
+		_loot = loot;
+	}
+
+	public void setMaxMembers(int maxmem)
+	{
+		_maxmem = maxmem;
+	}
+
+	public void setTitle(String title)
+	{
+		_title = title;
+	}
+}

L2_GameServer/java/com/l2jserver/gameserver/model/PartyMatchRoomList.java

@@ -0,0 +1,111 @@
+/*
+ * 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.Map;
+
+import javolution.util.FastMap;
+
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.ExClosePartyRoom;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+
+
+/**
+ * @author Gnacik
+ */
+public class PartyMatchRoomList
+{
+	private int _maxid = 1;
+	private Map<Integer, PartyMatchRoom> _rooms;
+	
+	private PartyMatchRoomList()
+	{
+		_rooms = new FastMap<Integer, PartyMatchRoom>();
+	}	
+	
+	public synchronized void addPartyMatchRoom(int id, PartyMatchRoom room)
+	{
+		_rooms.put(id, room);
+		_maxid++;
+	}
+	
+	public void deleteRoom(int id)
+	{
+		for(L2PcInstance _member : getRoom(id).getPartyMembers())
+		{
+			if(_member == null)
+				continue;
+
+			_member.sendPacket(new ExClosePartyRoom());
+			_member.sendPacket(new SystemMessage(SystemMessageId.PARTY_ROOM_DISBANDED));
+			
+			_member.setPartyRoom(0);
+			//_member.setPartyMatching(0);
+			_member.broadcastUserInfo();
+		}		
+		_rooms.remove(id);
+	}
+	
+	public PartyMatchRoom getRoom(int id)
+	{
+		return _rooms.get(id);
+	}
+	
+	public PartyMatchRoom[] getRooms()
+	{
+		return _rooms.values().toArray(new PartyMatchRoom[_rooms.size()]);
+	}
+	
+	public int getPartyMatchRoomCount()
+	{
+		return _rooms.size();
+	}
+
+	public int getMaxId()
+	{
+		return _maxid;
+	}	
+	
+	public PartyMatchRoom getPlayerRoom(L2PcInstance player)
+	{
+		for(PartyMatchRoom _room : _rooms.values())
+			for(L2PcInstance member : _room.getPartyMembers())
+				if(member.equals(player))
+					return _room;
+		return null;
+	}
+	
+	public int getPlayerRoomId(L2PcInstance player)
+	{
+		for(PartyMatchRoom _room : _rooms.values())
+			for(L2PcInstance member : _room.getPartyMembers())
+				if(member.equals(player))
+					return _room.getId();
+		return -1;
+	}
+	
+	public static PartyMatchRoomList getInstance()
+	{
+		return SingletonHolder._instance;
+	}
+
+	@SuppressWarnings("synthetic-access")
+	private static class SingletonHolder
+	{
+		protected static final PartyMatchRoomList _instance = new PartyMatchRoomList();
+	}
+}

L2_GameServer/java/com/l2jserver/gameserver/model/PartyMatchWaitingList.java

@@ -0,0 +1,64 @@
+/*
+ * 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;
+
+/**
+ * @author Gnacik
+ *
+ */
+public class PartyMatchWaitingList
+{
+	private List<L2PcInstance> _members;
+
+	private PartyMatchWaitingList()
+	{
+		_members = new FastList<L2PcInstance>();
+	}
+	
+	public void addPlayer(L2PcInstance player)
+	{
+		// player.setPartyWait(1);
+		if (!_members.contains(player))
+			_members.add(player);
+	}
+	
+	public void removePlayer(L2PcInstance player)
+	{
+		//player.setPartyWait(0);
+		if (_members.contains(player))
+			_members.remove(player);
+	}
+
+	public List<L2PcInstance> getPlayers()
+	{
+		return _members;
+	}
+	
+	public static PartyMatchWaitingList getInstance()
+	{
+		return SingletonHolder._instance;
+	}
+	
+	@SuppressWarnings("synthetic-access")
+	private static class SingletonHolder
+	{
+		protected static final PartyMatchWaitingList _instance = new PartyMatchWaitingList();
+	}	
+}

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java

@@ -116,6 +116,9 @@ import com.l2jserver.gameserver.model.L2UIKeysSettings;
 import com.l2jserver.gameserver.model.L2World;
 import com.l2jserver.gameserver.model.L2WorldRegion;
 import com.l2jserver.gameserver.model.MacroList;
+import com.l2jserver.gameserver.model.PartyMatchRoom;
+import com.l2jserver.gameserver.model.PartyMatchRoomList;
+import com.l2jserver.gameserver.model.PartyMatchWaitingList;
 import com.l2jserver.gameserver.model.ShortCuts;
 import com.l2jserver.gameserver.model.TerritoryWard;
 import com.l2jserver.gameserver.model.TradeList;
@@ -617,11 +620,10 @@ public final class L2PcInstance extends L2Playable
 	//TODO: This needs to be better intergrated and saved/loaded
 	private L2Radar _radar;
 
-	// these values are only stored temporarily
-	private boolean _partyMatchingAutomaticRegistration;
-	private boolean _partyMatchingShowLevel;
-	private boolean _partyMatchingShowClass;
-	private String _partyMatchingMemo;
+	// Party matching
+	// private int _partymatching = 0;
+	private int _partyroom = 0;
+	// private int _partywait = 0;
 
 	// Clan related attributes
 	/** The Clan Identifier of the L2PcInstance */
@@ -6036,56 +6038,24 @@ public final class L2PcInstance extends L2Playable
 		getStat().addExp(-lostExp);
 	}
 
-	/**
-	 * @param b
-	 */
-	public void setPartyMatchingAutomaticRegistration(boolean b)
-	{
-		_partyMatchingAutomaticRegistration = b;
-	}
-
-	/**
-	 * @param b
-	 */
-	public void setPartyMatchingShowLevel(boolean b)
-	{
-		_partyMatchingShowLevel = b;
-	}
-
-	/**
-	 * @param b
-	 */
-	public void setPartyMatchingShowClass(boolean b)
-	{
-		_partyMatchingShowClass = b;
-	}
-
-	/**
-	 * @param memo
-	 */
-	public void setPartyMatchingMemo(String memo)
-	{
-		_partyMatchingMemo = memo;
-	}
-
-	public boolean isPartyMatchingAutomaticRegistration()
+	public boolean isPartyWaiting()
 	{
-		return _partyMatchingAutomaticRegistration;
+		return PartyMatchWaitingList.getInstance().getPlayers().contains(this);
 	}
-
-	public String getPartyMatchingMemo()
+	
+	public void setPartyRoom(int id)
 	{
-		return _partyMatchingMemo;
+		_partyroom = id;
 	}
-
-	public boolean isPartyMatchingShowClass()
+	
+	public int getPartyRoom()
 	{
-		return _partyMatchingShowClass;
+		return _partyroom;
 	}
-
-	public boolean isPartyMatchingShowLevel()
+	
+	public boolean isInPartyMatchRoom()
 	{
-		return _partyMatchingShowLevel;
+		return _partyroom > 0;
 	}
 
 	/**
@@ -11672,6 +11642,23 @@ public final class L2PcInstance extends L2Playable
 			_log.log(Level.SEVERE, "deleteMe()", e);
 		}
 		
+		try
+		{
+			PartyMatchWaitingList.getInstance().removePlayer(this);
+			if (_partyroom != 0)
+			{
+				PartyMatchRoom room = PartyMatchRoomList.getInstance().getRoom(_partyroom);
+				if (room != null)
+				{
+					room.deleteMember(this);
+				}
+			}
+		}
+		catch (Exception e)
+		{
+			_log.log(Level.SEVERE, "deleteMe()", e);
+		}
+		
 		try
 		{
 			if (isFlying())

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestAnswerJoinParty.java

@@ -14,8 +14,11 @@
  */
 package com.l2jserver.gameserver.network.clientpackets;
 
+import com.l2jserver.gameserver.model.PartyMatchRoom;
+import com.l2jserver.gameserver.model.PartyMatchRoomList;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.ExManagePartyRoomMember;
 import com.l2jserver.gameserver.network.serverpackets.JoinParty;
 import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
 
@@ -67,6 +70,35 @@ public final class RequestAnswerJoinParty extends L2GameClientPacket
 					}
 				}//Update by rocknow-End
     			player.joinParty(requestor.getParty());
+
+    			if(requestor.isInPartyMatchRoom() && player.isInPartyMatchRoom())
+    			{
+    				PartyMatchRoomList list = PartyMatchRoomList.getInstance();
+    				if(list != null && (list.getPlayerRoomId(requestor) == list.getPlayerRoomId(player)))
+    				{
+    					PartyMatchRoom room = list.getPlayerRoom(requestor);
+    					for(L2PcInstance member : room.getPartyMembers())
+    					{
+    						member.sendPacket(new ExManagePartyRoomMember(player, room, 1));
+    					}
+    				}
+    			}
+    			else if (requestor.isInPartyMatchRoom() && !player.isInPartyMatchRoom())
+    			{
+    				PartyMatchRoomList list = PartyMatchRoomList.getInstance();
+    				if(list != null)
+    				{
+    					PartyMatchRoom room = list.getPlayerRoom(requestor);
+    					room.addMember(player);
+    					for(L2PcInstance member : room.getPartyMembers())
+    					{
+    						member.sendPacket(new ExManagePartyRoomMember(player, room, 1));
+    					}
+    					player.setPartyRoom(room.getId());
+    					//player.setPartyMatching(1);
+    					player.broadcastUserInfo();
+    				}
+    			}
     		}
     		else
             {

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestDismissPartyRoom.java

@@ -14,38 +14,49 @@
  */
 package com.l2jserver.gameserver.network.clientpackets;
 
-import java.util.logging.Logger;
+import com.l2jserver.gameserver.model.PartyMatchRoom;
+import com.l2jserver.gameserver.model.PartyMatchRoomList;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 /**
- * Format: (ch) dd
- * @author -Wooden-
- *
+ * @author Gnacik
+ * 
  */
 public class RequestDismissPartyRoom extends L2GameClientPacket
 {
-	private static Logger _log = Logger.getLogger(RequestDismissPartyRoom.class.getName());
-	private static final String _C__D0_02_REQUESTDISMISSPARTYROOM = "[C] D0:02 RequestDismissPartyRoom";
-	private int _data1;
-	private int _data2;
+	private static final String _C__D0_0A_REQUESTDISMISSPARTYROOM = "[C] D0:0A RequestDismissPartyRoom";
 	
+	private int _roomid;
+	@SuppressWarnings("unused")
+	private int _data2;
+
 	@Override
 	protected void readImpl()
 	{
-		_data1 = readD();
+		_roomid = readD();
 		_data2 = readD();
 	}
-	
+
 	@Override
 	protected void runImpl()
 	{
-		_log.info("This packet is not well known : RequestDismissPartyRoom");
-		_log.info("Data received: d:" + _data1 + " d:" + _data2);
+		final L2PcInstance _activeChar = getClient().getActiveChar();
+		 
+		if (_activeChar == null)
+			return;
+
+		PartyMatchRoom _room = PartyMatchRoomList.getInstance().getRoom(_roomid);
+		
+		if (_room == null)
+			return;
+
+		PartyMatchRoomList.getInstance().deleteRoom(_roomid);
 	}
-	
+
 	@Override
 	public String getType()
 	{
-		return _C__D0_02_REQUESTDISMISSPARTYROOM;
+		return _C__D0_0A_REQUESTDISMISSPARTYROOM;
 	}
-	
+
 }

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestExitPartyMatchingWaitingRoom.java

@@ -14,35 +14,38 @@
  */
 package com.l2jserver.gameserver.network.clientpackets;
 
-import java.util.logging.Logger;
+import com.l2jserver.gameserver.model.PartyMatchWaitingList;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 /**
- * Format: (ch)
- * this is just a trigger : no data
- * @author  -Wooden-
+ * 
+ * @author Gnacik
  *
  */
 public final class RequestExitPartyMatchingWaitingRoom extends L2GameClientPacket
 {
-	protected static final Logger _log = Logger.getLogger(RequestExitPartyMatchingWaitingRoom.class.getName());
 	private static final String _C__D0_17_REQUESTEXITPARTYMATCHINGWAITINGROOM = "[C] D0:17 RequestExitPartyMatchingWaitingRoom";
 	
-	@Override
+    @Override
 	protected void readImpl()
-	{
-		//trigger
-	}
-	
-	@Override
+    {
+    }
+
+    @Override
 	protected void runImpl()
-	{
-		_log.info("C5: RequestExitPartyMatchingWaitingRoom");
-	}
-	
-	@Override
-	public String getType()
-	{
-		return _C__D0_17_REQUESTEXITPARTYMATCHINGWAITINGROOM;
-	}
-	
-}
+    {
+    	L2PcInstance _activeChar = getClient().getActiveChar();
+    	
+    	if (_activeChar == null)
+    		return;
+    	
+    	PartyMatchWaitingList.getInstance().removePlayer(_activeChar);
+    }
+
+    @Override
+    public String getType()
+    {
+        return _C__D0_17_REQUESTEXITPARTYMATCHINGWAITINGROOM;
+    }
+
+}

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestListPartyMatchingWaitingRoom.java

@@ -14,35 +14,45 @@
  */
 package com.l2jserver.gameserver.network.clientpackets;
 
-import java.util.logging.Logger;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.serverpackets.ExListPartyMatchingWaitingRoom;
 
 /**
- * Format: (ch)
- * this is just a trigger : no data
- * @author  -Wooden-
+ * 
+ * @author  Gnacik
  *
  */
 public class RequestListPartyMatchingWaitingRoom extends L2GameClientPacket
 {
-	protected static final Logger _log = Logger.getLogger(RequestListPartyMatchingWaitingRoom.class.getName());
-	private static final String _C__D0_16_REQUESTLISTPARTYMATCHINGWAITINGROOM = "[C] D0:16 RequestListPartyMatchingWaitingRoom";
-	
-	@Override
+	private static int _page;
+	private static int _minlvl;
+	private static int _maxlvl;
+    private static int _mode; // 1 - waitlist 0 - room waitlist
+
+    @Override
 	protected void readImpl()
-	{
-		// trigger
-	}
-	
-	@Override
+    {
+    	_page = readD();
+    	_minlvl = readD();
+    	_maxlvl = readD();
+    	_mode	= readD();
+    }
+
+    @Override
 	protected void runImpl()
-	{
-		_log.info("C5: RequestListPartyMatchingWaitingRoom");
-	}
-	
-	@Override
-	public String getType()
-	{
-		return _C__D0_16_REQUESTLISTPARTYMATCHINGWAITINGROOM;
-	}
-	
-}
+    {
+		L2PcInstance _activeChar = getClient().getActiveChar();
+		
+		if (_activeChar == null)
+			return;
+
+		_activeChar.sendPacket(new ExListPartyMatchingWaitingRoom(_activeChar,_page,_minlvl,_maxlvl, _mode));
+    }
+
+    @Override
+    public String getType()
+    {
+        return "[C] D0:31 RequestListPartyMatchingWaitingRoom";
+    }
+
+}

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestOustFromPartyRoom.java

@@ -14,6 +14,14 @@
  */
 package com.l2jserver.gameserver.network.clientpackets;
 
+import com.l2jserver.gameserver.model.L2World;
+import com.l2jserver.gameserver.model.PartyMatchRoom;
+import com.l2jserver.gameserver.model.PartyMatchRoomList;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.ExClosePartyRoom;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+
 /**
  * format (ch) d
  * @author -Wooden-
@@ -21,25 +29,51 @@ package com.l2jserver.gameserver.network.clientpackets;
  */
 public final class RequestOustFromPartyRoom extends L2GameClientPacket
 {
-	private static final String _C__D0_01_REQUESTOUSTFROMPARTYROOM = "[C] D0:01 RequestOustFromPartyRoom";
-	@SuppressWarnings("unused")
-	private int _id;
+	private static final String _C__D0_09_REQUESTOUSTFROMPARTYROOM = "[C] D0:09 RequestOustFromPartyRoom";
+	
+	private int _charid;
 	
 	@Override
 	protected void readImpl()
 	{
-		_id = readD();
+		_charid = readD();
 	}
 	
 	@Override
 	protected void runImpl()
 	{
+		L2PcInstance activeChar = getClient().getActiveChar();
+		if (activeChar == null)
+			return;
+		
+		L2PcInstance member = L2World.getInstance().getPlayer(_charid);
+		if (member == null)
+			return;
+
+		PartyMatchRoom _room = PartyMatchRoomList.getInstance().getPlayerRoom(member);
+		if (_room == null)
+			return;
+		
+		if (_room.getOwner() != activeChar)
+			return;
+
+		if (activeChar.isInParty() && member.isInParty() && activeChar.getParty().getPartyLeaderOID() == member.getParty().getPartyLeaderOID())
+		{
+			activeChar.sendPacket(new SystemMessage(SystemMessageId.CANNOT_DISMISS_PARTY_MEMBER));
+		}
+		else
+		{
+			_room.deleteMember(member);
+			member.setPartyRoom(0);
+			member.sendPacket(new ExClosePartyRoom());
+			member.sendPacket(new SystemMessage(SystemMessageId.OUSTED_FROM_PARTY_ROOM));
+		}
 	}
 	
 	@Override
 	public String getType()
 	{
-		return _C__D0_01_REQUESTOUSTFROMPARTYROOM;
+		return _C__D0_09_REQUESTOUSTFROMPARTYROOM;
 	}
 	
 }

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestPartyMatchConfig.java

@@ -14,6 +14,17 @@
  */
 package com.l2jserver.gameserver.network.clientpackets;
 
+import com.l2jserver.gameserver.model.PartyMatchRoom;
+import com.l2jserver.gameserver.model.PartyMatchRoomList;
+import com.l2jserver.gameserver.model.PartyMatchWaitingList;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.ActionFailed;
+import com.l2jserver.gameserver.network.serverpackets.ExPartyRoomMember;
+import com.l2jserver.gameserver.network.serverpackets.ListPartyWating;
+import com.l2jserver.gameserver.network.serverpackets.PartyMatchDetail;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+
 /**
  * This class ...
  *
@@ -22,57 +33,67 @@ package com.l2jserver.gameserver.network.clientpackets;
 
 public final class RequestPartyMatchConfig extends L2GameClientPacket
 {
-	private static final String _C__6F_REQUESTPARTYMATCHCONFIG = "[C] 6F RequestPartyMatchConfig";
-	//private static Logger _log = Logger.getLogger(RequestPartyMatchConfig.class.getName());
+	private static final String _C__7F_REQUESTPARTYMATCHCONFIG = "[C] 7F RequestPartyMatchConfig";
 
-	private int _automaticRegistration;
-	private int _showLevel;
-	private int _showClass;
-	private String _memo;
+	private int _auto, _loc, _lvl;
 
 
 	@Override
 	protected void readImpl()
 	{
-		_automaticRegistration    = readD();
-		_showLevel                = readD();
-		_showClass                = readD();
-
-        /*
-         *  TODO: Check if this this part of the packet has been
-         *  removed by latest versions.
-         *
-		try
-        {
-            _memo                 = readS();
-        }
-		catch (BufferUnderflowException e)
-        {
-            _memo                 = "";
-            _log.warning("Memo field non existant in packet. Notify devs.");
-            e.printStackTrace();
-        }*/
+		_auto = readD();	//
+		_loc = readD();		// Location
+		_lvl = readD();		// my level
 	}
 
-	@Override
-	protected void runImpl()
-	{
-		// TODO: this packet is currently for creating a new party room
-		if (getClient().getActiveChar() == null)
-		    return;
+ 	@Override
+ 	protected void runImpl()
+ 	{
+		L2PcInstance _activeChar = getClient().getActiveChar();
+ 
+		if (_activeChar == null)
+			return;
 
-		getClient().getActiveChar().setPartyMatchingAutomaticRegistration(_automaticRegistration == 1);
-		getClient().getActiveChar().setPartyMatchingShowLevel(_showLevel == 1);
-		getClient().getActiveChar().setPartyMatchingShowClass(_showClass == 1);
-		getClient().getActiveChar().setPartyMatchingMemo(_memo);
-	}
+		if( !_activeChar.isInPartyMatchRoom() && _activeChar.getParty() != null && _activeChar.getParty().getLeader() != _activeChar)
+		{
+			_activeChar.sendPacket(new SystemMessage(SystemMessageId.CANT_VIEW_PARTY_ROOMS));
+			_activeChar.sendPacket(ActionFailed.STATIC_PACKET);
+			return;
+		}
+		
+		if(_activeChar.isInPartyMatchRoom())
+		{
+			// If Player is in Room show him room, not list
+			PartyMatchRoomList _list = PartyMatchRoomList.getInstance();
+			if (_list==null)
+				return;
+			
+			PartyMatchRoom _room = _list.getPlayerRoom(_activeChar);
+			if (_room == null)
+				return;
+			
+			_activeChar.sendPacket(new PartyMatchDetail(_activeChar,_room));
+			_activeChar.sendPacket(new ExPartyRoomMember(_activeChar, _room, 2));
+
+			_activeChar.setPartyRoom(_room.getId());
+			//_activeChar.setPartyMatching(1);
+			_activeChar.broadcastUserInfo();
+		}
+		else
+		{
+			// Add to waiting list
+			PartyMatchWaitingList.getInstance().addPlayer(_activeChar);
+
+			// Send Room list
+			ListPartyWating matchList = new ListPartyWating(_activeChar,_auto,_loc,_lvl);
+			
+			_activeChar.sendPacket(matchList);
+		}
+ 	}
 
-	/* (non-Javadoc)
-	 * @see com.l2jserver.gameserver.clientpackets.ClientBasePacket#getType()
-	 */
 	@Override
 	public String getType()
 	{
-		return _C__6F_REQUESTPARTYMATCHCONFIG;
+		return _C__7F_REQUESTPARTYMATCHCONFIG;
 	}
 }

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestPartyMatchDetail.java

@@ -14,51 +14,90 @@
  */
 package com.l2jserver.gameserver.network.clientpackets;
 
-import com.l2jserver.gameserver.model.L2World;
+import com.l2jserver.gameserver.model.PartyMatchRoom;
+import com.l2jserver.gameserver.model.PartyMatchRoomList;
+import com.l2jserver.gameserver.model.PartyMatchWaitingList;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.ExManagePartyRoomMember;
+import com.l2jserver.gameserver.network.serverpackets.ExPartyRoomMember;
 import com.l2jserver.gameserver.network.serverpackets.PartyMatchDetail;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
 
 /**
- * This class ...
- *
- * @version $Revision: 1.1.4.3 $ $Date: 2005/03/27 15:29:30 $
+ * @author Gnacik
  */
 
 public final class RequestPartyMatchDetail extends L2GameClientPacket
 {
-	private static final String _C__71_REQUESTPARTYMATCHDETAIL = "[C] 71 RequestPartyMatchDetail";
-	//private static Logger _log = Logger.getLogger(RequestPartyMatchDetail.class.getName());
-
-	private int _objectId;
-    @SuppressWarnings("unused")
-	private int _unk1;
+	private int _roomid;
+	@SuppressWarnings("unused")
+    private int _unk1;
+	@SuppressWarnings("unused")
+    private int _unk2;
+	@SuppressWarnings("unused")
+    private int _unk3;
 
 
 	@Override
 	protected void readImpl()
 	{
-		_objectId = readD();
-        //TODO analyse value unk1
+		_roomid = readD();
+		/*
+		 * IF player click on Room all unk are 0
+		 * IF player click AutoJoin values are -1 1 1
+		 */
         _unk1 = readD();
+        _unk2 = readD();
+        _unk3 = readD();
 	}
 
 	@Override
 	protected void runImpl()
 	{
-		//TODO: this packet is currently for starting auto join
-		L2PcInstance player = (L2PcInstance) L2World.getInstance().findObject(_objectId);
-		if (player == null)
-		    return;
-		PartyMatchDetail details = new PartyMatchDetail(player);
-		sendPacket(details);
+		L2PcInstance _activeChar = getClient().getActiveChar();
+		if (_activeChar == null)
+			return;
+		
+		PartyMatchRoom _room = PartyMatchRoomList.getInstance().getRoom(_roomid);
+		if (_room == null)
+			return;
+		
+		if ((_activeChar.getLevel() >= _room.getMinLvl()) && (_activeChar.getLevel() <= _room.getMaxLvl()))
+		{
+			// Remove from waiting list
+			PartyMatchWaitingList.getInstance().removePlayer(_activeChar);
+			
+			_activeChar.setPartyRoom(_roomid);
+			
+			_activeChar.sendPacket(new PartyMatchDetail(_activeChar, _room));
+			_activeChar.sendPacket(new ExPartyRoomMember(_activeChar, _room, 0));
+
+			for(L2PcInstance _member : _room.getPartyMembers())
+			{
+				if(_member == null)
+					continue;
+				
+				_member.sendPacket(new ExManagePartyRoomMember(_activeChar, _room, 0));
+				
+				SystemMessage sm = new SystemMessage(SystemMessageId.C1_ENTERED_PARTY_ROOM);
+				sm.addCharName(_activeChar);
+				_member.sendPacket(sm);				
+			}
+			_room.addMember(_activeChar);
+
+			// Info Broadcast
+			_activeChar.broadcastUserInfo();			
+		}
+		else
+		{
+			_activeChar.sendPacket(new SystemMessage(SystemMessageId.CANT_ENTER_PARTY_ROOM));
+		}
 	}
 
-	/* (non-Javadoc)
-	 * @see com.l2jserver.gameserver.clientpackets.ClientBasePacket#getType()
-	 */
 	@Override
 	public String getType()
 	{
-		return _C__71_REQUESTPARTYMATCHDETAIL;
+		return "[C] 81 RequestPartyMatchDetail";
 	}
 }

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestPartyMatchList.java

@@ -16,74 +16,112 @@ package com.l2jserver.gameserver.network.clientpackets;
 
 import java.util.logging.Logger;
 
-import com.l2jserver.Config;
-
+import com.l2jserver.gameserver.model.PartyMatchRoom;
+import com.l2jserver.gameserver.model.PartyMatchRoomList;
+import com.l2jserver.gameserver.model.PartyMatchWaitingList;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.ExPartyRoomMember;
+import com.l2jserver.gameserver.network.serverpackets.PartyMatchDetail;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
 
 /**
- * Packetformat  Rev650  cdddddS
- *
- * @version $Revision: 1.1.4.4 $ $Date: 2005/03/27 15:29:30 $
+ * author: Gnacik
  */
 
 public class RequestPartyMatchList extends L2GameClientPacket
 {
-	private static final String _C__70_REQUESTPARTYMATCHLIST = "[C] 70 RequestPartyMatchList";
-	private static Logger _log = Logger.getLogger(RequestPartyMatchList.class.getName());
-
-	private int _status;
-    /*private int _unk1;
-    private int _unk2;
-    private int _unk3;
-    private int _unk4;
-    private String _unk5;*/
-
+	private static final Logger _log = Logger.getLogger(RequestPartyMatchList.class.getName());
+	
+	private int _roomid;
+	private int _membersmax;
+	private int _lvlmin;
+	private int _lvlmax;
+	private int _loot;
+	private String _roomtitle;
 
 	@Override
 	protected void readImpl()
 	{
-		_status = readD();
-        //TODO analyse values _unk1-unk5
-		/*
-        _unk1 = readD();
-        _unk2 = readD();
-        _unk3 = readD();
-        _unk4 = readD();
-        _unk5 = readS();
-        */
+		_roomid = readD();
+		_membersmax = readD();
+		_lvlmin = readD();
+		_lvlmax = readD();
+		_loot = readD();
+		_roomtitle = readS();
 	}
 
 	@Override
 	protected void runImpl()
 	{
-		if (_status == 1)
-		{
-			// window is open fill the list
-			// actually the client should get automatic updates for the list
-			// for now we only fill it once
+		L2PcInstance _activeChar = getClient().getActiveChar();
 
-			//Collection<L2PcInstance> players = L2World.getInstance().getAllPlayers();
-			//L2PcInstance[] allPlayers = players.toArray(new L2PcInstance[players.size()]);
-			//L2PcInstance[] empty = new L2PcInstance[] { };
-			//ListPartyWating matchList = new ListPartyWating(empty);
-			//sendPacket(matchList);
-		}
-		else if (_status == 3)
+		if (_activeChar == null)
+			return;
+
+		if (_roomid  > 0)
 		{
-			// client does not need any more updates
-			if (Config.DEBUG) _log.fine("PartyMatch window was closed.");
+			PartyMatchRoom _room = PartyMatchRoomList.getInstance().getRoom(_roomid);
+			if(_room != null)
+			{
+				_log.info("PartyMatchRoom #" + _room.getId() + " changed by "+_activeChar.getName());
+				_room.setMaxMembers(_membersmax);
+				_room.setMinLvl(_lvlmin);
+				_room.setMaxLvl(_lvlmax);
+				_room.setLootType(_loot);
+				_room.setTitle(_roomtitle);
+
+				for(L2PcInstance _member : _room.getPartyMembers())
+				{
+					if(_member == null)
+						continue;
+
+					_member.sendPacket(new PartyMatchDetail(_activeChar, _room));
+					_member.sendPacket(new SystemMessage(SystemMessageId.PARTY_ROOM_REVISED));
+				}
+			}
 		}
 		else
 		{
-			if (Config.DEBUG) _log.fine("party match status: "+_status);
+			int _maxid = PartyMatchRoomList.getInstance().getMaxId();
+			
+			PartyMatchRoom _room = new PartyMatchRoom(_maxid, _roomtitle, _loot, _lvlmin, _lvlmax, _membersmax, _activeChar);
+			
+			_log.info("PartyMatchRoom #" + _maxid + " created by " + _activeChar.getName());
+			// Remove from waiting list
+			PartyMatchWaitingList.getInstance().removePlayer(_activeChar);
+			
+			PartyMatchRoomList.getInstance().addPartyMatchRoom(_maxid, _room);
+			
+			if (_activeChar.isInParty())
+			{
+				for (L2PcInstance ptmember : _activeChar.getParty().getPartyMembers())
+				{
+					if (ptmember == null)
+						continue;
+					if (ptmember == _activeChar)
+						continue;
+					
+					ptmember.setPartyRoom(_maxid);
+					//ptmember.setPartyMatching(1);
+					
+					_room.addMember(ptmember);
+				}
+			}
+			_activeChar.sendPacket(new PartyMatchDetail(_activeChar, _room));
+			_activeChar.sendPacket(new ExPartyRoomMember(_activeChar, _room, 1));
+			
+			_activeChar.sendPacket(new SystemMessage(SystemMessageId.PARTY_ROOM_CREATED));
+			
+			_activeChar.setPartyRoom(_maxid);
+			//_activeChar.setPartyMatching(1);
+			_activeChar.broadcastUserInfo();
 		}
 	}
 
-	/* (non-Javadoc)
-	 * @see com.l2jserver.gameserver.clientpackets.ClientBasePacket#getType()
-	 */
 	@Override
 	public String getType()
 	{
-		return _C__70_REQUESTPARTYMATCHLIST;
+		return "[C] 80 RequestPartyMatchList";
 	}
-}
+}

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestWithDrawalParty.java

@@ -14,7 +14,12 @@
  */
 package com.l2jserver.gameserver.network.clientpackets;
 
+import com.l2jserver.gameserver.model.PartyMatchRoom;
+import com.l2jserver.gameserver.model.PartyMatchRoomList;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.serverpackets.ExClosePartyRoom;
+import com.l2jserver.gameserver.network.serverpackets.ExPartyRoomMember;
+import com.l2jserver.gameserver.network.serverpackets.PartyMatchDetail;
 
 
 /**
@@ -46,7 +51,25 @@ public final class RequestWithDrawalParty extends L2GameClientPacket
 			if (player.getParty().isInDimensionalRift() && !player.getParty().getDimensionalRift().getRevivedAtWaitingRoom().contains(player))
 				player.sendMessage("You can't exit party when you are in Dimensional Rift.");
 			else
+			{				
 				player.getParty().removePartyMember(player);
+				
+				if(player.isInPartyMatchRoom())
+				{
+					PartyMatchRoom _room = PartyMatchRoomList.getInstance().getPlayerRoom(player);
+					if(_room != null)
+					{
+						player.sendPacket(new PartyMatchDetail(player, _room));
+						player.sendPacket(new ExPartyRoomMember(player, _room, 0));
+						player.sendPacket(new ExClosePartyRoom());
+						
+						_room.deleteMember(player);
+					}
+					player.setPartyRoom(0);
+					//player.setPartyMatching(0);
+					player.broadcastUserInfo();
+				}
+			}
 		}
 	}
 

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestWithdrawPartyRoom.java

@@ -14,38 +14,68 @@
  */
 package com.l2jserver.gameserver.network.clientpackets;
 
-import java.util.logging.Logger;
+import com.l2jserver.gameserver.model.PartyMatchRoom;
+import com.l2jserver.gameserver.model.PartyMatchRoomList;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.ExClosePartyRoom;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
 
 /**
- * Format (ch) dd
- * @author -Wooden-
+ * 
+ * @author Gnacik
  *
  */
 public final class RequestWithdrawPartyRoom extends L2GameClientPacket
 {
-	private static Logger _log = Logger.getLogger(RequestWithdrawPartyRoom.class.getName());
-	private static final String _C__D0_02_REQUESTWITHDRAWPARTYROOM = "[C] D0:02 RequestWithdrawPartyRoom";
-	private int _data1;
-	private int _data2;
-	
+	private int _roomid;
+	@SuppressWarnings("unused")
+    private int _unk1;
+
+
 	@Override
 	protected void readImpl()
 	{
-		_data1 = readD();
-		_data2 = readD();
+		_roomid = readD();
+		_unk1 = readD();
 	}
-	
+
 	@Override
 	protected void runImpl()
 	{
-		_log.info("This packet is not well known : RequestWithdrawPartyRoom");
-		_log.info("Data received: d:" + _data1 + " d:" + _data2);
+		final L2PcInstance _activeChar = getClient().getActiveChar();
+
+		if (_activeChar == null)
+			return;
+
+		PartyMatchRoom _room = PartyMatchRoomList.getInstance().getRoom(_roomid);
+		if (_room == null)
+			return;
+
+		if((_activeChar.isInParty() && _room.getOwner().isInParty()) && (_activeChar.getParty().getPartyLeaderOID() == _room.getOwner().getParty().getPartyLeaderOID()))
+		{			
+			// If user is in party with Room Owner
+			// is not removed from Room
+			
+			//_activeChar.setPartyMatching(0);
+			_activeChar.broadcastUserInfo();			
+		}
+		else
+		{
+			_room.deleteMember(_activeChar);
+			
+			_activeChar.setPartyRoom(0);
+			//_activeChar.setPartyMatching(0);
+			
+			_activeChar.sendPacket(new ExClosePartyRoom());
+			_activeChar.sendPacket(new SystemMessage(SystemMessageId.PARTY_ROOM_EXITED));
+		}
 	}
-	
+
 	@Override
 	public String getType()
 	{
-		return _C__D0_02_REQUESTWITHDRAWPARTYROOM;
+		return "[C] D0:0B RequestWithdrawPartyRoom";
 	}
-	
+
 }

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/CharInfo.java

@@ -353,7 +353,7 @@ public class CharInfo extends L2GameServerPacket
 			for (int id : _activeChar.getCubics().keySet())
 				writeH(id);
 
-			writeC(0x00);	// find party members
+			writeC(_activeChar.isInPartyMatchRoom() ? 1 : 0);
 
 			if (gmSeeInvis)
 			{

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/ExClosePartyRoom.java

@@ -0,0 +1,38 @@
+/*
+ * 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.network.serverpackets;
+
+/**
+ * @author Gnacik
+ */
+public class ExClosePartyRoom extends L2GameServerPacket
+{
+	public ExClosePartyRoom()
+	{
+	}
+
+	@Override
+	public String getType()
+	{
+		return "[S] FE:09 ExClosePartyRoom";
+	}
+
+	@Override
+	protected void writeImpl()
+	{
+		writeC(0xfe);
+		writeH(0x09);
+	}
+}

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/ExListPartyMatchingWaitingRoom.java

@@ -0,0 +1,96 @@
+/*
+ * 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.network.serverpackets;
+
+import javolution.util.FastList;
+import com.l2jserver.gameserver.model.PartyMatchWaitingList;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+* @author Gnacik
+*/
+public class ExListPartyMatchingWaitingRoom extends L2GameServerPacket
+{
+	@SuppressWarnings("unused")
+	private final L2PcInstance _activeChar;
+	@SuppressWarnings("unused")
+	private int _page;
+	private int _minlvl;
+	private int _maxlvl;
+	private int _mode;
+	private FastList<L2PcInstance> _members;
+	
+	public ExListPartyMatchingWaitingRoom(L2PcInstance player, int page, int minlvl, int maxlvl, int mode)
+	{
+		 _activeChar = player;
+		 _page = page;
+		 _minlvl = minlvl;
+		 _maxlvl = maxlvl;
+		 _mode = mode;
+		 _members = new FastList<L2PcInstance>();
+	}
+    
+    @Override
+    protected void writeImpl()
+    {
+    	writeC(0xfe);
+        writeH(0x36);
+        if (_mode == 0)
+        {
+        	writeD(0);
+        	writeD(0);
+        	return;
+        }
+        
+        //if (_activeChar.isInPartyMatchRoom())
+        //	return;
+        
+    	for(L2PcInstance cha : PartyMatchWaitingList.getInstance().getPlayers())
+    	{
+    		if(cha == null)
+    			continue;
+    		
+    		if(!cha.isPartyWaiting())
+    		{
+    			PartyMatchWaitingList.getInstance().removePlayer(cha);
+    			continue;
+    		}
+    		
+    		if((cha.getLevel() < _minlvl) || (cha.getLevel() > _maxlvl))
+    			continue;
+    		
+    		_members.add(cha);
+    	}
+
+    	int _count = 0;
+		int _size = _members.size();
+    	
+        writeD(1);
+        writeD(_size);
+        while(_size > _count)
+        {
+        	writeS(_members.get(_count).getName());
+        	writeD(_members.get(_count).getActiveClass());
+        	writeD(_members.get(_count).getLevel());
+        	_count++;
+        }
+    }
+	
+    @Override
+    public String getType()
+    {
+        return "[S] FE:36 ExListPartyMatchingWaitingRoom";
+    }
+}

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/ExManagePartyRoomMember.java

@@ -0,0 +1,69 @@
+/*
+ * 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.network.serverpackets;
+
+import com.l2jserver.gameserver.instancemanager.TownManager;
+import com.l2jserver.gameserver.model.PartyMatchRoom;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+* @author Gnacik
+* 
+* Mode :
+* 		0 - add
+* 		1 - modify
+* 		2 - quit
+*/
+public class ExManagePartyRoomMember extends L2GameServerPacket
+{
+	private final L2PcInstance _activeChar;
+	private final PartyMatchRoom _room;
+	private final int _mode;
+	
+	public ExManagePartyRoomMember(L2PcInstance player, PartyMatchRoom room, int mode)
+    {
+        _activeChar = player;
+        _room = room;
+        _mode = mode;
+    }
+
+    @Override
+    protected void writeImpl()
+    {
+        writeC(0xfe);
+        writeH(0x0A);
+        writeD(_mode);
+        writeD(_activeChar.getObjectId());
+        writeS(_activeChar.getName());
+        writeD(_activeChar.getActiveClass());
+        writeD(_activeChar.getLevel());
+        writeD(TownManager.getClosestLocation(_activeChar));
+    	if (_room.getOwner().equals(_activeChar))
+    		writeD(1);
+    	else
+    	{
+    		if((_room.getOwner().isInParty() && _activeChar.isInParty()) && (_room.getOwner().getParty().getPartyLeaderOID() == _activeChar.getParty().getPartyLeaderOID()))
+    			writeD(2);
+    		else
+    			writeD(0);
+    	}
+    }
+
+    @Override
+    public String getType()
+    {
+        return "[S] FE:0A ExManagePartyRoomMember";
+    }
+}

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/ExPartyRoomMember.java

@@ -0,0 +1,66 @@
+/*
+ * 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.network.serverpackets;
+
+import com.l2jserver.gameserver.instancemanager.TownManager;
+import com.l2jserver.gameserver.model.PartyMatchRoom;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+* @author Gnacik
+*/
+public class ExPartyRoomMember extends L2GameServerPacket
+{
+	private final PartyMatchRoom _room;
+	private final int _mode;
+	
+	public ExPartyRoomMember(L2PcInstance player, PartyMatchRoom room, int mode)
+    {
+        _room = room;
+        _mode = mode;
+    }
+
+    @Override
+    protected void writeImpl()
+    {
+        writeC(0xfe);
+        writeH(0x08);
+        writeD(_mode);
+        writeD(_room.getMembers());
+        for(L2PcInstance _member : _room.getPartyMembers())
+        {
+        	writeD(_member.getObjectId());
+        	writeS(_member.getName());
+        	writeD(_member.getActiveClass());
+        	writeD(_member.getLevel());
+        	writeD(TownManager.getClosestLocation(_member));
+        	if (_room.getOwner().equals(_member))
+        		writeD(1);
+        	else
+        	{
+        		if((_room.getOwner().isInParty() && _member.isInParty()) && (_room.getOwner().getParty().getPartyLeaderOID() == _member.getParty().getPartyLeaderOID()))
+        			writeD(2);
+        		else
+        			writeD(0);
+        	}
+        }
+    }
+
+    @Override
+    public String getType()
+    {
+        return "[S] FE:08 ExPartyRoomMember";
+    }
+}

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/ListPartyWating.java

@@ -14,88 +14,74 @@
  */
 package com.l2jserver.gameserver.network.serverpackets;
 
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.model.PartyMatchRoom;
+import com.l2jserver.gameserver.model.PartyMatchRoomList;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 /**
- *
- *
- * sample
- * af
- * 02 00 00 00   count
- *
- * 71 b3 70 4b  object id
- * 44 00 79 00 66 00 65 00 72 00 00 00   name
- * 14 00 00 00  level
- * 0f 00 00 00  class id
- * 00 00 00 00  sex ??
- * 00 00 00 00  clan id
- * 02 00 00 00  ??
- * 6f 5f 00 00  x
- * af a9 00 00  y
- * f7 f1 ff ff  z
- *
- *
- * c1 9c c0 4b object id
- * 43 00 6a 00 6a 00 6a 00 6a 00 6f 00 6e 00 00 00
- * 0b 00 00 00  level
- * 12 00 00 00  class id
- * 00 00 00 00  sex ??
- * b1 01 00 00  clan id
- * 00 00 00 00
- * 13 af 00 00
- * 38 b8 00 00
- * 4d f4 ff ff
- * *
- * format   d (dSdddddddd)
- *
- * @version $Revision: 1.1.2.1.2.4 $ $Date: 2005/03/27 15:29:57 $
+ * @author Gnacik
+ * 
  */
 public class ListPartyWating extends L2GameServerPacket
 {
-	private static final String _S__AF_PARTYMATCHLIST = "[S] 9c ListPartyWating";
-	private L2PcInstance[] _matchingPlayers;
-
-	/**
-	 * @param allPlayers
-	 */
-	public ListPartyWating(L2PcInstance[] allPlayers)
+	private L2PcInstance _cha;
+	private int _loc;
+	private int _lim;
+	private FastList<PartyMatchRoom> _rooms;
+	
+	public ListPartyWating(L2PcInstance player, int auto, int location, int limit)
 	{
-		_matchingPlayers = allPlayers;
+		_cha = player;
+		_loc = location;
+		_lim = limit;
+		_rooms = new FastList<PartyMatchRoom>();
 	}
 
 	@Override
 	protected final void writeImpl()
 	{
-		writeC(0x9c);
-
-		int size = _matchingPlayers.length;
-		if (size > 40)
+		for(PartyMatchRoom room : PartyMatchRoomList.getInstance().getRooms())
 		{
-			size = 40; // the client only displays 40 players, so we also limit the list to 40
+			if (room.getMembers() < 1 || room.getOwner() == null || room.getOwner().isOnline() == 0 || room.getOwner().getPartyRoom() != room.getId())
+			{
+				PartyMatchRoomList.getInstance().deleteRoom(room.getId());
+				continue;
+			}
+			if (_loc > 0 && _loc != room.getLocation())
+				continue;
+			if (_lim == 0 && ((_cha.getLevel() < room.getMinLvl()) || (_cha.getLevel() > room.getMaxLvl())))
+				continue;
+			_rooms.add(room);
 		}
+		int count = 0;
+		int size = _rooms.size();
+
+		writeC(0x9c);
+		if (size > 0)
+			writeD(1);
+		else
+			writeD(0);
 
-		writeD(size);
-		for (int i=0;i<size;i++)
+		writeD(_rooms.size());
+		while(size > count)
 		{
-			writeD(_matchingPlayers[i].getObjectId());
-			writeS(_matchingPlayers[i].getName());
-			writeD(_matchingPlayers[i].getLevel());
-			writeD(_matchingPlayers[i].getClassId().getId());
-			writeD(00);   // 00 -white name   01-red name
-			writeD(_matchingPlayers[i].getClanId());
-			writeD(00); //  00 - no affil  01-party  02-party pending  03-
-			writeD(_matchingPlayers[i].getX());
-			writeD(_matchingPlayers[i].getY());
-			writeD(_matchingPlayers[i].getZ());
+			writeD(_rooms.get(count).getId());
+			writeS(_rooms.get(count).getTitle());
+			writeD(_rooms.get(count).getLocation());
+			writeD(_rooms.get(count).getMinLvl());
+			writeD(_rooms.get(count).getMaxLvl());
+			writeD(_rooms.get(count).getMembers());
+			writeD(_rooms.get(count).getMaxMembers());
+			writeS(_rooms.get(count).getOwner().getName());
+			count++;
 		}
 	}
 
-	/* (non-Javadoc)
-	 * @see com.l2jserver.gameserver.serverpackets.ServerBasePacket#getType()
-	 */
 	@Override
 	public String getType()
 	{
-		return _S__AF_PARTYMATCHLIST;
+		return "[S] 9c ListPartyWating";
 	}
 }

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/PartyMatchDetail.java

@@ -14,70 +14,40 @@
  */
 package com.l2jserver.gameserver.network.serverpackets;
 
+import com.l2jserver.gameserver.model.PartyMatchRoom;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 /**
- *
- *
- * sample
- * b0
- * d8 a8 10 48  objectId
- * 00 00 00 00
- * 00 00 00 00
- * 00 00
- *
- * format   ddddS
- *
- * @version $Revision: 1.1.2.1.2.3 $ $Date: 2005/03/27 15:29:39 $
+ * @author Gnacik
  */
 public class PartyMatchDetail extends L2GameServerPacket
 {
-	private static final String _S__B0_PARTYMATCHDETAIL = "[S] 9d PartyMatchDetail";
-	private L2PcInstance _activeChar;
+	private PartyMatchRoom _room;
 
 	/**
 	 * @param allPlayers
 	 */
-	public PartyMatchDetail(L2PcInstance player)
+	public PartyMatchDetail(L2PcInstance player, PartyMatchRoom room)
 	{
-		_activeChar = player;
+		_room = room;
 	}
 
 	@Override
 	protected final void writeImpl()
 	{
 		writeC(0x9d);
-
-		writeD(_activeChar.getObjectId());
-		if (_activeChar.isPartyMatchingShowLevel())
-		{
-			writeD(1); // show level
-		}
-		else
-		{
-			writeD(0); // hide level
-		}
-
-		if (_activeChar.isPartyMatchingShowClass())
-		{
-			writeD(1); // show class
-		}
-		else
-		{
-			writeD(0); // hide class
-		}
-
-		writeD(0); //c2
-
-		writeS("  " + _activeChar.getPartyMatchingMemo()); // seems to be bugged.. first 2 chars get stripped away
+		writeD(_room.getId());			//	Room ID
+		writeD(_room.getMaxMembers());		//	Max Members
+		writeD(_room.getMinLvl());		//	Level Min
+		writeD(_room.getMaxLvl());		//	Level Max
+		writeD(_room.getLootType());		//	Loot Type
+		writeD(_room.getLocation());	//	Room Location
+		writeS(_room.getTitle());		//	Room title
 	}
 
-	/* (non-Javadoc)
-	 * @see com.l2jserver.gameserver.serverpackets.ServerBasePacket#getType()
-	 */
 	@Override
 	public String getType()
 	{
-		return _S__B0_PARTYMATCHDETAIL;
+		return "[S] 9d PartyMatchDetail";
 	}
 }

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/UserInfo.java

@@ -298,7 +298,7 @@ public final class UserInfo extends L2GameServerPacket
         for (int id : _activeChar.getCubics().keySet())
             writeH(id);
 
-        writeC(0x00); //1-find party members
+        writeC(_activeChar.isInPartyMatchRoom() ? 1 : 0);
 
         if (_activeChar.getAppearance().getInvisible() && _activeChar.isGM())
         	writeD(_activeChar.getAbnormalEffect() | AbnormalEffect.STEALTH.getMask());