public bool HandleCommand(TankMarryLogicProcessor process, GamePlayer player, GSPacketIn packet)
        {
            if (player.CurrentMarryRoom == null || player.CurrentMarryRoom.RoomState != eRoomState.FREE)
            {
                return(false);
            }
            if (!player.CurrentMarryRoom.Info.GuestInvite && player.PlayerCharacter.ID != player.CurrentMarryRoom.Info.GroomID && player.PlayerCharacter.ID != player.CurrentMarryRoom.Info.BrideID)
            {
                return(false);
            }
            GSPacketIn gSPacketIn = packet.Clone();

            gSPacketIn.ClearContext();
            int        playerId   = packet.ReadInt();
            GamePlayer playerById = WorldMgr.GetPlayerById(playerId);

            if (playerById != null && playerById.CurrentRoom == null && playerById.CurrentMarryRoom == null)
            {
                gSPacketIn.WriteByte(4);
                gSPacketIn.WriteInt(player.PlayerCharacter.ID);
                gSPacketIn.WriteString(player.PlayerCharacter.NickName);
                gSPacketIn.WriteInt(player.CurrentMarryRoom.Info.ID);
                gSPacketIn.WriteString(player.CurrentMarryRoom.Info.Name);
                gSPacketIn.WriteString(player.CurrentMarryRoom.Info.Pwd);
                gSPacketIn.WriteInt(player.MarryMap);
                playerById.Out.SendTCP(gSPacketIn);
                return(true);
            }
            return(false);
        }
Beispiel #2
0
        public override int HandlePacket(GamePlayer player, GSPacketIn packet)
        {
            ItemInfo item = player.PropBag.GetItemByCategoryID(0, 11, 4);

            if (item != null)
            {
                player.PropBag.RemoveCountFromStack(item, 1, eItemRemoveType.Use);
                player.OnUsingItem(item.TemplateID);
                int        senderID   = packet.ReadInt();
                string     senderName = packet.ReadString();
                string     msg        = packet.ReadString();
                GSPacketIn pkg        = packet.Clone();
                pkg.ClearContext();
                pkg.ClientID = player.PlayerCharacter.ID;
                pkg.WriteInt(player.PlayerCharacter.ID);
                pkg.WriteString(player.PlayerCharacter.NickName);
                pkg.WriteString(msg);
                GamePlayer[] players = WorldMgr.GetAllPlayers();
                GamePlayer[] array   = players;
                for (int i = 0; i < array.Length; i++)
                {
                    GamePlayer p = array[i];
                    p.Out.SendTCP(pkg);
                }
            }
            return(0);
        }
Beispiel #3
0
        private void HandlePlayerMessage(GSPacketIn pkg)
        {
            BaseGame game = GameMgr.FindGame(pkg.ClientID);

            if (game != null)
            {
                Player player = game.FindPlayer(pkg.ReadInt());
                bool   team   = pkg.ReadBoolean();
                byte   channl = pkg.ReadByte();
                string msg    = pkg.ReadString();
                if (player != null)
                {
                    GSPacketIn pkg2 = new GSPacketIn(19);
                    pkg2.ClientID = player.PlayerDetail.PlayerCharacter.ID;
                    pkg2.WriteInt(player.PlayerDetail.AreaID);
                    pkg2.WriteByte(channl);
                    pkg2.WriteBoolean(team);
                    pkg2.WriteString(player.PlayerDetail.PlayerCharacter.NickName);
                    pkg2.WriteString(msg);
                    if (team)
                    {
                        game.SendToTeam(pkg2, player.Team, player.PlayerDetail);
                    }
                    else
                    {
                        game.SendToAll(pkg2);
                    }
                }
            }
        }
Beispiel #4
0
        internal void SendAddPhysicalObj(PhysicalObj obj)
        {
            GSPacketIn pkg = new GSPacketIn((byte)ePackageType.GAME_CMD);

            pkg.WriteByte((byte)eTankCmdType.ADD_BOX);

            pkg.WriteInt(obj.Id);
            pkg.WriteInt(obj.Type);
            pkg.WriteInt(obj.X);
            pkg.WriteInt(obj.Y);
            pkg.WriteString(obj.Model);
            pkg.WriteString(obj.CurrentAction);
            pkg.WriteInt(obj.Scale);
            pkg.WriteInt(obj.Scale);
            pkg.WriteInt(obj.Rotation);
            pkg.WriteInt(0);
            pkg.WriteInt(0);

            //var id:int = evt.pkg.readInt();
            //var type:int =  evt.pkg.readInt();
            //var px:int = evt.pkg.readInt();
            //var py:int = evt.pkg.readInt();
            //var model:String = evt.pkg.readUTF();
            //var action:String = evt.pkg.readUTF();
            //var pscaleX:int = evt.pkg.readInt();
            //var pscaleY:int = evt.pkg.readInt();
            //var protation:int = evt.pkg.readInt();
            //var layer:int = evt.pkg.readInt();

            SendToAll(pkg);
        }
