public static void ResponseChannelList(Client pClient, PacketReader pPacket)
{
var uid = pPacket.ReadUInt64();
var type = pPacket.ReadInt32();
if (!Enum.IsDefined(typeof(MMatchChannelType), (byte)type))
{
pClient.Disconnect();
return;
}
List<MMatchChannel> channels = Program.mChannels.FindAll (c => c.nChannelType == (MMatchChannelType)type);
if (channels == null || channels.Count == 0)
return;
PacketWriter pChannelList = new PacketWriter(Operation.ChannelList, CryptFlags.Encrypt);
pChannelList.Write(channels.Count, 88);
Int16 index = 0;
foreach (MMatchChannel c in channels)
{
pChannelList.Write(c.uidChannel);
pChannelList.Write(++index);
pChannelList.Write((Int16)c.lClients.Count);
pChannelList.Write((Int16)c.nMaxUsers);
pChannelList.Write((Int16)c.nMinLevel);
pChannelList.Write((Int16)c.nMaxLevel);
pChannelList.Write((byte)c.nChannelType);
pChannelList.Write(c.szName, 64);
pChannelList.Write(false);
pChannelList.Write((Int32)0);
}
pClient.Send(pChannelList);
}
public static void PlayerList(Client pClient)
{
PacketWriter pResonsePlayerList = new PacketWriter(Operation.ChannelResponsePlayerList, CryptFlags.Encrypt);
List<Client> clients;
var pages = Convert.ToByte(pClient.mChannel.lClients.Count / 6);
var page = Math.Min(pClient.mChannelPage, pages);
var start = page * 6;
var count = Math.Min(pClient.mChannel.lClients.Count - start, 6);
pResonsePlayerList.Write((byte)pClient.mChannel.lClients.Count);
pResonsePlayerList.Write((byte)page);
pResonsePlayerList.Write(count, 71);
clients = pClient.mChannel.lClients.GetRange(start, count);
foreach (Client c in clients)
{
pResonsePlayerList.Write(c.mClientUID);
pResonsePlayerList.Write(c.mCharacter.szName, 32);
pResonsePlayerList.Write(c.mCharacter.szClanName, 16);
pResonsePlayerList.Write((byte)c.mCharacter.nLevel);
pResonsePlayerList.Write((Int32)c.mPlace);
pResonsePlayerList.Write((byte)c.mAccount.nUGradeID);
pResonsePlayerList.Write((byte)2);
pResonsePlayerList.Write(c.mCharacter.nCLID);
pResonsePlayerList.Write((Int32)0);
}
pClient.Send(pResonsePlayerList);
}
public static void Join(Client pClient, MMatchChannel pChannel)
{
Leave(pClient);
lock (pChannel.lClients)
pChannel.lClients.Add(pClient);
pClient.mPlace = MMatchPlace.Lobby;
pClient.mChannel = pChannel;
PacketWriter pPacket = new PacketWriter(Operation.ChannelResponseJoin, CryptFlags.Encrypt);
pPacket.Write(pChannel.uidChannel);
pPacket.Write((Int32)pChannel.nChannelType);
pPacket.Write(pChannel.szName);
pPacket.Write(true);
pClient.Send(pPacket);
pPacket = new PacketWriter(Operation.MatchResponseRuleset, CryptFlags.Encrypt);
pPacket.Write(pChannel.uidChannel);
pPacket.Write(pChannel.nChannelRule.ToString().ToLower());
pClient.Send(pPacket);
foreach (Client c in pChannel.lClients)
{
PlayerList(c);
}
}
public static void ProcessLiveCheck(Client pClient, PacketReader pPacket)
{
var timeStamp = pPacket.ReadInt32();
PacketWriter pResponseLiveCheck = new PacketWriter(Operation.MatchAgentResponseLiveCheck, CryptFlags.Encrypt);
pResponseLiveCheck.Write(timeStamp);
pClient.Send(pResponseLiveCheck);
}
public static void ProcessRegisterAgent(Client pClient, PacketReader pPacket)
{
pClient.mIsAgent = true;
Log.Write("[{0}] Agent Registered.", pClient.mClientIP);
lock (Program.mAgents)
Program.mAgents.Add(pClient);
}
public static void ForceLeave(Client pClient)
{
if (pClient.mStage == null)
return;
MMatchStage stage = pClient.mStage;
pClient.mStage = null;
pClient.mClientFlags = PacketFlags.Character;
pClient.mPlace = MMatchPlace.Lobby;
PacketWriter pPacket = new PacketWriter(Operation.StageLeave, CryptFlags.Encrypt);
pPacket.Write(pClient.mClientUID);
foreach (Client c in stage.Clients)
{
if (pClient == c) continue;
c.Send(pPacket);
}
lock (stage)
{
stage.Clients.Remove(pClient);
if (stage.Clients.Count == 0)
{
lock (pClient.mChannel.lStages)
pClient.mChannel.lStages.Remove(stage);
StageList(pClient);
return;
}
}
UpdateStageCache(stage, pClient, ObjectCache.New);
stage.stageMaster = stage.Clients[0];
UpdateMaster(stage);
}
public static void ResponseChannelJoinFromName(Client pClient, PacketReader pPacket)
{
var uid = pPacket.ReadUInt64();
var type = pPacket.ReadInt32();
var name = pPacket.ReadString();
if (!Enum.IsDefined(typeof(MMatchChannelType), (byte)type))
{
pClient.Disconnect();
return;
}
MMatchChannel channel = Program.mChannels.Find(c => c.nChannelType == (MMatchChannelType)type && c.szName.Equals(name));
if (channel == null)
{
channel = new MMatchChannel();
channel.szName = name;
channel.lClients = new List<Client>();
channel.nChannelRule = MMatchChannelRule.Elite;
channel.nChannelType = (MMatchChannelType)type;
channel.nMaxLevel = 100;
channel.nMinLevel = 0;
channel.nMaxUsers = 200;
channel.uidChannel = (UInt64)Program.mChannels.Count;
lock (Program.mChannels)
Program.mChannels.Add(channel);
}
ChannelMgr.Join(pClient, channel);
}
public static void ProcessBuyItem(Client pClient, PacketReader pPacket)
{
var uid = pPacket.ReadUInt64();
var itemid = pPacket.ReadInt32();
Item item = null;
var result = Results.Accepted;
item = Program.mItems.Find(i => i.nItemID == itemid);
if (item == null)
result = Results.ShopItemNonExistant;
else if (item.nPrice > pClient.mCharacter.nBP)
result = Results.ShopInsufficientBounty;
else
{
Item temp = new Item();
temp.nItemID = item.nItemID;
temp.nLevel = item.nLevel;
temp.nMaxWT = item.nMaxWT;
temp.nWeight = item.nWeight;
temp.nPrice = item.nPrice;
Database.Execute(string.Format("INSERT INTO CharacterItem (CID,ItemID,RegDate) VALUES ({0},{1},GetDate())", pClient.mCharacter.nCID, item.nItemID));
temp.nItemCID = Database.GetIdentity(string.Format("select @@identity"));
pClient.mCharacter.nItems.Add(temp);
pClient.mCharacter.nBP -= item.nPrice;
Database.Execute(string.Format("UPDATE Character SET BP={0} WHERE CID={1}", pClient.mCharacter.nBP, pClient.mCharacter.nCID));
}
PacketWriter pResponseBuyItem = new PacketWriter(Operation.MatchResponseBuyItem, CryptFlags.Decrypt);
pResponseBuyItem.Write((Int32)result);
pClient.Send(pResponseBuyItem);
}
public static void ProcessGameTimeSync(Client client, PacketReader pPacket)
{
var nTime = pPacket.ReadInt32();
PacketWriter packet = new PacketWriter(Operation.GameResponseTimeSync, CryptFlags.Encrypt);
packet.Write(nTime);
packet.Write(Program.timeGetTime());
client.Send(packet);
}
public static void ProcessCharacters(Client pClient, PacketReader pPacket)
{
pClient.UnloadCharacter();
PacketWriter pResponseChars = new PacketWriter(Operation.MatchResponseAccountCharList, CryptFlags.Encrypt);
var charCount = Database.GetQuery(string.Format("SELECT COUNT(*) FROM Character WHERE AID={0}", pClient.mAccount.nAID));
pResponseChars.Write(charCount, 34);
Database.GetCharacterList(pClient.mAccount.nAID, pResponseChars);
pClient.Send(pResponseChars);
}
public static void Chat(Client pClient, string pMessage)
{
PacketWriter pChannelChat = new PacketWriter(Operation.ChannelChat, CryptFlags.Encrypt);
pChannelChat.Write(pClient.mChannel.uidChannel);
pChannelChat.Write(pClient.mCharacter.szName);
pChannelChat.Write(pMessage);
pChannelChat.Write((Int32)pClient.mAccount.nUGradeID);
foreach (Client c in pClient.mChannel.lClients)
c.Send(pChannelChat);
}
public static void Chat(Client pClient, string pMessage)
{
PacketWriter pStageChat = new PacketWriter(Operation.StageChat, CryptFlags.Encrypt);
pStageChat.Write(pClient.mClientUID);
pStageChat.Write(pClient.mStage.uidStage);
pStageChat.Write(pMessage);
foreach (Client c in pClient.mStage.Clients)
{
c.Send(pStageChat);
}
}
public static void Join(Client pClient, MMatchStage pStage)
{
if (pStage.Clients.Count < pStage.nMaxPlayers)
{
pClient.mPlace = MMatchPlace.Stage;
pClient.mStage = pStage;
pClient.mClientFlags = PacketFlags.Stage;
lock (pStage.Clients)
pStage.Clients.Add(pClient);
PacketWriter pPacket = new PacketWriter(Operation.StageJoin, CryptFlags.Encrypt);
pPacket.Write(pClient.mClientUID);
pPacket.Write(pStage.uidStage);
pPacket.Write(Convert.ToInt32(pClient.mChannel.lStages.IndexOf(pStage) + 1));
pPacket.Write(pStage.szName);
foreach (Client c in pStage.Clients)
c.Send(pPacket);
pPacket = new PacketWriter(Operation.MatchObjectCache, CryptFlags.Encrypt);
pPacket.Write((byte)ObjectCache.Expire);
pPacket.Write(pStage.Clients.Count, 152);
foreach (Client c in pStage.Clients)
{
pPacket.Write((Int32)0);
pPacket.Write(c.mClientUID);
pPacket.Write(c.mCharacter.szName, 32);
pPacket.Write(c.mCharacter.szClanName, 16);
pPacket.Write((Int32)c.mCharacter.nLevel);
pPacket.Write((Int32)c.mAccount.nUGradeID);
pPacket.Write((Int32)0);
pPacket.Write((Int32)0);
pPacket.Write((Int32)0);//CLID
pPacket.Write((Int32)0);//Emblem
pPacket.Write((Int32)c.mCharacter.nSex);
pPacket.Write((byte)c.mCharacter.nHair);
pPacket.Write((byte)c.mCharacter.nFace);
pPacket.Write((Int16)0);
foreach (Item i in c.mCharacter.nEquippedItems)
pPacket.Write(i.nItemID);
pPacket.Write((Int32)1);
pPacket.Write((Int32)5);
pPacket.Write((Int32)25);
}
pClient.Send(pPacket);
UpdateStageCache(pStage, pClient, ObjectCache.Keep);
UpdateMaster(pStage);
}
StageList(pClient);
}
public static void ResponseChannelChat(Client pClient, PacketReader pPacket)
{
var uidChar = pPacket.ReadUInt64();
var uidChan = pPacket.ReadUInt64();
var message = pPacket.ReadString();
if (uidChar != pClient.mClientUID || uidChan != pClient.mChannel.uidChannel || message.Length > 127)
{
pClient.Disconnect();
return;
}
ChannelMgr.Chat(pClient, message);
}
public static void ResponseChannelJoin(Client pClient, PacketReader pPacket)
{
var uidChar = pPacket.ReadUInt64();
var uidChan = pPacket.ReadUInt64();
if (uidChar != pClient.mClientUID)
{
pClient.Disconnect();
return;
}
MMatchChannel channel = Program.mChannels.Find(c => c.uidChannel == uidChan);
if (channel != null)
ChannelMgr.Join(pClient, channel);
}
public static void ProcessCharInfo(Client pClient, PacketReader pReader)
{
var index = pReader.ReadByte();
if (index < 0 || index > 4)
{
pClient.Disconnect();
return;
}
pClient.mCharacter.nCharNum = index;
Database.GetCharacter(pClient.mAccount.nAID, index, pClient.mCharacter);
pClient.mCharacter.nUGradeID = pClient.mAccount.nUGradeID;
PacketWriter pCharInfoResponse = new PacketWriter(Operation.MatchResponseAccountCharInfo, CryptFlags.Encrypt);
pCharInfoResponse.Write(index);
pCharInfoResponse.Write(pClient.mCharacter);
pClient.Send(pCharInfoResponse);
}
public static void ProcessGameSpawn(Client client, PacketReader pPacket)
{
var uid = pPacket.ReadUInt64();
var xpos = pPacket.ReadSingle();
var ypos = pPacket.ReadSingle();
var zpos = pPacket.ReadSingle();
var xdir = pPacket.ReadSingle();
var ydir = pPacket.ReadSingle();
var zdir = pPacket.ReadSingle();
PacketWriter packet = new PacketWriter(Operation.GameResponseSpawn, CryptFlags.Encrypt);
packet.Write(client.mClientUID);
packet.Write((UInt16)xpos);
packet.Write((UInt16)ypos);
packet.Write((UInt16)zpos);
packet.Write((UInt16)xdir);
packet.Write(new byte[] { 0xfc, 0xc7 }, 0, 2);
packet.Write((UInt16)ydir);
foreach (Client c in client.mStage.Clients)
c.Send(packet);
}
public static void ProcessBattleInfo(Client pClient, PacketReader pPacket)
{
MMatchStage stage = pClient.mStage;
PacketWriter packet = new PacketWriter(Operation.BattleResponseInfo, CryptFlags.Encrypt);
packet.Write(stage.uidStage);
packet.Write(1,6);
packet.Write(stage.nRedTeamScore);
packet.Write(stage.nBlueTeamScore);
packet.Write((Int32)0);
packet.Write(0, 0);
packet.Write(stage.Clients.Count, 17);
foreach (Client c in stage.Clients)
{
packet.Write(c.mClientUID);
packet.Write(c.mGame.Spawned);
packet.Write(c.mGame.Kills);
packet.Write(c.mGame.Deaths);
}
pClient.Send(packet);
stage.BattleMgr.GameInfoCallback(pClient);
}
public static void Leave(Client pClient)
{
if (pClient.mChannel == null)
return;
lock (pClient.mChannel.lClients)
pClient.mChannel.lClients.Remove(pClient);
PacketWriter pChannelLeave = new PacketWriter(Operation.ChannelLeave, CryptFlags.Encrypt);
pChannelLeave.Write(pClient.mClientUID);
pChannelLeave.Write(pClient.mChannel.uidChannel);
pClient.Send(pChannelLeave);
foreach (Client c in pClient.mChannel.lClients)
PlayerList(c);
if (pClient.mChannel.lClients.Count == 0 && (pClient.mChannel.nChannelType == MMatchChannelType.Private || pClient.mChannel.nChannelType == MMatchChannelType.Clan))
lock (Program.mChannels)
Program.mChannels.Remove(pClient.mChannel);
pClient.mChannel = null;
}
public static void ProcessCharItemList(Client pClient, PacketReader pPacket)
{
PacketWriter pResponseCharItems = new PacketWriter(Operation.MatchResponseCharacterItemList, CryptFlags.Decrypt);
pResponseCharItems.Write(pClient.mCharacter.nBP);
pResponseCharItems.Write(12, 8);
for (int i = 0; i < 12; ++i)
{
pResponseCharItems.Write((Int32)0);
pResponseCharItems.Write(pClient.mCharacter.nEquippedItems[i].nItemCID);
}
pResponseCharItems.Write(pClient.mCharacter.nItems.Count, 16);
foreach (Item i in pClient.mCharacter.nItems)
{
pResponseCharItems.Write((Int32)0);
pResponseCharItems.Write(i.nItemCID);
pResponseCharItems.Write(i.nItemID);
pResponseCharItems.Write(i.nRentHour);
}
pResponseCharItems.Write(0, 12);
pClient.Send(pResponseCharItems);
}
public static void UpdateTeam(Client client)
{
PacketWriter pPacket = new PacketWriter(Operation.StageTeam, CryptFlags.Encrypt);
pPacket.Write(client.mClientUID);
pPacket.Write(client.mStage.uidStage);
pPacket.Write((Int32)client.mTeam);
foreach (Client c in client.mStage.Clients)
c.Send(pPacket);
}
public static void ProcessTakeOffItem(Client pClient, PacketReader pPacket)
{
var uidChar = pPacket.ReadUInt64();
var nItemSlot = pPacket.ReadInt32();
if (!Enum.IsDefined(typeof(MMatchItemSlotType), nItemSlot))
{
pClient.Disconnect();
return;
}
pClient.mCharacter.nEquippedItems[nItemSlot].nItemCID = 0;
pClient.mCharacter.nEquippedItems[nItemSlot].nItemID = 0;
Database.Execute(string.Format("UPDATE Character SET {0}={1} WHERE CID={2}", (MMatchItemSlotType)nItemSlot, 0, pClient.mCharacter.nCID));
PacketWriter pResponseTakeOffItem = new PacketWriter(Operation.MatchResponseTakeOffItem, CryptFlags.Decrypt);
pResponseTakeOffItem.Write((Int32)0);
pClient.Send(pResponseTakeOffItem);
ProcessCharItemList(pClient, null);
}
public static void UpdateStageCache(MMatchStage stage, Client client, ObjectCache cache)
{
PacketWriter pPacket = new PacketWriter(Operation.MatchObjectCache, CryptFlags.Encrypt);
pPacket.Write((byte)cache);
pPacket.Write(1, 140);
pPacket.Write((Int32)0);
pPacket.Write(client.mClientUID);
pPacket.Write(client.mCharacter.szName, 32);
pPacket.Write(client.mCharacter.szClanName, 16);
pPacket.Write(Convert.ToInt32(client.mCharacter.nLevel));
pPacket.Write((Int32)client.mAccount.nUGradeID);
pPacket.Write((Int32)0);
pPacket.Write((Int32)0);
pPacket.Write(client.mCharacter.nCLID);
pPacket.Write((Int32)0);//Emblem
pPacket.Write((Int32)client.mCharacter.nSex);
pPacket.Write((byte)client.mCharacter.nHair);
pPacket.Write((byte)client.mCharacter.nFace);
pPacket.Write((Int16)0);
foreach (Item i in client.mCharacter.nEquippedItems)
pPacket.Write(i.nItemID);
lock (stage.Clients)
{
foreach (Client c in stage.Clients)
{
if (c == client) continue;
c.Send(pPacket);
}
}
}
public static void UpdateSetting(Client client)
{
if (client.mStage == null)
return;
MMatchStage stage = client.mStage;
PacketWriter packet = new PacketWriter(Operation.StageResponseSettings, CryptFlags.Encrypt);
packet.Write(stage.uidStage);
packet.Write(1, 68);
packet.Write(stage.uidStage);
packet.Write(stage.szMap, 32);
packet.Write((Int32)0);
packet.Write((Int32)stage.nGameType);
packet.Write((Int32)stage.nRounds);
packet.Write((Int32)stage.nTime);
packet.Write((Int32)stage.nLevel);
packet.Write((Int32)stage.nMaxPlayers);
packet.Write(stage.bTeamKill);
packet.Write(stage.bTeamWinThePoint);
packet.Write(stage.bForcedEntry);
packet.Write(stage.bTeamBalance);
packet.Write(stage.Clients.Count, 16);
foreach (Client c in stage.Clients)
{
packet.Write(c.mClientUID);
packet.Write((Int32)c.mTeam);
packet.Write((Int32)c.mState);
}
packet.Write((Int32)stage.nStageState);
packet.Write(client.mClientUID);
foreach (Client c in stage.Clients)
{
c.Send(packet);
}
UpdateMaster(stage);
}
public static void StageList(Client pClient)
{
List<MMatchStage> stages = null;
MMatchChannel pChannel = pClient.mChannel;
PacketWriter pPacket = new PacketWriter(Operation.StageList, CryptFlags.Encrypt);
byte curr = Convert.ToByte(Math.Min(8, Math.Max(0, pChannel.lStages.Count - pClient.mStageIndex)));
byte prev = Convert.ToByte(Math.Min(8, Math.Max(0, pChannel.lStages.Count - Math.Max(0, pClient.mStageIndex - 8))));
byte next = Convert.ToByte(Math.Min(8, Math.Max(0, pChannel.lStages.Count - (pClient.mStageIndex + 8))));
pPacket.Write(prev);
pPacket.Write(next);
pPacket.Write(curr, 0x5A);
if (curr > 0) stages = pChannel.lStages.GetRange(pClient.mStageIndex, curr);
if (stages != null)
{
byte index = pClient.mStageIndex;
foreach (MMatchStage stage in stages)
{
pPacket.Write(stage.uidStage);
pPacket.Write(++index);
pPacket.Write(stage.szName, 64);
pPacket.Write(Convert.ToByte(stage.Clients.Count));
pPacket.Write(stage.nMaxPlayers);
pPacket.Write((Int32)stage.nStageState);
pPacket.Write((Int32)stage.nGameType);
pPacket.Write((byte)0);
Int32 nSettings = 0;
if (stage.bForcedEntry) nSettings = 1;
if (stage.szPassword.Length > 0) nSettings += 2;
pPacket.Write(nSettings);
pPacket.Write(Convert.ToByte(stage.stageMaster.mCharacter.nLevel));
pPacket.Write(stage.nLevel);
}
}
foreach (Client c in pChannel.lClients)
c.Send(pPacket);
}
public static void ProcessShopItemList(Client pClient, PacketReader pPacket)
{
PacketWriter pResponseShop = new PacketWriter(Operation.MatchResponseShopItemList, CryptFlags.Decrypt);
pResponseShop.Write(1, 12);
pResponseShop.WriteSkip(12);
pResponseShop.Write(Program.mShop.Count, 4);
foreach (uint item in Program.mShop)
pResponseShop.Write(item);
pClient.Send(pResponseShop);
}
public static void Remove(Client pClient)
{
lock (mClients)
mClients.Remove(pClient);
}
public static void ProcessEnterBattle(Client pClient, PacketReader pPacket)
{
if (pClient.mStage == null) return;
pClient.mStage.BattleMgr.GameEnterCalback(pClient);
}
public static void ProcessLoading(Client pClient, PacketReader pPacket)
{
if (pClient.mStage == null) return;
pClient.mStage.BattleMgr.GameLoadedCallback(pClient);
}
public static void ResponsePlayerList(Client pClient, PacketReader pPacket)
{
var uidChar = pPacket.ReadUInt64();
var uidChan = pPacket.ReadUInt64();
var page = pPacket.ReadInt32();
if (uidChar != pClient.mClientUID || uidChan != pClient.mChannel.uidChannel)
{
pClient.Disconnect();
return;
}
pClient.mChannelPage = page;
ChannelMgr.PlayerList(pClient);
}
