public static void ProcessChat(Client client, PacketReader packet)
{
var uidChar = packet.ReadMuid();
var uidChan = packet.ReadMuid();
var message = packet.ReadString();
if (client.GetChannel() != null)
client.GetChannel().Chat(client, message);
}
public static void ProcessChannelJoin(Client client, PacketReader packet)
{
var playerId = packet.ReadMuid();
var channelId = packet.ReadMuid();
var channel = ChannelList.Find(channelId);
if (channel != null)
{
channel.Join(client);
}
}
public static void ProcessCreateChar(Client client, PacketReader packetReader)
{
var uid = packetReader.ReadMuid();
var index = packetReader.ReadInt32();
var name = packetReader.ReadString();
var sex = packetReader.ReadInt32();
var hair = packetReader.ReadInt32();
var face = packetReader.ReadInt32();
var costume = packetReader.ReadInt32();
var result = Results.Accepted;
if (uid != client.GetMuid() || index < 0 || index > 4 || sex < 0 || sex > 1)
{
client.Disconnect();
return;
}
if (!Globals.AcceptedString.IsMatch(name))
result = Results.CharacterEnterName;
else if (Globals.GunzDatabase.GetCharacterCount(client.ClientPlayer.PlayerAccount.AccountId) >= 4)
result = Results.CharacterNameNonExistant;
else if (Globals.GunzDatabase.CharacterExists(name))
result = Results.CharacterNameInUse;
else if (!Globals.GunzDatabase.CreateCharacter(client.ClientPlayer.PlayerAccount.AccountId, (byte)index, name, sex, hair, face, costume))
result = Results.CharacterInvalidName;
Match.ResponseCreateChar(client, result, name);
}
public static void ProcessDeleteChar(Client client, PacketReader packetReader)
{
var uid = packetReader.ReadMuid();
var index = packetReader.ReadInt32();
var name = packetReader.ReadString();
var result = Results.Accepted;
if (uid != client.GetMuid() || !Globals.AcceptedString.IsMatch(name) || index < 0 || index > 4)
{
client.Disconnect();
return;
}
var cid = Globals.GunzDatabase.GetCid(client.ClientPlayer.PlayerAccount.AccountId, index);
if (cid == 0)
{
result = Results.CharacterDeleteDisabled;
}
else
{
Globals.GunzDatabase.DeleteCharacter(client.ClientPlayer.PlayerAccount.AccountId, cid);
}
Match.ResponseDeleteCharacter(client, result);
}
public static void ProcessPeerRelay(Client client, PacketReader packetReader)
{
if (client.GetStage() == null)
return;
var charId = packetReader.ReadMuid();
var peerId = packetReader.ReadMuid();
//Now attempt to bind them!
if (Globals.NatAgent != null)
{
AgentPackets.RelayPeer(Globals.NatAgent, new Tuple<Muid, Muid, Muid>(charId, peerId, client.GetStage().GetTraits().StageId));
Log.Write("Binding player to NAT");
}
else
{
AgentPackets.AgentError(client, 10001);
}
}
public static void ProcessPeerReady(Client client, PacketReader packetReader)
{
if (Globals.NatAgent == null)
return;
var charId = packetReader.ReadMuid();
var peerId = packetReader.ReadMuid();
var agentId = Globals.NatAgent.GetMuid();
var peer1 = TcpServer.GetClientFromUid(charId);
var peer2 = TcpServer.GetClientFromUid(peerId);
if (peer1 != null)
{
AgentPackets.AgentLocateToClient(peer1, agentId);
AgentPackets.ResponsePeerRelay(peer1, peerId);
}
if (peer2 != null)
{
AgentPackets.AgentLocateToClient(peer2, Globals.NatAgent.GetMuid());
AgentPackets.ResponsePeerRelay(peer2, charId);
}
}
public static void ProcessAdminAnnounce(Client client, PacketReader packetReader)
{
var adminId = packetReader.ReadMuid();
var message = packetReader.ReadString();
if (client.ClientPlayer.PlayerAccount.Access == UGradeId.Administrator
|| client.ClientPlayer.PlayerAccount.Access == UGradeId.Developer
|| client.ClientPlayer.PlayerAccount.Access == UGradeId.EventMaster)
{
Match.Announce(client, message);
return;
}
client.Disconnect();
return;
}
public static void ProcessGameKill(Client client, PacketReader packet)
{
if (client.GetStage() == null)
{
Log.Write("Client doesn't have a stage...?");
return;
}
var uidKiller = packet.ReadMuid();
Client killer;
lock (client.GetStage().ObjectLock)
{
killer =
client.GetStage().GetTraits().Players.Find(c => c.GetMuid() == uidKiller);
}
if (killer != null)
client.GetStage().GetTraits().Ruleset.GameKillCallback(killer, client);
else
{
Log.Write("Invalid killer");
}
}
public static void ProcessClanInfo(Client client, PacketReader packetReader)
{
var uid = packetReader.ReadMuid();
var name = packetReader.ReadString();
ClanPackets.ClanInfo(client, name);
}
public static void ProcessAnswerAgreement(Client client, PacketReader packetReader)
{
var request = packetReader.ReadInt32();
var masterId = packetReader.ReadMuid();
var name = packetReader.ReadString();
var answer = packetReader.ReadBoolean();
PendingClan pendingClan;
lock (Globals.PendingClans)
pendingClan = Globals.PendingClans.Find(c => c.ClanMaster.GetMuid() == masterId);
if (pendingClan == null)
return;
if (answer == false)
{
lock (Globals.PendingClans)
Globals.PendingClans.Remove(pendingClan);
return;
}
if (pendingClan.Member1.First.GetCharacter().Name == name)
{
pendingClan.Member1.Second = true;
}
if (pendingClan.Member2.First.GetCharacter().Name == name)
{
pendingClan.Member2.Second = answer;
}
if (pendingClan.Member3.First.GetCharacter().Name == name)
{
pendingClan.Member3.Second = answer;
}
if (pendingClan.Member4.First.GetCharacter().Name == name)
{
pendingClan.Member4.Second = answer;
}
if (pendingClan.Member1.Second && pendingClan.Member2.Second && pendingClan.Member3.Second && pendingClan.Member4.Second)
{
int clanId = Globals.GunzDatabase.CreateClan(pendingClan.ClanName, pendingClan.ClanMaster, pendingClan.Member1.First,
pendingClan.Member2.First, pendingClan.Member3.First,
pendingClan.Member4.First);
ClanPackets.ResponseAagreedCreateClan(pendingClan);
pendingClan.ClanMaster.GetCharacter().ClanId = clanId;
pendingClan.Member1.First.GetCharacter().ClanId = clanId;
pendingClan.Member2.First.GetCharacter().ClanId = clanId;
pendingClan.Member3.First.GetCharacter().ClanId = clanId;
pendingClan.Member4.First.GetCharacter().ClanId = clanId;
pendingClan.ClanMaster.GetCharacter().ClanName = pendingClan.ClanName;
pendingClan.Member1.First.GetCharacter().ClanName = pendingClan.ClanName;
pendingClan.Member2.First.GetCharacter().ClanName = pendingClan.ClanName;
pendingClan.Member3.First.GetCharacter().ClanName = pendingClan.ClanName;
pendingClan.Member4.First.GetCharacter().ClanName = pendingClan.ClanName;
lock (Globals.PendingClans)
Globals.PendingClans.Remove(pendingClan);
ClanPackets.SendMemberList(pendingClan.ClanMaster);
ClanPackets.SendMemberList(pendingClan.Member1.First);
ClanPackets.SendMemberList(pendingClan.Member2.First);
ClanPackets.SendMemberList(pendingClan.Member3.First);
ClanPackets.SendMemberList(pendingClan.Member4.First);
ClanPackets.UpdateClanCharInfo(pendingClan.ClanMaster);
ClanPackets.UpdateClanCharInfo(pendingClan.Member1.First);
ClanPackets.UpdateClanCharInfo(pendingClan.Member2.First);
ClanPackets.UpdateClanCharInfo(pendingClan.Member3.First);
ClanPackets.UpdateClanCharInfo(pendingClan.Member4.First);
}
}
public static void ProcessResponseAgreement(Client client, PacketReader packetReader)
{
var uidProposer = packetReader.ReadMuid();
var uidChar = packetReader.ReadMuid();
var name = packetReader.ReadString();
var proposal = packetReader.ReadInt32();
var request = packetReader.ReadInt32();
var agreement = packetReader.ReadBoolean();
PendingClanWarRequest pc = Globals.PendingClanWar.Find(p => p.ClanName == client.GetCharacter().ClanName);
if (agreement == true)
{
lock (Globals.PendingClanWar)
{
pc.Players.Find(p => p.First == client).Second = true;
}
}
lock (Globals.PendingClanWar)
{
if (pc.Players.FindAll(p => p.Second).Count == pc.Players.Count)
{
List<Client> players = new List<Client>();
foreach (var p in pc.Players)
players.Add(p.First);
players.Add(pc.Requester);
ClanPackets.SearchRival(players);
Globals.PendingClanWar.Remove(pc);
ClanWarHandler.FindMatch(players);
}
}
}
public static void ProcessSelectChar(Client client, PacketReader packetReader)
{
var uid = packetReader.ReadMuid();
var index = packetReader.ReadInt32();
if (uid != client.GetMuid() || index < 0 || index > 4)
{
client.Disconnect();
return;
}
client.ClientFlags = PacketFlags.Character;
Globals.GunzDatabase.GetCharacter(client.ClientPlayer.PlayerAccount.AccountId, (byte)index, client.GetCharacter());
Match.ResponseSelectCharacter(client);
}
public static void ResponseStageState(Client client, PacketReader packetReader)
{
var charId = packetReader.ReadMuid();
var stageId = packetReader.ReadMuid();
var state = packetReader.ReadInt32();
if (!Enum.IsDefined(typeof(ObjectStageState), state) || client.GetStage() == null)
{
client.Disconnect();
return;
}
client.ClientPlayer.PlayerState = (ObjectStageState)state;
client.GetStage().PlayerState(client);
}
public static void ProcessStageMap(Client client, PacketReader packetReader)
{
var uid = packetReader.ReadMuid();
var map = packetReader.ReadString();
if (map.Length > 127 || client.GetStage() == null || client.GetStage().GetTraits().Master != client)
{
client.Disconnect();
return;
}
if (map != "RelayMap")
{
client.GetStage().GetTraits().RelayEnabled = false;
client.GetStage().GetTraits().Map = map;
try
{
client.GetStage().GetTraits().CurrentMap = Globals.Maps.GetMap(map);
}
catch
{
Log.Write("Unable to load map: {0}. Defaulting to Mansion", map);
client.GetStage().GetTraits().CurrentMap = Globals.Maps.GetMap("Mansion");
}
}
else
{
client.GetStage().GetTraits().RelayEnabled = true;
}
client.GetStage().Settings(client, true);
Channel.Refresh(client);
}
public static void ProcessStageCreate(Client client, PacketReader packetReader)
{
var uid = packetReader.ReadMuid();
var name = packetReader.ReadString();
var locked = packetReader.ReadBoolean();
var password = packetReader.ReadString();
if (uid != client.GetMuid())
{
client.Disconnect();
return;
}
var traits = new StageTraits();
traits.StageId = Globals.StageCounter.GetNext();
traits.Name = name;
traits.Locked = locked;
traits.Password = password;
traits.Master = client;
client.ClientPlayer.PlayerStage = client.GetChannel().Add(traits);
client.GetStage().Join(client);
}
public static void ProcessObtainWorldItem(Client client, PacketReader packet)
{
var uidChar = packet.ReadMuid();
var nItem = packet.ReadInt32();
lock (client.GetStage().GetTraits().CurrentMap)
{
var i =
client.GetStage().GetTraits().CurrentMap.DeathMatchItems.Find(
ii => ii.ItemUid == nItem);
if (i != null)
{
i.Taken = true;
i.NextSpawn = DateTime.Now.AddSeconds(i.SpawnTime);
Log.Write("Spawning item: {0}. Next Spawn: {1}", i.ItemId, DateTime.Now.AddSeconds(i.SpawnTime / 1000));
}
else
{
lock (client.GetStage().GetTraits().WorldItems)
{
i = client.GetStage().GetTraits().WorldItems.Find(ii => ii.ItemUid == nItem);
if (i != null)
{
client.GetStage().GetTraits().WorldItems.Remove(i);
}
else
{
return;
}
}
}
lock (client.GetStage().ObjectLock)
Battle.ObtainWorldItem(client.GetStage().GetTraits().Players,
client.GetMuid(), nItem);
}
}
public static void ProcessClanChat(Client client, PacketReader packetReader)
{
if (client.GetCharacter().ClanId < 1)
return;
var sender = packetReader.ReadMuid();
var msg = packetReader.ReadString();
ClanPackets.Message(client, msg);
}
public static void ProcessAnswerJoin(Client client, PacketReader packetReader)
{
var admin = packetReader.ReadMuid();
var name = packetReader.ReadString();
var answer = packetReader.ReadBoolean();
Client owner = TcpServer.GetClientFromUid(admin);
if (owner == null)
return;
if (!answer)
{
ClanPackets.ResponseJoin(owner, Results.ClanJoinRejected);
return;
}
ClanPackets.ResponseAgreedJoin(owner);
client.GetCharacter().ClanId = owner.GetCharacter().ClanId;
client.GetCharacter().ClanName = owner.GetCharacter().ClanName;
Globals.GunzDatabase.JoinClan(client.GetCharacter().CharacterId, owner.GetCharacter().ClanId);
ClanPackets.UpdateClanCharInfo(client);
ClanPackets.SendMemberList(client);
ClanPackets.MemberConnected(client,name);
}
public static void ProcessRelayMap(Client pClient, PacketReader pPacket)
{
var uid = pPacket.ReadMuid();
var type = pPacket.ReadInt32();
var count = pPacket.ReadInt32();
var totalSize = pPacket.ReadInt32();
var elementSize = pPacket.ReadInt32();
var elementCount = pPacket.ReadInt32();
if (elementCount < 0)
return;
var stage = pClient.GetStage().GetTraits();
stage.RelayMaps = new RelayMapInfo();
stage.RelayMaps.RepeatCount = count;
stage.RelayMaps.RelayType = type;
stage.RelayMaps.Maps = new List<RelayMaps>();
for (var i = 0; i < elementCount; ++i)
{
var map = pPacket.ReadInt32();
Log.Write("Found map: {0}", (RelayMaps)map);
stage.RelayMaps.Maps.Add((RelayMaps)map);
}
stage.Map = (stage.RelayMaps.Maps[0]).ToString();
stage.CurrentMap = Globals.Maps.GetMap(stage.RelayMaps.Maps[0].ToString());
}
public static void ProcessCreateClan(Client client, PacketReader packetReader)
{
var masterId = packetReader.ReadMuid();
var reqeuest = packetReader.ReadInt32();
var clanName = packetReader.ReadString();
var member1 = packetReader.ReadString();
var member2 = packetReader.ReadString();
var member3 = packetReader.ReadString();
var member4 = packetReader.ReadString();
var members = new List<Client>();
members.Add(TcpServer.GetClientFromName(member1));
members.Add(TcpServer.GetClientFromName(member2));
members.Add(TcpServer.GetClientFromName(member3));
members.Add(TcpServer.GetClientFromName(member4));
if (!Globals.AcceptedString.IsMatch(clanName))
{
return;
}
if (Globals.GunzDatabase.ClanExists(clanName))
{
ClanPackets.ResponseCreateClan(client, Results.ClanNameInUse, reqeuest);
return;
}
foreach (var member in members)
{
if (member == null || Globals.GunzDatabase.IsInClan(member))
{
ClanPackets.ResponseCreateClan(client, Results.ClanUserAlreadyInAClan, reqeuest);
return;
}
}
var pendingClan = new PendingClan();
pendingClan.ClanMaster = client;
pendingClan.ClanName = clanName;
pendingClan.RequestId = reqeuest;
pendingClan.Member1 = new Pair<Client, bool>(members[0], false);
pendingClan.Member2 = new Pair<Client, bool>(members[1], false);
pendingClan.Member3 = new Pair<Client, bool>(members[2], false);
pendingClan.Member4 = new Pair<Client, bool>(members[3], false);
lock (Globals.PendingClans)
Globals.PendingClans.Add(pendingClan);
ClanPackets.ResponseCreateClan(client, Results.Accepted, reqeuest);
ClanPackets.AskAgreement(members, reqeuest, clanName, client.GetMuid(), client.GetCharacter().Name);
var responsetimer = new Timer(30000);
responsetimer.Elapsed += (s, o) => CancelRequest(client, pendingClan, responsetimer);
responsetimer.Start();
}
public static void ProcessStageJoin(Client client, PacketReader packetReader)
{
var uidChar = packetReader.ReadMuid();
var uidStage = packetReader.ReadMuid();
var stage = client.GetChannel().Find(uidStage);
if (stage == null)
{
Log.Write("Failed to join stage: {0}", uidStage.HighId);
return;
}
stage.Join(client);
}
public static void ProcessExpelMember(Client client, PacketReader packetReader)
{
if (client.GetCharacter().ClanId < 1 || client.GetCharacter().ClanGrade == ClanGrade.User)
return;
var sender = packetReader.ReadMuid();
var member = packetReader.ReadString();
Client memberClient = TcpServer.GetClientFromName(member);
if (memberClient != null)
{
if (memberClient.GetCharacter().ClanGrade == ClanGrade.Master || (memberClient.GetCharacter().ClanGrade == ClanGrade.Admin && client.GetCharacter().ClanGrade == ClanGrade.Admin))
{
ClanPackets.ExpelMemberNotAllowed(client);
return;
}
memberClient.GetCharacter().ClanName = string.Empty;
memberClient.GetCharacter().ClanId = 0;
memberClient.GetCharacter().ClanGrade = ClanGrade.None;
ClanPackets.SendMemberList(memberClient);
ClanPackets.UpdateClanCharInfo(memberClient);
Globals.GunzDatabase.ExpelMember(memberClient.GetCharacter().CharacterId);
}
using (var expelMember = new PacketWriter(Operation.MatchClanAdminResponseLeaveMember, CryptFlags.Encrypt))
{
expelMember.Write(0);
client.Send(expelMember);
}
}
public static void ProcessStageSetting(Client client, PacketReader packetReader)
{
if (client.GetStage() == null)
return;
var stage = client.GetStage().GetTraits();
var uidChar = packetReader.ReadMuid();
var uidStage = packetReader.ReadMuid();
var total = packetReader.ReadInt32();
var size = packetReader.ReadInt32();
var count = packetReader.ReadInt32();
var uidStage2 = packetReader.ReadMuid();
var map = packetReader.ReadString(32);
var index = packetReader.ReadInt32();
var type = packetReader.ReadInt32();
var rounds = packetReader.ReadInt32();
var time = packetReader.ReadInt32();
var level = packetReader.ReadInt32();
var players = packetReader.ReadInt32();
var teamkill = packetReader.ReadBoolean();
var balance = packetReader.ReadBoolean();
var join = packetReader.ReadBoolean();
var win = packetReader.ReadBoolean();
if ((ObjectStageGameType)type != stage.Gametype)
{
if (!Enum.IsDefined(typeof(ObjectStageGameType), (byte)type))
{
client.Disconnect();
return;
}
stage.Gametype = (ObjectStageGameType)type;
}
switch ((ObjectStageGameType)type)
{
case ObjectStageGameType.DeathMatch:
stage.Ruleset = new Deathmatch(client.GetStage());
break;
case ObjectStageGameType.Berserker:
stage.Ruleset = new Berserker(client.GetStage());
break;
case ObjectStageGameType.Duel:
stage.Ruleset = new Duel(client.GetStage());
break;
case ObjectStageGameType.Gladiator:
stage.Ruleset = new Deathmatch(client.GetStage());
break;
case ObjectStageGameType.Training:
stage.Ruleset = new Deathmatch(client.GetStage());
break;
case ObjectStageGameType.TeamDeathMatch:
stage.Ruleset = new TeamDeathmatch(client.GetStage());
break;
case ObjectStageGameType.TeamGladiator:
stage.Ruleset = new TeamDeathmatch(client.GetStage());
break;
case ObjectStageGameType.Assassination:
stage.Ruleset = new Assassination(client.GetStage());
break;
case ObjectStageGameType.TeamDeathMatchExtreme:
stage.Ruleset = new TeamDeathmatchExtreme(client.GetStage());
break;
default:
Log.Write("Unknown ruleset: {0}", type);
stage.Ruleset = new Deathmatch(client.GetStage());
break;
}
stage.RoundCount = rounds;
stage.Time = time > Byte.MaxValue ? (byte)0 : Convert.ToByte(time);
stage.Level = Convert.ToByte(level);
stage.MaxPlayers = Convert.ToByte(players);
stage.ForcedEntry = join;
stage.TeamBalanced = balance;
stage.TeamKill = teamkill;
if ((ObjectStageGameType)type == ObjectStageGameType.Duel && type != stage.Type)
{
stage.CurrentMap = Globals.Maps.GetMap("Hall");
stage.Map = "Hall";
}
else
{
stage.Type = type;
}
client.GetStage().Settings(client, true);
Channel.Refresh(client);
}
public static void ProcessJoinClan(Client client, PacketReader packetReader)
{
var uidChar = packetReader.ReadMuid();
var clanName = packetReader.ReadString();
var memberName = packetReader.ReadString();
var target = TcpServer.GetClientFromName(memberName);
if (target == null)
{
ClanPackets.ResponseJoin(client, Results.FriendNotOnline);
return;
}
if (!Globals.AcceptedString.IsMatch(memberName))
{
Log.Write("Clan regex fail.");
ClanPackets.ResponseJoin(client, Results.FriendNotOnline);
return;
}
if (Globals.GunzDatabase.IsInClan(target))
{
ClanPackets.ResponseJoin(client, Results.ClanUserAlreadyInAClan);
return;
}
ClanPackets.ResponseJoin(client, Results.Accepted);
ClanPackets.RequestJoin(client, target, clanName);
}
public static void ResponseSpawnWorldItem(Client client, PacketReader packet)
{
var charId = packet.ReadMuid();
var itemId = packet.ReadInt32();
var X = packet.ReadSingle();
var Y = packet.ReadSingle();
var Z = packet.ReadSingle();
var spawn = new ItemSpawn();
spawn.Position.X = X;
spawn.Position.Y = Y;
spawn.Position.Z = Z;
spawn.ItemId = (ushort)itemId;
spawn.Taken = false;
spawn.ItemUid = client.GetStage().GetTraits().WorldItemUid;
spawn.NextSpawn = DateTime.Now.AddMilliseconds(WorldItemManager.GetTime(itemId));
Interlocked.Increment(ref client.GetStage().GetTraits().WorldItemUid);
lock (client.GetStage().GetTraits().WorldItems)
client.GetStage().GetTraits().WorldItems.Add(spawn);
lock (client.GetStage().ObjectLock)
Battle.SpawnWorldItem(client.GetStage().GetTraits().Players,
spawn);
}
public static void ProcessPromoteMember(Client client, PacketReader packetReader)
{
if (client.GetCharacter().ClanId < 1 || client.GetCharacter().ClanGrade != ClanGrade.Master)
return;
var sender = packetReader.ReadMuid();
var member = packetReader.ReadString();
var rank = packetReader.ReadInt32();
if (!Enum.IsDefined(typeof(ClanGrade), rank))
{
client.Disconnect();
return;
}
Client memberClient = TcpServer.GetClientFromName(member);
if (memberClient != null)
{
memberClient.GetCharacter().ClanGrade = (ClanGrade)rank;
Globals.GunzDatabase.UpdateMember(memberClient.GetCharacter().CharacterId, rank);
}
ClanPackets.ResponseChangeGrade(client);
ClanPackets.UpdateClanCharInfo(memberClient);
ClanPackets.SendMemberList(client);
}
public static void ResponseStageTeam(Client client, PacketReader packetReader)
{
var charId = packetReader.ReadMuid();
var stageId = packetReader.ReadMuid();
var team = packetReader.ReadInt32();
if (!Enum.IsDefined(typeof(Team), team) || client.GetStage() == null)
{
client.Disconnect();
return;
}
client.ClientPlayer.PlayerTeam = (Team) team;
client.GetStage().Team(client);
}
public static void ProcessRequestProposal(Client client, PacketReader packetReader)
{
var uid = packetReader.ReadMuid();
var mode = packetReader.ReadInt32();
var request = packetReader.ReadInt32();
var memberCount = packetReader.ReadInt32();
var totalSize = packetReader.ReadInt32();
var blobSize = packetReader.ReadInt32();
var blobCount = packetReader.ReadInt32();
List<byte[]> blob = new List<byte[]>();
if (memberCount == blobCount)
{
for (int i = 0; i < blobCount; ++i)
{
var temp = new byte[blobSize];
packetReader.Read(temp, 0, blobSize);
blob.Add(temp);
}
}
else
{
client.Disconnect();
return;
}
List<Client> requests = new List<Client>();
foreach (byte[] b in blob)
{
string s = System.Text.ASCIIEncoding.ASCII.GetString(b);
s = s.Substring(0, s.IndexOf('\0'));
requests.Add(TcpServer.GetClientFromName(s));
}
if (requests.FindAll(c => c.GetCharacter().ClanId == client.GetCharacter().ClanId).Count == memberCount)
{
List<Pair<Client, bool>> list = new List<Pair<Client, bool>>();
foreach (Client c in requests)
{
list.Add(new Pair<Client, bool>(c, false));
}
list.Add(new Pair<Client, bool>(client, true));
ClanPackets.AskAgreement(requests, client, mode, request);
ClanPackets.ResponseProposal(client, 0, mode, request);
PendingClanWarRequest pc = new PendingClanWarRequest();
pc.RequestId = request;
pc.Players = list;
pc.ClanName = client.GetCharacter().ClanName;
pc.Requester = client;
pc.RequestMode = mode;
lock(Globals.PendingClanWar)
Globals.PendingClanWar.Add(pc);
var responsetimer = new Timer(30000);
responsetimer.Elapsed += (s, o) => CancelClanWarRequest(client, pc, responsetimer);
responsetimer.Start();
}
}