Beispiel #5
0
        private void HandlePlayerMessage(GSPacketIn pkg)
        {
            BaseGame game = GameMgr.FindGame(pkg.ClientID);

            if (game != null)
            {
                Player player = game.FindPlayer(pkg.ReadInt());
                bool   team   = pkg.ReadBoolean();
                string msg    = pkg.ReadString();
                if (player != null)
                {
                    GSPacketIn pkg1 = new GSPacketIn((byte)eFightPackageType.CHAT);
                    pkg1.ClientID = player.PlayerDetail.PlayerCharacter.ID;
                    pkg1.WriteByte(5);
                    pkg1.WriteBoolean(false);
                    pkg1.WriteString(player.PlayerDetail.PlayerCharacter.NickName);
                    pkg1.WriteString(msg);
                    if (team)
                    {
                        game.SendToTeam(pkg, player.Team);
                    }
                    else
                    {
                        game.SendToAll(pkg1);
                    }
                }
            }
        }
        public override int HandlePacket(GamePlayer player, GSPacketIn packet)
        {
            GSPacketIn pkg = packet.Clone();

            pkg.ClearContext();
            byte page  = packet.ReadByte();
            byte count = packet.ReadByte();

            GamePlayer[] players = WorldMgr.GetAllPlayersNoGame();
            int          total   = players.Length;
            byte         length  = (total > (int)count) ? count : ((byte)total);

            pkg.WriteByte(length);
            for (int i = (int)(page * count); i < (int)(page * count + length); i++)
            {
                PlayerInfo info = players[i % total].PlayerCharacter;
                pkg.WriteInt(info.ID);
                pkg.WriteString((info.NickName == null) ? "" : info.NickName);
                pkg.WriteBoolean(info.Sex);
                pkg.WriteInt(info.Grade);
                pkg.WriteInt(info.ConsortiaID);
                pkg.WriteString((info.ConsortiaName == null) ? "" : info.ConsortiaName);
                pkg.WriteInt(info.Offer);
                pkg.WriteInt(info.Win);
                pkg.WriteInt(info.Total);
                pkg.WriteInt(info.Escape);
                pkg.WriteInt(info.Repute);
                pkg.WriteInt(info.FightPower);
            }
            player.Out.SendTCP(pkg);
            return(0);
        }
        public int HandlePacket(GameClient client, GSPacketIn packet)
        {
            ItemInfo itemByCategoryID = client.Player.PropBag.GetItemByCategoryID(0, 11, 4);

            if (itemByCategoryID != null)
            {
                client.Player.PropBag.RemoveCountFromStack(itemByCategoryID, 1);
                packet.ReadInt();
                packet.ReadString();
                string str = packet.ReadString();
                if (DateTime.Compare(client.Player.LastChatTime.AddSeconds(15.0), DateTime.Now) > 0)
                {
                    client.Out.SendMessage(eMessageType.ChatERROR, LanguageMgr.GetTranslation("Quá nhiều thao tác!", new object[0]));
                    return(1);
                }
                GSPacketIn gSPacketIn = new GSPacketIn(71);
                gSPacketIn.WriteInt(client.Player.PlayerCharacter.ID);
                gSPacketIn.WriteString(client.Player.PlayerCharacter.NickName);
                gSPacketIn.WriteString(str);
                GameServer.Instance.LoginServer.SendPacket(gSPacketIn);
                client.Player.LastChatTime = DateTime.Now;
                GamePlayer[] allPlayers = WorldMgr.GetAllPlayers();
                for (int i = 0; i < allPlayers.Length; i++)
                {
                    GamePlayer gamePlayer = allPlayers[i];
                    gSPacketIn.ClientID = gamePlayer.PlayerCharacter.ID;
                    gamePlayer.Out.SendTCP(gSPacketIn);
                }
            }
            return(0);
        }
Beispiel #8
0
        public int HandlePacket(GameClient client, GSPacketIn packet)
        {
            GSPacketIn pkg             = new GSPacketIn(0xc6);
            PlayerInfo playerCharacter = client.Player.PlayerCharacter;

            pkg.WriteInt(playerCharacter.ID);
            pkg.WriteInt(playerCharacter.Grade);
            pkg.WriteInt(playerCharacter.Hide);
            pkg.WriteInt(playerCharacter.Repute);
            pkg.WriteString(playerCharacter.NickName);
            pkg.WriteBoolean(true);
            pkg.WriteInt(5);
            pkg.WriteBoolean(playerCharacter.Sex);
            pkg.WriteString(playerCharacter.Style);
            pkg.WriteString(playerCharacter.Colors);
            pkg.WriteString(playerCharacter.Skin);
            pkg.WriteInt(300);
            pkg.WriteInt(400);
            pkg.WriteInt(playerCharacter.FightPower);
            pkg.WriteInt(playerCharacter.Win);
            pkg.WriteInt(playerCharacter.Total);
            pkg.WriteInt(1);
            client.SendTCP(pkg);
            return(0);
        }
