Exemplo n.º 1
0
        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);
        }
Exemplo n.º 2
0
        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);
        }
Exemplo n.º 3
0
        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);
            }
        }
Exemplo n.º 4
0
 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);
 }
Exemplo n.º 5
0
 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);
 }
Exemplo n.º 6
0
        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);
        }
Exemplo n.º 7
0
        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);
        }
Exemplo n.º 8
0
        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);
        }
Exemplo n.º 9
0
        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);
        }
Exemplo n.º 10
0
        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);
        }
Exemplo n.º 11
0
        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);
        }
Exemplo n.º 12
0
        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);
            }
        }
Exemplo n.º 13
0
        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);
        }
Exemplo n.º 14
0
        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);
        }
Exemplo n.º 15
0
        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);
        }
Exemplo n.º 16
0
        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);
        }
Exemplo n.º 17
0
        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);
        }
Exemplo n.º 18
0
        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);
        }
Exemplo n.º 19
0
        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;
        }
Exemplo n.º 20
0
        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);
        }
Exemplo n.º 21
0
        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);
        }
Exemplo n.º 22
0
        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);
        }
Exemplo n.º 23
0
        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);
                }
            }
        }
Exemplo n.º 24
0
        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);
        }
Exemplo n.º 25
0
        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);
        }
Exemplo n.º 26
0
        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);
        }
Exemplo n.º 27
0
 public static void Remove(Client pClient)
 {
     lock (mClients)
         mClients.Remove(pClient);
 }
Exemplo n.º 28
0
 public static void ProcessEnterBattle(Client pClient, PacketReader pPacket)
 {
     if (pClient.mStage == null) return;
     pClient.mStage.BattleMgr.GameEnterCalback(pClient);
 }
Exemplo n.º 29
0
 public static void ProcessLoading(Client pClient, PacketReader pPacket)
 {
     if (pClient.mStage == null) return;
     pClient.mStage.BattleMgr.GameLoadedCallback(pClient);
 }
Exemplo n.º 30
0
        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);
        }