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); }