Beispiel #9
0
        private void HandleSysNotice(GSPacketIn pkg)
        {
            BaseGame game = GameMgr.FindGame(pkg.ClientID);

            if (game != null)
            {
                Player     player = game.FindPlayer(pkg.Parameter1);
                GSPacketIn pkg2   = new GSPacketIn(3);
                pkg2.WriteInt(3);
                pkg2.WriteString(LanguageMgr.GetTranslation("AbstractPacketLib.SendGamePlayerLeave.Msg6", new object[]
                {
                    player.PlayerDetail.PlayerCharacter.Grade * 12,
                    15
                }));
                player.PlayerDetail.SendTCP(pkg2);
                pkg2.ClearContext();
                pkg2.WriteInt(3);
                pkg2.WriteString(LanguageMgr.GetTranslation("AbstractPacketLib.SendGamePlayerLeave.Msg7", new object[]
                {
                    player.PlayerDetail.PlayerCharacter.NickName,
                    player.PlayerDetail.PlayerCharacter.Grade * 12,
                    15
                }));
                game.SendToAll(pkg2, player.PlayerDetail);
            }
        }
Beispiel #10
0
        public GSPacketIn SendMarryRoomInfoUpdateToScenePlayers(MarryRoom room)
        {
            GSPacketIn gSPacketIn = new GSPacketIn(255);
            bool       flag       = room != null;

            gSPacketIn.WriteBoolean(flag);
            if (flag)
            {
                gSPacketIn.WriteInt(room.Info.ID);
                gSPacketIn.WriteBoolean(room.Info.IsHymeneal);
                gSPacketIn.WriteString(room.Info.Name);
                gSPacketIn.WriteBoolean(!(room.Info.Pwd == ""));
                gSPacketIn.WriteInt(room.Info.MapIndex);
                gSPacketIn.WriteInt(room.Info.AvailTime);
                gSPacketIn.WriteInt(room.Count);
                gSPacketIn.WriteInt(room.Info.PlayerID);
                gSPacketIn.WriteString(room.Info.PlayerName);
                gSPacketIn.WriteInt(room.Info.GroomID);
                gSPacketIn.WriteString(room.Info.GroomName);
                gSPacketIn.WriteInt(room.Info.BrideID);
                gSPacketIn.WriteString(room.Info.BrideName);
                gSPacketIn.WriteDateTime(room.Info.BeginTime);
                gSPacketIn.WriteByte((byte)room.RoomState);
                gSPacketIn.WriteString(room.Info.RoomIntroduction);
            }
            this.SendToScenePlayer(gSPacketIn);
            return(gSPacketIn);
        }
Beispiel #11
0
        private void HandlePlayerMessage(GSPacketIn pkg)
        {
            BaseGame baseGame = GameMgr.FindGame(pkg.ClientID);

            if (baseGame != null)
            {
                Player player = baseGame.FindPlayer(pkg.ReadInt());
                bool   flag   = pkg.ReadBoolean();
                string str    = pkg.ReadString();
                if (player != null)
                {
                    GSPacketIn gSPacketIn = new GSPacketIn(19);
                    gSPacketIn.ClientID = player.PlayerDetail.PlayerCharacter.ID;
                    gSPacketIn.WriteByte(5);
                    gSPacketIn.WriteBoolean(false);
                    gSPacketIn.WriteString(player.PlayerDetail.PlayerCharacter.NickName);
                    gSPacketIn.WriteString(str);
                    if (flag)
                    {
                        baseGame.SendToTeam(pkg, player.Team);
                        return;
                    }
                    baseGame.SendToAll(gSPacketIn);
                }
            }
        }
