C# Packet.ReadInt方法代码示例

        public void HandlePacket(Packet p, NetworkPlayer player)
        {
            byte num = p.ReadByte();
            switch (num)
            {
                case 0:
                    string name = p.ReadString();
                    player.PlayerName = name;
                    Packet255SCConnectionFirmed packet2 = new Packet255SCConnectionFirmed(player.PlayerID);
                    SendPacket(packet2, player.NetConnection);
                    foreach (NetworkPlayer pl in GameServer.NetworkPlayers)
                    {
                        var packet = new Packet0SCPlayerConnect(pl.PlayerName, pl.PlayerID, pl.EntityPosition);
                        SendPacket(packet, player.NetConnection);

                        if (pl == player) continue;

                        packet = new Packet0SCPlayerConnect(player.PlayerName,
                                                            player.PlayerID, player.EntityPosition);
                        SendPacket(packet, pl.NetConnection);
                    }
                    ServerConsole.Log("New player \"" + name + "\" connected.");
                    break;
                //A game event, JC!
                case 1:
                    byte eventID = p.ReadByte();
                    GameServer.HandleGameEvent(eventID, p, player);
                    break;

                case 2:
                    int pX = p.ReadInt();
                    int pY = p.ReadInt();
                    GameServer.SetBlock(pX, pY, 0, true, 0);
                    break;

                case 4:
                    byte flags = p.ReadByte();
                    if (player.MovementFlags != flags)
                    {
                        player.UpdateMask |= (int)PlayerUpdateFlags.Player_Update;
                        player.UpdateMask |= (int)PlayerUpdateFlags.Player_Movement_Flags;
                    }
                    player.MovementFlags = flags;
                    break;

                case 5:
                    flags = p.ReadByte();
                    float angle = p.ReadShort().DToR();
                    if (player.MovementFlags != flags || angle != player.PlayerAimAngle)
                    {
                        player.UpdateMask |= (int)PlayerUpdateFlags.Player_Update;
                        player.UpdateMask |= (int)PlayerUpdateFlags.Player_Movement_Flags;
                    }
                    player.MovementFlags = flags;
                    player.PlayerAimAngle = angle;
                    break;
            }
        }

 /// <summary>
 /// Initializes new instance of <see cref="UserAuthenticationRequest"/> struct.
 /// </summary>
 /// <param name="p"><see cref="Packet"/> to initialize from.</param>
 public UserAuthenticationRequest( Packet p )
 {
     RequestID = p.ReadLong();
     Login = p.ReadString();
     Password = p.ReadString();
     SessionID = p.ReadInt();
 }

        public static void HandlePlayerChat(Client pClient, Packet pPacket)
        {
            int Tick = pPacket.ReadInt();
            string Message = pPacket.ReadMapleString();
            byte Unknown = pPacket.ReadByte();

            if (Message.Length >= 80)
                return;

            if (Message.StartsWith("!"))
            {
                string[] Sub = Message.Split(' ');

                switch (Sub[0].ToLower())
                {
                    case "!map":
                        int Id = int.Parse(Sub[1]);
                        pClient.Character.ChangeMap(Id);
                        break;
                }
            }
            else
            {
                pClient.Character.CurrentMap.SendPacket(MapPacket.PlayerChat(pClient.Character.Id, Message, false, 1));
            }
        }

        public static void HandleChangeMap(Client pClient, Packet pPacket)
        {
            Console.WriteLine(pPacket.ToString());
            Map Map = pClient.Character.ChannelMaps[pClient.Character.MapId];

            byte Unk = pPacket.ReadByte();
            int Opcode = pPacket.ReadInt();
            int ToMap = pPacket.ReadInt();

            switch (Opcode)
            {
                case 0:
                    {
                        if (pClient.Character.HP == 0)
                        {
                            //pClient.Character.HandleDeath();
                        }
                        break;
                    }
                case -1:
                    {
                        string PortalName = pPacket.ReadMapleString();

                        if (Map.Portals.ContainsKey(PortalName)){
                            Portal Portal = Map.Portals[PortalName];
                            Portal To = Master.Instance.DataProvider.Maps[Portal.ToMapID].Portals[Portal.ToName];
                            pClient.Character.ChangeMap(Portal.ToMapID, To);
                        }
                        break;
                    }
                default:
                    {
                        // Change to map if admin.
                    }
                    break;
            }
        }

        public static void HandlePlayerDamage(Client pClient, Packet pPacket)
        {
            pPacket.Skip(4);
            pPacket.ReadInt(); // Tick.
            sbyte Type = pPacket.ReadSByte();
            pPacket.Skip(1);
            int Damage = pPacket.ReadInt();
            pPacket.Skip(2);
               int MobId = 0;

               if (Type != -2 && Type != -3 && Type != -4)
               MobId = pPacket.ReadInt();

               pClient.Character.ModifyHP((short)-Damage);
        }

        public static void HandleMigration(Client pClient, Packet pPacket)
        {
            int CharacterId = pPacket.ReadInt();
            pPacket.Skip(18);
            long SessionId = pPacket.ReadLong();

            if (Master.Instance.Worlds[pClient.World].EligableMigration(CharacterId, SessionId, false))
            {
                pClient.SessionId = SessionId;

                pClient.Character = Master.Instance.Accessor.GetCharacter(CharacterId);
                pClient.Account = Master.Instance.Accessor.GetAccount(pClient.Character.AccountId);

                if (pClient.Character.Id != CharacterId)
                {
                    pClient.Session.Disconnect();
                    return;
                }

                pClient.Character.Client = pClient;

                if (pClient.Account.LoggedIn == 2)
                {
                    pClient.Session.Disconnect();
                    return;
                }

                pClient.Account.LoggedIn = 2;

                if (Master.Instance.Worlds[pClient.World].CashShopMigration(pClient.Character.Id))
                {
                    CashShopHandler.HandleEnter(pClient, pPacket);
                }
                else
                {
                    pClient.SendPacket(MapPacket.EnterFieldNew(pClient.Character));
                    Master.Instance.Worlds[pClient.World].Channels[pClient.Channel].Maps[pClient.Character.MapId].AddPlayer(pClient.Character);
                }
            }
            else
            {
                Console.WriteLine("[{0}] Migration failed.", pClient.Session.IP);
            }
        }

        public static void BeginMove(Packet packet, Player player)
        {
            int GameCoord = packet.ReadInt( );

            Point Pos = Data.GetReallyCoord(player.CharData.Map, GameCoord);
            NPC NPCData = NPCs.IsNPC(player, Pos);

            if (NPCData != null)
            {
                #region Response (NPC)
                Packet Response = new Packet(0x0252);
                Response.WriteByte(1);
                Response.WriteUShort(NPCData.Type);
                player.Sock.Send(Response);
                #endregion
            }
            else
            {
                #region Response (Move)
                Packet Response = new Packet(0x0122);
                Response.WriteInt(GameCoord); // Coord
                Response.WriteUShort(player.CharData.MovingSpeed); // Speed
                Response.WriteByte(1); // Flag
                player.Sock.Send(Response);
                #endregion

                #region Others
                Packet Others = new Packet(0x0123);
                Others.WriteULong(player.ID);
                Others.WriteInt(GameCoord);
                Others.WriteUShort(1); // Speed

                int MapIndex = Maps.MapsData.Find(player.CharData.Map);
                if (MapIndex != -1)
                {
                    foreach (Player x in Maps.MapsData[MapIndex].Players)
                    {
                        if (x.ID != player.ID)
                            x.Sock.Send(Others);
                    }
                }
                #endregion
            }
        }

        /// <summary>
        /// Initializes new instance of <see cref="CacheUserSessionRequest"/> struct.
        /// </summary>
        /// <param name="p"><see cref="Packet"/> to initialize from.</param>
        public CacheUserSessionRequest( Packet p )
        {
            RequestID = p.ReadLong();

            UserSession session = new UserSession();
            session.AccountName = p.ReadString();
            session.IPAddress = p.ReadString();
            session.ID = p.ReadInt();
            session.AccountID = p.ReadInt();
            session.Login1 = p.ReadInt();
            session.Login2 = p.ReadInt();
            session.Play1 = p.ReadInt();
            session.Play2 = p.ReadInt();
            session.StartTime = p.InternalReadDateTime();

            Session = session;
        }

        public static void HandleCreateCharacter(Client pClient, Packet pPacket)
        {
            if (pClient.Account.LoggedIn != 1) { return; }

            List<Equip> equips = new List<Equip>();

            string name = pPacket.ReadMapleString();
            pPacket.ReadInt();

            int startMap = 0;

            int jobType = pPacket.ReadInt();
            short jobSubtype = pPacket.ReadShort();
            byte gender = pPacket.ReadByte();
            byte skin = pPacket.ReadByte();
            pPacket.ReadByte();
            int face = pPacket.ReadInt();
            int hair = pPacket.ReadInt();
            int hairColor = -1, faceMark = -1, topId, bottomId = -1, capeId = -1, shoesId, weaponId, shieldId = -1;

            if (Constants.CharacterCreation.hasHairColor(jobType))
                hairColor = pPacket.ReadInt();
            if (Constants.CharacterCreation.hasSkinColor(jobType))
                pPacket.ReadInt();
            if (Constants.CharacterCreation.hasFaceMark(jobType))
                faceMark = pPacket.ReadInt();
            if (Constants.CharacterCreation.hasHat(jobType))
            {
                int capId = pPacket.ReadInt();
                Equip cap = new Equip();
                cap.ItemID = capId;
                cap.GiveStats(false);
                cap.InventorySlot = -1;

                equips.Add(cap);
            }
            topId = pPacket.ReadInt();
            Equip top = new Equip();
            top.ItemID = topId;
            top.GiveStats(false);
            top.InventorySlot = -5;

            equips.Add(top);
            if (Constants.CharacterCreation.hasBottom(jobType))
            {
                bottomId = pPacket.ReadInt();
                Equip bottom = new Equip();
                bottom.ItemID = bottomId;
                bottom.GiveStats(false);
                bottom.InventorySlot = -6;

                equips.Add(bottom);
            }
            if (Constants.CharacterCreation.hasCape(jobType))
            {
                capeId = pPacket.ReadInt();
                Equip cape = new Equip();
                cape.ItemID = capeId;
                cape.GiveStats(false);
                cape.InventorySlot = -9;

                equips.Add(cape);
            }
            shoesId = pPacket.ReadInt();
            Equip shoes = new Equip();
            shoes.ItemID = shoesId;
            shoes.GiveStats(false);
            shoes.InventorySlot = -7;

            equips.Add(shoes);
            weaponId = pPacket.ReadInt();
            Equip weapon = new Equip();
            weapon.ItemID = weaponId;
            weapon.GiveStats(false);
            weapon.InventorySlot = -11;

            equips.Add(weapon);
            if (jobType == (int)Constants.CharacterCreation.CreateTypes.Demon)
            {
                shieldId = pPacket.ReadInt();
                Equip shield = new Equip();
                shield.ItemID = shieldId;
                shield.GiveStats(false);
                shield.InventorySlot = -10;

                equips.Add(shield);
            }
            Character newChr = new Character();

            newChr.Client = pClient;
            newChr.AccountId = pClient.Account.Id;
            newChr.WorldId = pClient.World;

            newChr.Name = name;

            newChr.MapId = Constants.CharacterCreation.GetMapByType(jobType);
            if (hairColor < 0) hairColor = 0;
            if (jobType != (short)Constants.CharacterCreation.CreateTypes.Mihile)
            {
                hair += hairColor;
//.........这里部分代码省略.........

        public static void HandleSelectCharacter(Client pClient, Packet pPacket)
        {
            if (pClient.Account.LoggedIn != 1) return;

            int CharacterId = pPacket.ReadInt();

            MigrateClient(pClient, CharacterId);
        }

        public static void HandleHeartbeat(Client pClient, Packet pPacket)
        {
            int Request = pPacket.ReadInt();

            pClient.SendPacket(GeneralPacket.HeartbeatResponse(Request));
        }

        public static void HandleGameEvent(byte eventID, Packet p)
        {
            switch ((GameServer.GameEvents)eventID)
            {
                case GameServer.GameEvents.Block_Set:
                    SetBlock(p.ReadShort(), p.ReadShort(), p.ReadShort(), true, p.ReadByte());
                    break;

                case GameServer.GameEvents.Block_Set_ID:
                    SetBlock(p.ReadShort(), p.ReadShort(), p.ReadShort());
                    break;

                case GameServer.GameEvents.Block_Set_MD:
                    short X = p.ReadShort();
                    short Y = p.ReadShort();
                    SetBlockMetaData(X, Y, p.ReadByte());
                    break;

                case GameServer.GameEvents.Block_Set_Line:
                    short startX = p.ReadShort();
                    short startY = p.ReadShort();
                    long maskID = p.ReadLong();
                    long maskMD = p.ReadLong();
                    bool[] IDUpdate = maskID.BitMaskToBools();
                    bool[] MDUpdate = maskMD.BitMaskToBools();

                    for (int i = 0; i < 64; i++)
                    {
                        if (IDUpdate[i])
                        {
                            SetBlock(startX, startY + i, p.ReadShort());
                        }
                        if (MDUpdate[i])
                        {
                            SetBlockMetaData(startX, startY + i, p.ReadByte());
                        }
                    }
                    break;

                case GameServer.GameEvents.Player_Chat:
                    byte playerID = p.ReadByte();
                    bool teamChat = p.ReadBool();
                    string chatText = p.ReadString();
                    if (playerID == ThePlayer.PlayerEntity.PlayerID)
                    {
                        ChatInterface.AddChat(new ChatEntry(ThePlayer.PlayerEntity.PlayerName, chatText, Color.White, teamChat));
                    }
                    else if (playerID != 0)
                    {
                        foreach (PlayerEntity pe in OtherPlayers)
                        {
                            if (pe.PlayerID == playerID)
                            {
                                ChatInterface.AddChat(new ChatEntry(pe.PlayerName, chatText, Color.White, teamChat));
                            }
                        }
                    }
                    else
                    {
                        ChatInterface.AddChat(new ChatEntry("Server", chatText, Color.Blue, false));
                    }
                    break;

                case GameServer.GameEvents.Player_Position:
                    playerID = p.ReadByte();
                    int x = p.ReadInt();
                    int y = p.ReadInt();
                    if (playerID == ThePlayer.PlayerEntity.PlayerID)
                    {
                        ThePlayer.PlayerEntity.EntityPosition = new Vector2(x, y);
                    }
                    else
                    {
                        foreach (PlayerEntity pe in OtherPlayers)
                        {
                            if (pe.PlayerID == playerID)
                            {
                                pe.EntityPosition = new Vector2(x, y);
                            }
                        }
                    }
                    break;

                case GameServer.GameEvents.Player_Aim_And_Position:
                    playerID = p.ReadByte();
                    x = p.ReadShort();
                    y = p.ReadShort();
                    if (playerID == ThePlayer.PlayerEntity.PlayerID)
                    {
                        ThePlayer.PlayerEntity.EntityPosition = new Vector2(x, y);
                    }
                    else
                    {
                        foreach (PlayerEntity pe in OtherPlayers)
                        {
                            if (pe.PlayerID == playerID)
                            {
                                pe.EntityPosition = new Vector2(x, y);
                            }
                        }
//.........这里部分代码省略.........

        public static void HandlePacket(byte packetID, Packet p)
        {
            switch (packetID)
            {
                case 0:
                    string pName = p.ReadString();
                    byte id = p.ReadByte();

                    int posX = p.ReadInt();
                    int posY = p.ReadInt();
                    if (OtherPlayers.Where(pl => pl.PlayerID == id).Count() > 0) return;
                    if (ThePlayer.PlayerEntity.PlayerID != id)
                    {
                        ConsoleManager.Log("New player: " + pName + " id: " + id + " x: " + posX + " y: " + posY);
                        OtherPlayers.Add(new PlayerEntity(new Vector2(posX, posY), id, pName));
                    }
                    else
                    {
                        ThePlayer.PlayerEntity.EntityPosition = new Vector2(posX, posY);
                    }
                    break;
                case 1:
                    HandleGameEvent(p.ReadByte(), p);
                    break;

                case 2:
                    byte type = p.ReadByte();
                    byte ID = p.ReadByte();
                    short X = p.ReadShort();
                    short Y = p.ReadShort();
                    short angle = p.ReadShort();
                    byte strength = p.ReadByte();
                    byte owner = p.ReadByte();
                    GameProjectiles.Add(new ProjectileArrow(new Vector2(X, Y), angle, owner, strength) { ProjectileID = ID });
                    break;

                case 3:
                    byte toRemove = p.ReadByte();
                    EntityProjectile proj = null;
                    foreach (EntityProjectile projectile in GameProjectiles)
                    {
                        if (projectile.ProjectileID == toRemove)
                        {
                            proj = projectile;
                            break;
                        }
                    }
                    if (proj != null) GameProjectiles.Remove(proj);
                    break;

                case 6:
                    byte playerID = p.ReadByte();
                    PlayerEntity player = PlayerOfID(playerID);
                    if (player == null) break;
                    player.OnAttack();
                    break;

                case 7:
                    playerID = p.ReadByte();
                    byte itemID = p.ReadByte();
                    player = PlayerOfID(playerID);
                    if (player == null) break;
                    player.EquippedItem = Item.GetItem(itemID);

                    break;

                case 8:
                    Vector2 pos = p.ReadVectorS();
                    Vector2 velocity = p.ReadVectorS();
                    short droppedID = p.ReadShort();
                    itemID = p.ReadByte();
                    EntityDroppedItem item = DroppedItemOfID(droppedID);
                    if (item != null)
                        break;

                    item = new EntityDroppedItem(pos, velocity, itemID, droppedID);
                    DroppedItems.Add(item);
                    break;

                case 9:
                    droppedID = p.ReadShort();
                    byte pickerUpper = p.ReadByte();
                    player = PlayerOfID(pickerUpper);
                    item = DroppedItemOfID(droppedID);
                    if (item == null || player == null) break;
                    item.MovingTowards = player;
                    item.DroppedItemID = -1;
                    item.Incomplete = false;
                    break;

                case 10:
                    droppedID = p.ReadShort();
                    item = DroppedItemOfID(droppedID);
                    if (item != null)
                        DroppedItems.Remove(item);
                    break;

                case 12:
                    droppedID = p.ReadShort();
                    pickerUpper = p.ReadByte();
//.........这里部分代码省略.........

        /// <summary>
        /// Handles incoming packet.
        /// </summary>
        /// <param name="packet">Incoming packet.</param>
        protected override void Handle( Packet packet )
        {
            Logger.WriteLine(Source.OuterNetwork, "Received: {0}", packet.ToString());

            //Logger.WriteLine(Source.Debug, "packet.FirstOpcode = {0}", packet.FirstOpcode);

            switch ( State )
            {
                case UserConnectionState.Disconnected:
                    throw new InvalidOperationException();

                case UserConnectionState.Connected:
                    {
                        switch ( packet.FirstOpcode )
                        {
                            case 0x0e: // protocol
                                {
                                    int revision = packet.ReadInt();

                                    //Logger.WriteLine(Source.Debug, "Protocol Revision: {0}", revision);

                                    if ( revision == -2 )
                                    {
                                        CloseConnection();
                                        // remove from active connections list
                                    }

                                    if ( revision < Settings.Default.WorldMinProtoRev || revision > Settings.Default.WorldMaxProtoRev )
                                    {
                                        CloseConnection();
                                        // remove from active connections, log
                                    }

                                    byte[] keyIN = BlowFishKeygen.GetNext();
                                    //byte[] keyOUT = BlowFishKeygen.GetNext();

                                    m_Crypt = new GameCrypt();
                                    m_Crypt.setKey(keyIN);

                                    SendNoCrypt(KeyPacket.Create(keyIN));

                                    BeginReceive();

                                    break;
                                }
                            case 0x2b: // login
                                {
                                    new AuthLogin(packet).RunImpl();
                                    break;
                                }
                            default:
                                {
                                    Logger.WriteLine(Source.OuterNetwork, "Unknown packet on state {0}: Opcode = {1}", State, packet.FirstOpcode);
                                    break;
                                }
                        }

                        return;
                    }

                case UserConnectionState.Authed:
                    {
                        switch (packet.FirstOpcode)
                        {
                            default:
                                {
                                    Logger.WriteLine(Source.OuterNetwork, "Unknown packet on state {0}: Opcode = {1}", State, packet.FirstOpcode);
                                    break;
                                }
                        }
                        return;
                    }
            }
        }

        public static void HandlePlayerMovement(Client pClient, Packet pPacket)
        {
            Character Character = pClient.Character;

            pPacket.Skip(14);
            pPacket.ReadInt();
            pPacket.ReadInt();

            Pos StartPos = Character.Position;

            if (Character == null)
                return;

            List<LifeMovementFragment> Res = new List<LifeMovementFragment>();

            try
            {
                Res = MovementParse.ParseMovement(pPacket, 1);
            }
            catch
            {
                Console.WriteLine("AIOBE Type: 1\r\n" + pPacket.ToString());
                return;
            }

            //Character.CurrentMap.SendPacket(MapPacket.PlayerMove(Character.Id, Res, StartPos));

            MovementParse.UpdatePosition(Res, Character, 0);
            Pos Pos = Character.Position;

            //Character.CurrentMap.MovePlayer(Character, Pos);
        }