Beispiel #12
0
        private void SendCreateGame()
        {
            GSPacketIn pkg = new GSPacketIn((byte)ePackageType.GAME_CREATE);

            pkg.WriteInt(m_map.Info.ID);
            pkg.WriteInt((byte)m_roomType);
            pkg.WriteInt((byte)m_teamType);
            pkg.WriteInt((byte)m_gameType);
            pkg.WriteInt(m_timeType);

            Player[] players = GetAllFightPlayersSafe();
            pkg.WriteInt(players.Length);
            foreach (Player p in players)
            {
                GamePlayer gp = p.PlayerDetail;
                pkg.WriteInt(p.Id);
                pkg.WriteString(gp.PlayerCharacter.NickName);
                pkg.WriteBoolean(gp.PlayerCharacter.Sex);
                pkg.WriteInt(gp.PlayerCharacter.Hide);
                pkg.WriteString(gp.PlayerCharacter.Style);
                pkg.WriteString(gp.PlayerCharacter.Colors);
                pkg.WriteString(gp.PlayerCharacter.Skin);
                pkg.WriteInt(gp.PlayerCharacter.Grade);
                pkg.WriteInt(gp.PlayerCharacter.Repute);
                pkg.WriteInt(gp.CurrentWeapon().TemplateID);
                pkg.WriteInt(gp.PlayerCharacter.ConsortiaID);
                pkg.WriteString(gp.PlayerCharacter.ConsortiaName);
                pkg.WriteInt(gp.PlayerCharacter.ConsortiaLevel);
                pkg.WriteInt(gp.PlayerCharacter.ConsortiaRepute);

                pkg.WriteInt(p.Team);
            }

            SendToAll(pkg);
        }
        public int HandlePacket(GameClient client, GSPacketIn packet)
        {
            GSPacketIn gSPacketIn = new GSPacketIn(69, client.Player.PlayerCharacter.ID);
            byte       b          = packet.ReadByte();
            byte       b2         = packet.ReadByte();

            GamePlayer[] allPlayersNoGame = WorldMgr.GetAllPlayersNoGame();
            int          num = allPlayersNoGame.Length;
            byte         b3  = (num > (int)b2) ? b2 : ((byte)num);

            gSPacketIn.WriteByte(b3);
            for (int i = (int)(b * b2); i < (int)(b * b2 + b3); i++)
            {
                PlayerInfo playerCharacter = allPlayersNoGame[i % num].PlayerCharacter;
                gSPacketIn.WriteInt(playerCharacter.ID);
                gSPacketIn.WriteString(playerCharacter.NickName);
                gSPacketIn.WriteByte(playerCharacter.typeVIP);
                gSPacketIn.WriteInt(playerCharacter.VIPLevel);
                gSPacketIn.WriteBoolean(playerCharacter.Sex);
                gSPacketIn.WriteInt(playerCharacter.Grade);
                gSPacketIn.WriteInt(playerCharacter.ConsortiaID);
                gSPacketIn.WriteString(playerCharacter.ConsortiaName);
                gSPacketIn.WriteInt(playerCharacter.Offer);
                gSPacketIn.WriteInt(playerCharacter.Win);
                gSPacketIn.WriteInt(playerCharacter.Total);
                gSPacketIn.WriteInt(playerCharacter.Escape);
                gSPacketIn.WriteInt(playerCharacter.Repute);
                gSPacketIn.WriteInt(playerCharacter.FightPower);
                gSPacketIn.WriteBoolean(playerCharacter.IsOldPlayer);
            }
            client.Out.SendTCP(gSPacketIn);
            return(0);
        }
 public void UpdateRoom(GamePlayer player)
 {
     GamePlayer[] playersSafe = this.GetPlayersSafe();
     GamePlayer[] array       = playersSafe;
     for (int i = 0; i < array.Length; i++)
     {
         GamePlayer gamePlayer = array[i];
         if (gamePlayer != player)
         {
             GSPacketIn gSPacketIn = new GSPacketIn(102);
             gSPacketIn.WriteByte(3);
             gSPacketIn.WriteInt(gamePlayer.PlayerCharacter.Grade);
             gSPacketIn.WriteInt(gamePlayer.PlayerCharacter.Hide);
             gSPacketIn.WriteInt(gamePlayer.PlayerCharacter.Repute);
             gSPacketIn.WriteInt(gamePlayer.PlayerCharacter.ID);
             gSPacketIn.WriteString(gamePlayer.PlayerCharacter.NickName);
             gSPacketIn.WriteByte(gamePlayer.PlayerCharacter.typeVIP);
             gSPacketIn.WriteInt(gamePlayer.PlayerCharacter.VIPLevel);
             gSPacketIn.WriteBoolean(gamePlayer.PlayerCharacter.Sex);
             gSPacketIn.WriteString(gamePlayer.PlayerCharacter.Style);
             gSPacketIn.WriteString(gamePlayer.PlayerCharacter.Colors);
             gSPacketIn.WriteString(gamePlayer.PlayerCharacter.Skin);
             gSPacketIn.WriteInt(gamePlayer.WorldBossX);
             gSPacketIn.WriteInt(gamePlayer.WorldBossY);
             gSPacketIn.WriteInt(gamePlayer.PlayerCharacter.FightPower);
             gSPacketIn.WriteInt(gamePlayer.PlayerCharacter.Win);
             gSPacketIn.WriteInt(gamePlayer.PlayerCharacter.Total);
             gSPacketIn.WriteInt(gamePlayer.PlayerCharacter.Offer);
             gSPacketIn.WriteByte(gamePlayer.WorldBossState);
             player.SendTCP(gSPacketIn);
         }
     }
 }
Beispiel #15
0
        public GSPacketIn SendMarryRoomInfoUpdateToScenePlayers(MarryRoom room)
        {
            GSPacketIn pkg    = new GSPacketIn((short)ePackageType.MARRY_ROOM_UPDATE);
            bool       result = room != null;

            pkg.WriteBoolean(result);
            if (result)
            {
                pkg.WriteInt(room.Info.ID);
                pkg.WriteBoolean(room.Info.IsHymeneal);
                pkg.WriteString(room.Info.Name);
                pkg.WriteBoolean(room.Info.Pwd == "" ? false : true);
                pkg.WriteInt(room.Info.MapIndex);
                pkg.WriteInt(room.Info.AvailTime);
                pkg.WriteInt(room.Count);
                pkg.WriteInt(room.Info.PlayerID);
                pkg.WriteString(room.Info.PlayerName);
                pkg.WriteInt(room.Info.GroomID);
                pkg.WriteString(room.Info.GroomName);
                pkg.WriteInt(room.Info.BrideID);
                pkg.WriteString(room.Info.BrideName);
                pkg.WriteDateTime(room.Info.BeginTime);
                pkg.WriteByte((byte)room.RoomState);
                pkg.WriteString(room.Info.RoomIntroduction);
            }

            SendToScenePlayer(pkg);
            return(pkg);
        }
Beispiel #16
0
        private void SendKeyAndName()
        {
            GSPacketIn pkg = new GSPacketIn(1);

            pkg.WriteString(AppConfig.AppSettings["CrossServerKey"]);
            pkg.WriteString(AppConfig.AppSettings["ServerName"]);
            this.SendTCP(pkg);
        }
Beispiel #17
0
        //修改:  Xiaov
        //时间:  2009-11-7
        //描述:  用户与用户之间私聊<已测试>
        public int HandlePacket(GameClient client, GSPacketIn packet)
        {
            int receiverID = packet.ReadInt();
            //int senderID = packet.ReadInt();
            string receiver    = packet.ReadString();
            string sender      = packet.ReadString();
            string msg         = packet.ReadString();
            bool   isAutoReply = packet.ReadBoolean();

            if (receiverID == 0)
            {
                using (PlayerBussiness db = new PlayerBussiness())
                {
                    PlayerInfo info = db.GetUserSingleByNickName(receiver);
                    if (info != null)
                    {
                        receiverID = info.ID;
                    }
                }
            }

            if (receiverID != 0)
            {
                GSPacketIn pkg = packet.Clone();
                pkg.ClearContext();
                pkg.WriteInt(receiverID);
                pkg.ClientID = (client.Player.PlayerCharacter.ID);
                //pkg.WriteInt(senderID);
                pkg.WriteString(receiver);
                pkg.WriteString(sender);
                pkg.WriteString(msg);
                pkg.WriteBoolean(false);

                GamePlayer player = Managers.WorldMgr.GetPlayerById(receiverID);

                if (player != null)
                {
                    if (player.IsBlackFriend(client.Player.PlayerCharacter.ID))
                    {
                        return(1);
                    }
                    player.Out.SendTCP(pkg);
                }
                else
                {
                    GameServer.Instance.LoginServer.SendPacket(pkg);
                }
                client.Out.SendTCP(pkg);
            }
            else
            {
                client.Out.SendMessage(eMessageType.ERROR, LanguageMgr.GetTranslation("UserPrivateChatHandler.NoUser"));
            }



            return(1);
        }
Beispiel #18
0
        public override int HandlePacket(GamePlayer player, GSPacketIn packet)
        {
            int result2;

            if (player.PlayerCharacter.ConsortiaID != 0)
            {
                result2 = 0;
            }
            else
            {
                int    id            = packet.ReadInt();
                bool   result        = false;
                int    consortiaID   = 0;
                string consortiaName = "";
                string msg           = "ConsortiaInvitePassHandler.Failed";
                int    tempID        = 0;
                string tempName      = "";
                using (ConsortiaBussiness db = new ConsortiaBussiness())
                {
                    int consortiaRepute    = 0;
                    ConsortiaUserInfo info = new ConsortiaUserInfo();
                    if (db.PassConsortiaInviteUsers(id, player.PlayerCharacter.ID, player.PlayerCharacter.NickName, ref consortiaID, ref consortiaName, ref msg, info, ref tempID, ref tempName, ref consortiaRepute))
                    {
                        player.PlayerCharacter.ConsortiaID   = consortiaID;
                        player.PlayerCharacter.ConsortiaName = consortiaName;
                        player.PlayerCharacter.DutyLevel     = info.Level;
                        player.PlayerCharacter.DutyName      = info.DutyName;
                        player.PlayerCharacter.Right         = info.Right;
                        ConsortiaInfo consotia = ConsortiaMgr.FindConsortiaInfo(consortiaID);
                        if (consotia != null)
                        {
                            player.PlayerCharacter.ConsortiaLevel = consotia.Level;
                        }
                        msg                = "ConsortiaInvitePassHandler.Success";
                        result             = true;
                        info.UserID        = player.PlayerCharacter.ID;
                        info.UserName      = player.PlayerCharacter.NickName;
                        info.Grade         = player.PlayerCharacter.Grade;
                        info.Offer         = player.PlayerCharacter.Offer;
                        info.RichesOffer   = player.PlayerCharacter.RichesOffer;
                        info.RichesRob     = player.PlayerCharacter.RichesRob;
                        info.Win           = player.PlayerCharacter.Win;
                        info.Total         = player.PlayerCharacter.Total;
                        info.Escape        = player.PlayerCharacter.Escape;
                        info.ConsortiaID   = consortiaID;
                        info.ConsortiaName = consortiaName;
                        GameServer.Instance.LoginServer.SendConsortiaUserPass(tempID, tempName, info, true, consortiaRepute, player.PlayerCharacter.UserName, player.PlayerCharacter.FightPower, player.PlayerCharacter.AchievementPoint, player.PlayerCharacter.Honor);
                    }
                }
                packet.WriteBoolean(result);
                packet.WriteInt(consortiaID);
                packet.WriteString(consortiaName);
                packet.WriteString(LanguageMgr.GetTranslation(msg, new object[0]));
                player.Out.SendTCP(packet);
                result2 = 0;
            }
            return(result2);
        }
Beispiel #19
0
    public void CreateRoom(byte roomType, byte timeType = 2)
    {
        this.m_lastRecv = 0;
        GSPacketIn pkg = new GSPacketIn((byte)ePackageType.GAME_ROOM_CREATE);

        pkg.WriteByte(roomType);
        pkg.WriteByte(timeType);
        pkg.WriteString("Kien dep trai!");
        pkg.WriteString("");
        this.SendTCP(pkg);
    }
Beispiel #20
0
        public void SendConsortiaUserDelete(int playerid, int consortiaID, bool isKick, string nickName, string kickName)
        {
            GSPacketIn pkg = new GSPacketIn((byte)eChatServerPacket.CONSORTIA_RESPONSE);

            pkg.WriteByte(3);
            pkg.WriteInt(playerid);
            pkg.WriteInt(consortiaID);
            pkg.WriteBoolean(isKick);
            pkg.WriteString(nickName);
            pkg.WriteString(kickName);
            SendTCP(pkg);
        }
Beispiel #21
0
        public void SendConsortiaUserDelete(int playerid, int consortiaID, bool isKick, string nickName, string kickName)
        {
            GSPacketIn pkg = new GSPacketIn(128);

            pkg.WriteByte(3);
            pkg.WriteInt(playerid);
            pkg.WriteInt(consortiaID);
            pkg.WriteBoolean(isKick);
            pkg.WriteString(nickName);
            pkg.WriteString(kickName);
            this.SendTCP(pkg);
        }
Beispiel #22
0
        public void SendConsortiaBanChat(int playerid, string playerName, int handleID, string handleName, bool isBan)
        {
            GSPacketIn pkg = new GSPacketIn(128);

            pkg.WriteByte(5);
            pkg.WriteBoolean(isBan);
            pkg.WriteInt(playerid);
            pkg.WriteString(playerName);
            pkg.WriteInt(handleID);
            pkg.WriteString(handleName);
            this.SendTCP(pkg);
        }
Beispiel #23
0
        public int HandlePacket(GameClient client, GSPacketIn packet)
        {
            if (client.Player.CurrentRoom == null)
            {
                return(0);
            }
            int        playerId   = packet.ReadInt();
            GamePlayer playerById = WorldMgr.GetPlayerById(playerId);

            if (playerById == client.Player)
            {
                return(0);
            }
            GSPacketIn        gSPacketIn = new GSPacketIn(70, client.Player.PlayerCharacter.ID);
            List <GamePlayer> players    = client.Player.CurrentRoom.GetPlayers();

            foreach (GamePlayer current in players)
            {
                if (current == playerById)
                {
                    client.Out.SendMessage(eMessageType.ERROR, LanguageMgr.GetTranslation("friendnotinthesameserver.Sameroom", new object[0]));
                    int result = 0;
                    return(result);
                }
            }
            if (playerById != null && playerById.CurrentRoom == null)//__receiveInvite
            {
                gSPacketIn.WriteInt(client.Player.PlayerCharacter.ID);
                gSPacketIn.WriteInt(client.Player.CurrentRoom.RoomId);
                gSPacketIn.WriteInt(client.Player.CurrentRoom.MapId);
                gSPacketIn.WriteByte(client.Player.CurrentRoom.TimeMode);
                gSPacketIn.WriteByte((byte)client.Player.CurrentRoom.RoomType);
                gSPacketIn.WriteByte((byte)client.Player.CurrentRoom.HardLevel);
                gSPacketIn.WriteByte((byte)client.Player.CurrentRoom.LevelLimits);
                gSPacketIn.WriteString(client.Player.PlayerCharacter.NickName);
                gSPacketIn.WriteByte(client.Player.PlayerCharacter.typeVIP);
                gSPacketIn.WriteInt(client.Player.PlayerCharacter.VIPLevel);
                gSPacketIn.WriteString(client.Player.CurrentRoom.Name);
                gSPacketIn.WriteString(client.Player.CurrentRoom.Password);
                gSPacketIn.WriteInt(0);
                gSPacketIn.WriteBoolean(client.Player.CurrentRoom.isOpenBoss);
                playerById.Out.SendTCP(gSPacketIn);
                return(0);
            }
            if (playerById != null && playerById.CurrentRoom != null && playerById.CurrentRoom != client.Player.CurrentRoom)
            {
                client.Out.SendMessage(eMessageType.ERROR, LanguageMgr.GetTranslation("friendnotinthesameserver.Room", new object[0]));
                return(0);
            }
            client.Out.SendMessage(eMessageType.ERROR, LanguageMgr.GetTranslation("friendnotinthesameserver.Fail", new object[0]));
            return(0);
        }
        public override int HandlePacket(GamePlayer player, GSPacketIn packet)
        {
            int    id         = packet.ReadInt();
            string nickName   = packet.ReadString();
            string senderName = packet.ReadString();
            string msg        = packet.ReadString();

            if (id == 0)
            {
                using (PlayerBussiness db = new PlayerBussiness())
                {
                    PlayerInfo info = db.GetUserSingleByNickName(nickName);
                    if (info != null)
                    {
                        id = info.ID;
                    }
                }
            }
            int result;

            if (id != 0)
            {
                GSPacketIn pkg = packet.Clone();
                pkg.ClearContext();
                pkg.ClientID = player.PlayerCharacter.ID;
                pkg.WriteInt(id);
                pkg.WriteString(nickName);
                pkg.WriteString(player.PlayerCharacter.NickName);
                pkg.WriteString(msg);
                GamePlayer other = WorldMgr.GetPlayerById(id);
                if (other != null)
                {
                    if (other.IsBlackFriend(player.PlayerCharacter.ID))
                    {
                        result = 1;
                        return(result);
                    }
                    other.Out.SendTCP(pkg);
                }
                else
                {
                    GameServer.Instance.LoginServer.SendPacket(pkg);
                }
                player.Out.SendTCP(pkg);
            }
            else
            {
                player.Out.SendMessage(eMessageType.ERROR, LanguageMgr.GetTranslation("UserPrivateChatHandler.NoUser", new object[0]));
            }
            result = 1;
            return(result);
        }
Beispiel #25
0
        public void SendConsortiaBanChat(int playerid, string playerName, int handleID, string handleName, bool isBan)
        {
            GSPacketIn pkg = new GSPacketIn((byte)eChatServerPacket.CONSORTIA_RESPONSE);

            pkg.WriteByte(5);
            pkg.WriteBoolean(isBan);
            pkg.WriteInt(playerid);
            pkg.WriteString(playerName);
            pkg.WriteInt(handleID);
            pkg.WriteString(handleName);

            SendTCP(pkg);
        }
        public int HandlePacket(GameClient client, GSPacketIn packet)
        {
            int             num        = (int)packet.ReadByte();
            int             num2       = packet.ReadInt();
            int             place      = packet.ReadInt();
            ItemInfo        itemAt     = client.Player.GetItemAt((eBageType)num2, place);
            PlayerInventory inventory  = client.Player.GetInventory((eBageType)num2);
            string          msg        = "Kích hoạt tiềm năng thành công!";
            GSPacketIn      gSPacketIn = new GSPacketIn(133, client.Player.PlayerCharacter.ID);

            if (num == 1)
            {
                int             num3       = packet.ReadInt();
                int             place2     = packet.ReadInt();
                ItemInfo        itemAt2    = client.Player.GetItemAt((eBageType)num3, place2);
                PlayerInventory inventory2 = client.Player.GetInventory((eBageType)num3);
                inventory2.RemoveCountFromStack(itemAt2, 1);
                ItemTemplateInfo itemTemplateInfo = ItemMgr.FindItemTemplate(itemAt2.TemplateID);
                int    property = itemTemplateInfo.Property3;
                string text     = property.ToString();
                for (int i = 1; i < 4; i++)
                {
                    text = text + "," + property.ToString();
                }
                if (itemAt.latentEnergyCurStr.Split(new char[]
                {
                    ','
                })[0] == "0")
                {
                    itemAt.latentEnergyCurStr = text;
                }
                itemAt.latentEnergyNewStr  = text;
                itemAt.latentEnergyEndTime = DateTime.Now.AddDays((double)itemTemplateInfo.Property4);
            }
            else
            {
                client.Player.MainBag.UpdatePlayerProperties();
                itemAt.latentEnergyCurStr = itemAt.latentEnergyNewStr;
                msg = "Cập nhật tiềm năng thành công!";
            }
            itemAt.IsBinds = true;
            inventory.UpdateItem(itemAt);
            inventory.SaveToDatabase();
            gSPacketIn.WriteInt(itemAt.Place);
            gSPacketIn.WriteString(itemAt.latentEnergyCurStr);
            gSPacketIn.WriteString(itemAt.latentEnergyNewStr);
            gSPacketIn.WriteDateTime(itemAt.latentEnergyEndTime);
            client.Out.SendTCP(gSPacketIn);
            client.Player.SendMessage(msg);
            return(0);
        }
Beispiel #27
0
        public void SendConsortiaInvite(int ID, int playerid, string playerName, int inviteID, string intviteName, string consortiaName, int consortiaID)
        {
            GSPacketIn pkg = new GSPacketIn(128);

            pkg.WriteByte(4);
            pkg.WriteInt(ID);
            pkg.WriteInt(playerid);
            pkg.WriteString(playerName);
            pkg.WriteInt(inviteID);
            pkg.WriteString(intviteName);
            pkg.WriteInt(consortiaID);
            pkg.WriteString(consortiaName);
            this.SendTCP(pkg);
        }
Beispiel #28
0
        public int HandlePacket(GameClient client, GSPacketIn packet)
        {
            int Type = packet.ReadInt();

            if (Type == 2)
            {
                int ItemID = packet.ReadInt();

                using (PlayerBussiness db = new PlayerBussiness())
                {
                    ItemInfo Item = db.GetUserItemSingle(ItemID);
                    if (Item != null)
                    {
                        GSPacketIn pkg = new GSPacketIn((byte)ePackageType.LINKREQUEST_GOODS, client.Player.PlayerCharacter.ID);
                        pkg.WriteInt(Item.TemplateID);
                        pkg.WriteInt(Item.ItemID);

                        pkg.WriteInt(Item.StrengthenLevel);

                        pkg.WriteInt(Item.AttackCompose);

                        pkg.WriteInt(Item.AgilityCompose);

                        pkg.WriteInt(Item.LuckCompose);

                        pkg.WriteInt(Item.DefendCompose);
                        pkg.WriteInt(Item.ValidDate);
                        pkg.WriteBoolean(Item.IsBinds);
                        pkg.WriteBoolean(Item.IsJudge);
                        pkg.WriteBoolean(Item.IsUsed);
                        if (Item.IsUsed)
                        {
                            pkg.WriteString(Item.BeginDate.ToString());
                        }
                        pkg.WriteInt(Item.Hole1);
                        pkg.WriteInt(Item.Hole2);
                        pkg.WriteInt(Item.Hole3);
                        pkg.WriteInt(Item.Hole4);
                        pkg.WriteInt(Item.Hole5);
                        pkg.WriteInt(Item.Hole6);

                        pkg.WriteString(Item.Template.Hole);

                        client.Out.SendTCP(pkg);
                    }
                    return(1);
                }
            }
            return(0);
        }
Beispiel #29
0
        private void HandleAreaBigBugle(GSPacketIn pkg)
        {
            var x = new GSPacketIn(25);

            x.WriteInt(pkg.ReadInt());
            x.WriteInt(pkg.ReadInt());
            x.WriteString(Name);
            x.WriteString(pkg.ReadString());
            x.WriteString(pkg.ReadString());
            foreach (var a in server.GetAllClients())
            {
                a.SendTCP(x);
            }
        }
Beispiel #30
0
        public void SendConsortiaInvite(int ID, int playerid, string playerName, int inviteID, string intviteName, string consortiaName, int consortiaID)
        {
            GSPacketIn pkg = new GSPacketIn((byte)eChatServerPacket.CONSORTIA_RESPONSE);

            pkg.WriteByte(4);
            pkg.WriteInt(ID);
            pkg.WriteInt(playerid);
            pkg.WriteString(playerName);
            pkg.WriteInt(inviteID);
            pkg.WriteString(intviteName);
            pkg.WriteInt(consortiaID);
            pkg.WriteString(consortiaName);

            SendTCP(pkg);
        }