using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;

namespace ServerPackets
{
    public sealed class KeepAlive : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.KeepAlive; }
        }
        public long Time;

        protected override void ReadPacket(BinaryReader reader)
        {
            Time = reader.ReadInt64();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Time);
        }
    }


    public sealed class Connected : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.Connected; }
        }

        protected override void ReadPacket(BinaryReader reader)
        {
        }

        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class ClientHP : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ClientHP; }
        }
        protected override void ReadPacket(BinaryReader reader)
        {

        }
        protected override void WritePacket(BinaryWriter writer)
        {

        }

    }

    public sealed class ClientVersion : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ClientVersion; }
        }

        public byte Result;
        /*
         * 0: Wrong Version
         * 1: Correct Version
         */

        protected override void ReadPacket(BinaryReader reader)
        {
            Result = reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Result);
        }
    }
    public sealed class Disconnect : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.Disconnect; }
        }

        public byte Reason;

        /*
         * 0: Server Closing.
         * 1: Another User.
         * 2: Packet Error.
         * 3: Server Crashed.
         */

        protected override void ReadPacket(BinaryReader reader)
        {
            Reason = reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Reason);
        }
    }

    public sealed class HookSuspicionMsg : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.HookSuspicionMsg; }
        }
        public string Question;
        public List<string> Options = new List<string>();
        public long StartTime;
        public int AnswerIndex;
        public bool IsPrisonQuestion;
        protected override void ReadPacket(BinaryReader reader)
        {
            Question=reader.ReadString();
            var count=reader.ReadInt32();
            for (int i = 0; i < count; i++)
            {
                Options.Add(reader.ReadString());
            }
            StartTime = reader.ReadInt64();
            IsPrisonQuestion=reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Question);
            writer.Write(Options.Count);
            for (int i = 0; i < Options.Count; i++)
            {
                writer.Write(Options[i]);
            }
            writer.Write(StartTime);
            writer.Write(IsPrisonQuestion);
        }
    }

    public sealed class HookSuspicionMsgFailure : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.HookSuspicionMsgFailure; }
        }
        protected override void ReadPacket(BinaryReader reader)
        {
        }

        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class NewAccount : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.NewAccount; }
        }

        public byte Result;
        /*
         * 0: Disabled
         * 1: Bad AccountID
         * 2: Bad Password
         * 3: Bad Email
         * 4: Bad Name
         * 5: Bad Question
         * 6: Bad Answer
         * 7: Account Exists.
         * 8: Success
         */

        protected override void ReadPacket(BinaryReader reader)
        {
            Result = reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Result);
        }

    }
    public sealed class ChangePassword : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ChangePassword; }
        }

        public byte Result;
        /*
         * 0: Disabled
         * 1: Bad AccountID
         * 2: Bad Current Password
         * 3: Bad New Password
         * 4: Account Not Exist
         * 5: Wrong Password
         * 6: Success
         */

        protected override void ReadPacket(BinaryReader reader)
        {
            Result = reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Result);
        }
    }
    public sealed class ChangePasswordBanned : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ChangePasswordBanned; }
        }

        public string Reason = string.Empty;
        public DateTime ExpiryDate;

        protected override void ReadPacket(BinaryReader reader)
        {
            Reason = reader.ReadString();
            ExpiryDate = DateTime.FromBinary(reader.ReadInt64());
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Reason);
            writer.Write(ExpiryDate.ToBinary());
        }
    }
    public sealed class Login : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.Login; }
        }

        public byte Result;
        /*
         * 0: Disabled
         * 1: Bad AccountID
         * 2: Bad Password
         * 3: Account Not Exist
         * 4: Wrong Password
         */

        protected override void ReadPacket(BinaryReader reader)
        {
            Result = reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Result);
        }


    }
    public sealed class LoginBanned : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.LoginBanned; }
        }

        public string Reason = string.Empty;
        public DateTime ExpiryDate;

        protected override void ReadPacket(BinaryReader reader)
        {
            Reason = reader.ReadString();
            ExpiryDate = DateTime.FromBinary(reader.ReadInt64());
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(string.IsNullOrEmpty(Reason)?"":Reason);
            writer.Write(ExpiryDate.ToBinary());
        }
    }
    public sealed class LoginSuccess : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.LoginSuccess; }
        }

        public List<SelectInfo> Characters = new List<SelectInfo>();

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                Characters.Add(new SelectInfo(reader));
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Characters.Count);

            for (int i = 0; i < Characters.Count; i++)
                Characters[i].Save(writer);
        }
    }
    public sealed class NewCharacter : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.NewCharacter; }
        }

        /*
         * 0: Disabled.
         * 1: Bad Character Name
         * 2: Bad Gender
         * 3: Bad Class
         * 4: Max Characters
         * 5: Character Exists.
         * */
        public byte Result;

        protected override void ReadPacket(BinaryReader reader)
        {
            Result = reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Result);
        }
    }
    public sealed class NewCharacterSuccess : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.NewCharacterSuccess; }
        }

        public SelectInfo CharInfo;

        protected override void ReadPacket(BinaryReader reader)
        {
            CharInfo = new SelectInfo(reader);
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            CharInfo.Save(writer);
        }
    }
    public sealed class DeleteCharacter : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.DeleteCharacter; }
        }

        public byte Result;

        /*
         * 0: Disabled.
         * 1: Character Not Found
         * */

        protected override void ReadPacket(BinaryReader reader)
        {
            Result = reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Result);
        }
    }
    public sealed class DeleteCharacterSuccess : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.DeleteCharacterSuccess; }
        }

        public int CharacterIndex;

        protected override void ReadPacket(BinaryReader reader)
        {
            CharacterIndex = reader.ReadInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(CharacterIndex);
        }
    }
    public sealed class StartGame : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.StartGame; }
        }

        public byte Result;
        public int Resolution;
        public int SessionID;

        /*
         * 0: Disabled.
         * 1: Not logged in
         * 2: Character not found.
         * 3: Start Game Error
         * */

        protected override void ReadPacket(BinaryReader reader)
        {
            Result = reader.ReadByte();
            Resolution = reader.ReadInt32();
            SessionID = reader.ReadInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Result);
            writer.Write(Resolution);
            writer.Write(SessionID);
        }
    }
    public sealed class StartGameBanned : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.StartGameBanned; }
        }

        public string Reason = string.Empty;
        public DateTime ExpiryDate;

        protected override void ReadPacket(BinaryReader reader)
        {
            Reason = reader.ReadString();
            ExpiryDate = DateTime.FromBinary(reader.ReadInt64());
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Reason);
            writer.Write(ExpiryDate.ToBinary());
        }
    }
    public sealed class StartGameDelay : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.StartGameDelay; }
        }

        public long Milliseconds;

        protected override void ReadPacket(BinaryReader reader)
        {
            Milliseconds = reader.ReadInt64();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Milliseconds);
        }

    }
    public sealed class MapInformation : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.MapInformation; }
        }

        public string FileName = string.Empty;
        public string Title = string.Empty;
        public ushort MiniMap, BigMap, Music;
        public LightSetting Lights;
        public bool Lightning, Fire;
        public byte MapDarkLight;
        public int MapIndex;

        protected override void ReadPacket(BinaryReader reader)
        {
            FileName = reader.ReadString();
            Title = reader.ReadString();
            MiniMap = reader.ReadUInt16();
            BigMap = reader.ReadUInt16();
            Lights = (LightSetting)reader.ReadByte();
            byte bools = reader.ReadByte();
            if ((bools & 0x01) == 0x01) Lightning = true;
            if ((bools & 0x02) == 0x02) Fire = true;
            MapDarkLight = reader.ReadByte();
            Music = reader.ReadUInt16();
            MapIndex = reader.ReadInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(FileName);
            writer.Write(Title);
            writer.Write(MiniMap);
            writer.Write(BigMap);
            writer.Write((byte)Lights);
            byte bools = 0;
            bools |= (byte)(Lightning ? 0x01 : 0);
            bools |= (byte)(Fire ? 0x02 : 0);
            writer.Write(bools);
            writer.Write(MapDarkLight);
            writer.Write(Music);
            writer.Write(MapIndex);
        }
    }
    public sealed class UserInformation : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.UserInformation; }
        }

        public uint ObjectID;
        public uint RealId;
        public string Name = string.Empty;
        public string GuildName = string.Empty;
        public string GuildRank = string.Empty;
        public Color NameColor;
        public MirClass Class;
        public MirGender Gender;
        public ushort Level;
        public Point Location;
        public MirDirection Direction;
        public byte Hair;
        public byte HR;
        public byte HG;
        public byte HB;
        public byte IR;
        public byte IG;
        public byte IB;

        public byte Emtype;
        public ushort HP, MP;
        public uint MaxHP;
        public long Experience, MaxExperience;

        public ushort LevelBonus;
        public ushort ExtraHP;
        public ushort ExtraMP;
        public ushort ExtraAC;
        public ushort ExtraMAC;
        public ushort ExtraDC;
        public ushort ExtraMC;
        public ushort ExtraSC;

        public ushort ExtraFire;
        public ushort ExtraIce;
        public ushort ExtraLight;
        public ushort ExtraWind;
        public ushort ExtraHoly;
        public ushort ExtraDark;
        public ushort ExtraPhantom;
        public bool AllowTrade;       //是否开启交易状态

        public LevelEffects LevelEffects;

        public UserItem[] Inventory, Equipment;
        public uint Gold, Credit;

        public ushort Job;
        public ushort JobLevel;
        public long JobExp;



        public List<ClientMagic> Magics = new List<ClientMagic>();
        public List<ClientIntelligentCreature> IntelligentCreatures = new List<ClientIntelligentCreature>();//IntelligentCreature
        public IntelligentCreatureType SummonedCreatureType = IntelligentCreatureType.None;//IntelligentCreature
        public bool CreatureSummoned;//IntelligentCreature



        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            RealId = reader.ReadUInt32();
            Name = reader.ReadString();
            GuildName = reader.ReadString();
            GuildRank = reader.ReadString();
            NameColor = Color.FromArgb(reader.ReadInt32());
            Class = (MirClass)reader.ReadByte();
            Gender = (MirGender)reader.ReadByte();
            Level = reader.ReadUInt16();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
            Hair = reader.ReadByte();
            HR = reader.ReadByte();
            HG = reader.ReadByte();
            HB = reader.ReadByte();
            IR = reader.ReadByte();
            IG = reader.ReadByte();
            IB = reader.ReadByte();

            Emtype = reader.ReadByte();
            HP = reader.ReadUInt16();
            MaxHP = reader.ReadUInt32();
            MP = reader.ReadUInt16();

            Experience = reader.ReadInt64();
            MaxExperience = reader.ReadInt64();


            LevelBonus = reader.ReadUInt16();
            ExtraHP = reader.ReadUInt16();
            ExtraMP = reader.ReadUInt16();
            ExtraAC = reader.ReadUInt16();
            ExtraMAC = reader.ReadUInt16();
            ExtraDC = reader.ReadUInt16();
            ExtraMC = reader.ReadUInt16();
            ExtraSC = reader.ReadUInt16();

            ExtraFire = reader.ReadUInt16();
            ExtraIce = reader.ReadUInt16();
            ExtraLight = reader.ReadUInt16();
            ExtraWind = reader.ReadUInt16();
            ExtraHoly = reader.ReadUInt16();
            ExtraDark = reader.ReadUInt16();
            ExtraPhantom = reader.ReadUInt16();

            AllowTrade = reader.ReadBoolean();

            Job = reader.ReadUInt16();
            JobLevel = reader.ReadUInt16();
            JobExp = reader.ReadInt64();




            LevelEffects = (LevelEffects)reader.ReadByte();

            if (reader.ReadBoolean())
            {
                Inventory = new UserItem[reader.ReadInt32()];
                for (int i = 0; i < Inventory.Length; i++)
                {
                    if (!reader.ReadBoolean()) continue;
                    Inventory[i] = new UserItem(reader);
                }
            }

            if (reader.ReadBoolean())
            {
                Equipment = new UserItem[reader.ReadInt32()];
                for (int i = 0; i < Equipment.Length; i++)
                {
                    if (!reader.ReadBoolean()) continue;
                    Equipment[i] = new UserItem(reader);
                }
            }

            //if (reader.ReadBoolean())
            //{
            //    QuestInventory = new UserItem[reader.ReadInt32()];
            //    for (int i = 0; i < QuestInventory.Length; i++)
            //    {
            //        if (!reader.ReadBoolean()) continue;
            //        QuestInventory[i] = new UserItem(reader);
            //    }
            //}

            Gold = reader.ReadUInt32();
            Credit = reader.ReadUInt32();

            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                Magics.Add(new ClientMagic(reader));

            //IntelligentCreature
            count = reader.ReadInt32();
            for (int i = 0; i < count; i++)
                IntelligentCreatures.Add(new ClientIntelligentCreature(reader));
            SummonedCreatureType = (IntelligentCreatureType)reader.ReadByte();
            CreatureSummoned = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(RealId);
            writer.Write(Name);
            writer.Write(GuildName);
            writer.Write(GuildRank);
            writer.Write(NameColor.ToArgb());
            writer.Write((byte)Class);
            writer.Write((byte)Gender);
            writer.Write(Level);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
            writer.Write(Hair);
            writer.Write(HR);
            writer.Write(HG);
            writer.Write(HB);
            writer.Write(IR);
            writer.Write(IG);
            writer.Write(IB);

            writer.Write(Emtype);
            writer.Write(HP);
            writer.Write(MaxHP);
            writer.Write(MP);

            writer.Write(Experience);
            writer.Write(MaxExperience);
            writer.Write(LevelBonus);
            writer.Write(ExtraHP);
            writer.Write(ExtraMP);
            writer.Write(ExtraAC);
            writer.Write(ExtraMAC);
            writer.Write(ExtraDC);
            writer.Write(ExtraMC);
            writer.Write(ExtraSC);

            writer.Write(ExtraFire);
            writer.Write(ExtraIce);
            writer.Write(ExtraLight);
            writer.Write(ExtraWind);
            writer.Write(ExtraHoly);
            writer.Write(ExtraDark);
            writer.Write(ExtraPhantom);

            writer.Write(AllowTrade);

            writer.Write(Job);
            writer.Write(JobLevel);
            writer.Write(JobExp);

            writer.Write((byte)LevelEffects);

            writer.Write(Inventory != null);
            if (Inventory != null)
            {
                writer.Write(Inventory.Length);
                for (int i = 0; i < Inventory.Length; i++)
                {
                    writer.Write(Inventory[i] != null);
                    if (Inventory[i] == null) continue;

                    Inventory[i].Save(writer);
                }

            }

            writer.Write(Equipment != null);
            if (Equipment != null)
            {
                writer.Write(Equipment.Length);
                for (int i = 0; i < Equipment.Length; i++)
                {
                    writer.Write(Equipment[i] != null);
                    if (Equipment[i] == null) continue;

                    Equipment[i].Save(writer);
                }
            }

            //writer.Write(QuestInventory != null);
            //if (QuestInventory != null)
            //{
            //    writer.Write(QuestInventory.Length);
            //    for (int i = 0; i < QuestInventory.Length; i++)
            //    {
            //        writer.Write(QuestInventory[i] != null);
            //        if (QuestInventory[i] == null) continue;

            //        QuestInventory[i].Save(writer);
            //    }
            //}

            writer.Write(Gold);
            writer.Write(Credit);

            writer.Write(Magics.Count);
            for (int i = 0; i < Magics.Count; i++)
                Magics[i].Save(writer);

            //IntelligentCreature
            writer.Write(IntelligentCreatures.Count);
            for (int i = 0; i < IntelligentCreatures.Count; i++)
                IntelligentCreatures[i].Save(writer);
            writer.Write((byte)SummonedCreatureType);
            writer.Write(CreatureSummoned);
        }
    }
    public sealed class UserLocation : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.UserLocation; }
        }

        public Point Location;
        public MirDirection Direction;


        protected override void ReadPacket(BinaryReader reader)
        {
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }
    public sealed class ObjectPlayer : Packet
    {

        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectPlayer; }
        }

        public uint ObjectID;
        public string Name = string.Empty;
        public string GuildName = string.Empty;
        public string GuildRankName = string.Empty;
        public Color NameColor;
        public MirClass Class;
        public MirGender Gender;
        public ushort Level;
        public Point Location;
        public MirDirection Direction;
        public byte Hair, HR, HG, HB;
        public byte Light;
        public short Weapon, Armour, Helmet;
        public byte IR, IG, IB;
        public byte Emtype;
        public byte AmultShape;
        public PoisonType Poison;
        public bool Dead, Hidden, SpHidden;
        public SpellEffect Effect;
        public byte WingEffect;
        public bool Extra;

        public short MountType;
        public bool RidingMount;
        public bool Fishing;

        public short TransformType;

        public uint ElementOrbEffect;
        public uint ElementOrbLvl;
        public uint ElementOrbMax;

        public LevelEffects LevelEffects;

        public List<BuffType> Buffs = new List<BuffType>();
        public uint Hp, MaxHp;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Name = reader.ReadString();
            GuildName = reader.ReadString();
            GuildRankName = reader.ReadString();
            NameColor = Color.FromArgb(reader.ReadInt32());
            Class = (MirClass)reader.ReadByte();
            Gender = (MirGender)reader.ReadByte();
            Level = reader.ReadUInt16();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
            Hair = reader.ReadByte();
            HR = reader.ReadByte();
            HG = reader.ReadByte();
            HB = reader.ReadByte();

            IR = reader.ReadByte();
            IG = reader.ReadByte();
            IB = reader.ReadByte();

            Emtype = reader.ReadByte();
            AmultShape = reader.ReadByte();
            Light = reader.ReadByte();
            Weapon = reader.ReadInt16();
            Armour = reader.ReadInt16();
            Helmet = reader.ReadInt16();
            Poison = (PoisonType)reader.ReadUInt16();
            Dead = reader.ReadBoolean();
            Hidden = reader.ReadBoolean();
            SpHidden = reader.ReadBoolean();
            Effect = (SpellEffect)reader.ReadByte();
            WingEffect = reader.ReadByte();
            Extra = reader.ReadBoolean();
            MountType = reader.ReadInt16();
            RidingMount = reader.ReadBoolean();
            Fishing = reader.ReadBoolean();

            TransformType = reader.ReadInt16();

            ElementOrbEffect = reader.ReadUInt32();
            ElementOrbLvl = reader.ReadUInt32();
            ElementOrbMax = reader.ReadUInt32();

            int count = reader.ReadInt32();
            for (int i = 0; i < count; i++)
            {
                Buffs.Add((BuffType)reader.ReadByte());
            }

            LevelEffects = (LevelEffects)reader.ReadByte();

            Hp = reader.ReadUInt32();
            MaxHp = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Name);
            writer.Write(GuildName);
            writer.Write(GuildRankName);
            writer.Write(NameColor.ToArgb());
            writer.Write((byte)Class);
            writer.Write((byte)Gender);
            writer.Write(Level);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
            writer.Write(Hair);
            writer.Write(HR);
            writer.Write(HG);
            writer.Write(HB);
            writer.Write(IR);
            writer.Write(IG);
            writer.Write(IB);
            writer.Write(Emtype);
            writer.Write(AmultShape);
            writer.Write(Light);
            writer.Write(Weapon);
            writer.Write(Armour);
            writer.Write(Helmet);
            writer.Write((ushort)Poison);
            writer.Write(Dead);
            writer.Write(Hidden);
            writer.Write(SpHidden);
            writer.Write((byte)Effect);
            writer.Write(WingEffect);
            writer.Write(Extra);
            writer.Write(MountType);
            writer.Write(RidingMount);
            writer.Write(Fishing);

            writer.Write(TransformType);

            writer.Write(ElementOrbEffect);
            writer.Write(ElementOrbLvl);
            writer.Write(ElementOrbMax);

            writer.Write(Buffs.Count);
            for (int i = 0; i < Buffs.Count; i++)
            {
                writer.Write((byte)Buffs[i]);
            }

            writer.Write((byte)LevelEffects);
            writer.Write(Hp);
            writer.Write(MaxHp);
        }
    }
    public sealed class ObjectRemove : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectRemove; }
        }

        public uint ObjectID;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
        }

    }
    public sealed class ObjectTurn : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectTurn; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }
    public sealed class ObjectWalk : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectWalk; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }
    public sealed class ObjectRun : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectRun; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }
    public sealed class Chat : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.Chat; }
        }

        public string Message = string.Empty;
        public ChatType Type;

        protected override void ReadPacket(BinaryReader reader)
        {
            Message = reader.ReadString();
            Type = (ChatType)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Message);
            writer.Write((byte)Type);
        }
    }
    public sealed class ObjectChat : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectChat; }
        }

        public uint ObjectID;
        public string Text = string.Empty;
        public ChatType Type;
        public ulong UniqueID1;
        public ulong UniqueID2;
        public ulong UniqueID3;
        public string Name1 = string.Empty;
        public string Name2 = string.Empty;
        public string Name3 = string.Empty;
        public Color Color1 = Color.White;
        public Color Color2 = Color.White;
        public Color Color3 = Color.White;


        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Text = reader.ReadString();
            Type = (ChatType)reader.ReadByte();
            UniqueID1 = reader.ReadUInt64();
            UniqueID2 = reader.ReadUInt64();
            UniqueID3 = reader.ReadUInt64();
            Name1 = reader.ReadString();
            Name2 = reader.ReadString();
            Name3 = reader.ReadString();
            Color1 = Color.FromArgb(reader.ReadInt32());
            Color2 = Color.FromArgb(reader.ReadInt32());
            Color3 = Color.FromArgb(reader.ReadInt32());
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Text);
            writer.Write((byte)Type);
            writer.Write(UniqueID1);
            writer.Write(UniqueID2);
            writer.Write(UniqueID3);
            writer.Write(Name1);
            writer.Write(Name2);
            writer.Write(Name3);
            writer.Write(Color1.ToArgb());
            writer.Write(Color2.ToArgb());
            writer.Write(Color3.ToArgb());
        }
    }
    public sealed class NewItemInfo : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.NewItemInfo; }
        }

        public ItemInfo Info;

        protected override void ReadPacket(BinaryReader reader)
        {
            Info = new ItemInfo(reader);
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            Info.Save(writer);
        }
    }
    public sealed class MoveItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.MoveItem; }
        }

        public MirGridType Grid;
        public int From, To;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            Grid = (MirGridType)reader.ReadByte();
            From = reader.ReadInt32();
            To = reader.ReadInt32();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Grid);
            writer.Write(From);
            writer.Write(To);
            writer.Write(Success);
        }
    }
    public sealed class EquipItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.EquipItem; }
        }

        public MirGridType Grid;
        public ulong UniqueID;
        public int To;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            Grid = (MirGridType)reader.ReadByte();
            UniqueID = reader.ReadUInt64();
            To = reader.ReadInt32();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Grid);
            writer.Write(UniqueID);
            writer.Write(To);
            writer.Write(Success);
        }
    }
    public sealed class MergeItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.MergeItem; }
        }

        public MirGridType GridFrom, GridTo;
        public ulong IDFrom, IDTo;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            GridFrom = (MirGridType)reader.ReadByte();
            GridTo = (MirGridType)reader.ReadByte();
            IDFrom = reader.ReadUInt64();
            IDTo = reader.ReadUInt64();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)GridFrom);
            writer.Write((byte)GridTo);
            writer.Write(IDFrom);
            writer.Write(IDTo);
            writer.Write(Success);
        }
    }
    public sealed class RemoveItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.RemoveItem; }
        }

        public MirGridType Grid;
        public ulong UniqueID;
        public int To;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            Grid = (MirGridType)reader.ReadByte();
            UniqueID = reader.ReadUInt64();
            To = reader.ReadInt32();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Grid);
            writer.Write(UniqueID);
            writer.Write(To);
            writer.Write(Success);
        }
    }
    public sealed class RemoveSlotItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.RemoveSlotItem; }
        }

        public MirGridType Grid;
        public MirGridType GridTo;
        public ulong UniqueID;
        public int To;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            Grid = (MirGridType)reader.ReadByte();
            GridTo = (MirGridType)reader.ReadByte();
            UniqueID = reader.ReadUInt64();
            To = reader.ReadInt32();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Grid);
            writer.Write((byte)GridTo);
            writer.Write(UniqueID);
            writer.Write(To);
            writer.Write(Success);
        }
    }
    public sealed class TakeBackItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.TakeBackItem; }
        }

        public int From, To;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            From = reader.ReadInt32();
            To = reader.ReadInt32();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(From);
            writer.Write(To);
            writer.Write(Success);
        }
    }


    public sealed class StorPasswordAsk : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.StorPasswordAsk; }
        }


        protected override void ReadPacket(BinaryReader reader)
        {
        }

        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }

    public sealed class ReceiveMessageBox : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ReceiveMessageBox; }
        }
        public string Message;

        protected override void ReadPacket(BinaryReader reader)
        {
            Message=reader.ReadString();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Message);
        }
    }

    public sealed class SetStoragePassword : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.SetStoragePassword; }
        }
        public bool IsNewPassword;

        protected override void ReadPacket(BinaryReader reader)
        {
            IsNewPassword = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(IsNewPassword);
        }
    }

    public sealed class StorPasswordAuthResult : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.StorPasswordAuthResult; }
        }


        protected override void ReadPacket(BinaryReader reader)
        {
        }

        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }


    public sealed class SureBuyStorage : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.SureBuyStorage; }
        }

        public int Status;
        public int Position;
        protected override void ReadPacket(BinaryReader reader)
        {
            Status= reader.ReadInt32(); 
            Position= reader.ReadInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Status);
            writer.Write(Position);
        }
    }

    public sealed class StoreItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.StoreItem; }
        }

        public int From, To;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            From = reader.ReadInt32();
            To = reader.ReadInt32();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(From);
            writer.Write(To);
            writer.Write(Success);
        }
    }

    public sealed class DepositRefineItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.DepositRefineItem; }
        }

        public int From, To;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            From = reader.ReadInt32();
            To = reader.ReadInt32();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(From);
            writer.Write(To);
            writer.Write(Success);
        }
    }

    public sealed class RetrieveRefineItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.RetrieveRefineItem; }
        }

        public int From, To;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            From = reader.ReadInt32();
            To = reader.ReadInt32();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(From);
            writer.Write(To);
            writer.Write(Success);
        }
    }

    public sealed class RefineCancel : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.RefineCancel; }
        }

        public bool Unlock;
        protected override void ReadPacket(BinaryReader reader)
        {
            Unlock = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Unlock);
        }
    }

    public sealed class RefineItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.RefineItem; }
        }

        public ulong UniqueID;

        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
        }
    }

    public sealed class Mir3RefineItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.Mir3RefineItem; }
        }

        public ulong UniqueID;
        public byte Added;
        // public RefinedValue Value;


        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
            Added = reader.ReadByte();
            // Value = (RefinedValue)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
            writer.Write(Added);
            // writer.Write((byte)Value);
        }
    }

    public sealed class Mir3AtkRefine : Packet
    {

        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.Mir3AtkRefine; }
        }

        // public ulong UniqueID;

        public byte Added;
        public RefinedValue Value;
        protected override void ReadPacket(BinaryReader reader)
        {
            Added = reader.ReadByte();
            Value = (RefinedValue)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Added);
            writer.Write((byte)Value);
        }

    }

    public sealed class FindBlackItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.FindBlackItem; }
        }

        public UserItem Item;

        protected override void ReadPacket(BinaryReader reader)
        {
            if (reader.ReadBoolean())
                Item = new UserItem(reader);

        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Item != null);
            if (Item != null) Item.Save(writer);
        }
    }

    public sealed class DepositTradeItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.DepositTradeItem; }
        }

        public int From, To;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            From = reader.ReadInt32();
            To = reader.ReadInt32();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(From);
            writer.Write(To);
            writer.Write(Success);
        }
    }
    public sealed class RetrieveTradeItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.RetrieveTradeItem; }
        }

        public int From, To;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            From = reader.ReadInt32();
            To = reader.ReadInt32();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(From);
            writer.Write(To);
            writer.Write(Success);
        }
    }
    public sealed class SplitItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.SplitItem; }
        }

        public UserItem Item;
        public MirGridType Grid;

        protected override void ReadPacket(BinaryReader reader)
        {
            if (reader.ReadBoolean())
                Item = new UserItem(reader);

            Grid = (MirGridType)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Item != null);
            if (Item != null) Item.Save(writer);
            writer.Write((byte)Grid);
        }
    }
    public sealed class SplitItem1 : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.SplitItem1; }
        }

        public MirGridType Grid;
        public ulong UniqueID;
        public uint Count;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            Grid = (MirGridType)reader.ReadByte();
            UniqueID = reader.ReadUInt64();
            Count = reader.ReadUInt32();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Grid);
            writer.Write(UniqueID);
            writer.Write(Count);
            writer.Write(Success);
        }
    }
    public sealed class UseItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.UseItem; }
        }

        public ulong UniqueID;
        public bool Success;
        public ItemType Type;
        public short Shape;

        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
            Success = reader.ReadBoolean();
            Type = (ItemType)reader.ReadByte();
            Shape = reader.ReadInt16();

        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
            writer.Write(Success);
            writer.Write((byte)Type);
            writer.Write(Shape);
        }
    }

    public sealed class DropProtectSuccess : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.DropProtectSuccess; }
        }
        public int result;

        protected override void ReadPacket(BinaryReader reader)
        {
            result = reader.ReadInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(result);
        }


    }

    public sealed class DropItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.DropItem; }
        }

        public ulong UniqueID;
        public uint Count;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
            Count = reader.ReadUInt32();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
            writer.Write(Count);
            writer.Write(Success);
        }
    }
    public sealed class PlayerUpdate : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.PlayerUpdate; }
        }

        public uint ObjectID;
        public byte Light;
        public short Weapon, Armour, Helmet;
        public byte IR, IG, IB;
        public byte WingEffect;
        public byte AmultShape;
        public byte Emtype;
        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();

            Light = reader.ReadByte();
            Weapon = reader.ReadInt16();
            Armour = reader.ReadInt16();
            Helmet = reader.ReadInt16();
            WingEffect = reader.ReadByte();
            IR = reader.ReadByte();
            IG = reader.ReadByte();
            IB = reader.ReadByte();
            Emtype = reader.ReadByte();
            AmultShape = reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Light);
            writer.Write(Weapon);
            writer.Write(Armour);
            writer.Write(Helmet);
            writer.Write(WingEffect);
            writer.Write(IR);
            writer.Write(IG);
            writer.Write(IB);
            writer.Write(Emtype);
            writer.Write(AmultShape);
        }
    }
    public sealed class PlayerInspect : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.PlayerInspect; }
        }

        public string Name = string.Empty;
        public string GuildName = string.Empty;
        public string GuildRank = string.Empty;
        public int Votes;
        public UserItem[] Equipment;
        public MirClass Class;
        public MirGender Gender;
        public byte Hair, HR, HG, HB;
        public ushort Level;
        public string LoverName;

        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
            GuildName = reader.ReadString();
            GuildRank = reader.ReadString();
            Votes = reader.ReadInt32();
            Equipment = new UserItem[reader.ReadInt32()];
            for (int i = 0; i < Equipment.Length; i++)
            {
                if (reader.ReadBoolean())
                    Equipment[i] = new UserItem(reader);
            }

            Class = (MirClass)reader.ReadByte();
            Gender = (MirGender)reader.ReadByte();
            Hair = reader.ReadByte();
            HR = reader.ReadByte();
            HG = reader.ReadByte();
            HB = reader.ReadByte();
            Level = reader.ReadUInt16();
            LoverName = reader.ReadString();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Name);
            writer.Write(GuildName);
            writer.Write(GuildRank);
            writer.Write(Votes);
            writer.Write(Equipment.Length);
            for (int i = 0; i < Equipment.Length; i++)
            {
                UserItem T = Equipment[i];
                writer.Write(T != null);
                if (T != null) T.Save(writer);
            }

            writer.Write((byte)Class);
            writer.Write((byte)Gender);
            writer.Write(Hair);
            writer.Write(HR);
            writer.Write(HG);
            writer.Write(HB);
            writer.Write(Level);
            writer.Write(LoverName);

        }
    }

    public sealed class MarriageRequest : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MarriageRequest; } }

        public string Name;
        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Name);
        }
    }

    public sealed class DivorceRequest : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.DivorceRequest; } }

        public string Name;
        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Name);
        }
    }

    public sealed class MentorRequest : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MentorRequest; } }

        public string Name;
        public ushort Level;

        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
            Level = reader.ReadUInt16();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Name);
            writer.Write(Level);
        }
    }

    public sealed class TradeRequest : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.TradeRequest; } }

        public string Name;
        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Name);
        }
    }
    public sealed class TradeAccept : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.TradeAccept; } }

        public string Name;

        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Name);
        }
    }
    public sealed class TradeGold : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.TradeGold; }
        }

        public uint Amount;
        public uint TradeCost;

        protected override void ReadPacket(BinaryReader reader)
        {
            Amount = reader.ReadUInt32();
            TradeCost = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Amount);
            writer.Write(TradeCost);
        }
    }
    public sealed class TradeItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.TradeItem; }
        }
        public UserItem[] TradeItems;
        protected override void ReadPacket(BinaryReader reader)
        {
            TradeItems = new UserItem[reader.ReadInt32()];
            for (int i = 0; i < TradeItems.Length; i++)
            {
                if (reader.ReadBoolean())
                    TradeItems[i] = new UserItem(reader);
            }
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(TradeItems.Length);
            for (int i = 0; i < TradeItems.Length; i++)
            {
                UserItem T = TradeItems[i];
                writer.Write(T != null);
                if (T != null) T.Save(writer);
            }
        }
    }
    public sealed class TradeCost : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.TradeCost; }
        }
        public uint MyTradeCost;
        protected override void ReadPacket(BinaryReader reader)
        {
            MyTradeCost = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(MyTradeCost);
        }
    }

    public sealed class TradeConfirm : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.TradeConfirm; }
        }

        protected override void ReadPacket(BinaryReader reader)
        {
        }

        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class TradeCancel : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.TradeCancel; }
        }

        public bool Unlock;
        protected override void ReadPacket(BinaryReader reader)
        {
            Unlock = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Unlock);
        }
    }

    public sealed class LogOutSuccess : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.LogOutSuccess; }
        }

        public List<SelectInfo> Characters = new List<SelectInfo>();

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                Characters.Add(new SelectInfo(reader));
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Characters.Count);

            for (int i = 0; i < Characters.Count; i++)
                Characters[i].Save(writer);
        }
    }
    public sealed class LogOutFailed : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.LogOutFailed; }
        }

        protected override void ReadPacket(BinaryReader reader)
        {
        }

        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }

    public sealed class TimeOfDay : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.TimeOfDay; }
        }

        public LightSetting Lights;

        protected override void ReadPacket(BinaryReader reader)
        {
            Lights = (LightSetting)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Lights);
        }
    }
    public sealed class ChangeAMode : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ChangeAMode; }
        }

        public AttackMode Mode;

        protected override void ReadPacket(BinaryReader reader)
        {
            Mode = (AttackMode)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Mode);
        }
    }
    public sealed class ChangePMode : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ChangePMode; }
        }

        public PetMode Mode;

        protected override void ReadPacket(BinaryReader reader)
        {
            Mode = (PetMode)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Mode);
        }
    }
    public sealed class ObjectItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectItem; }
        }

        public uint ObjectID;
        public string Name = string.Empty;
        public Color NameColor;
        public Point Location;
        public ushort Image;
        public bool IsAdd;
        //public byte Gradenum;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Name = reader.ReadString();
            NameColor = Color.FromArgb(reader.ReadInt32());
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Image = reader.ReadUInt16();
            IsAdd = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Name);
            writer.Write(NameColor.ToArgb());
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write(Image);
            writer.Write(IsAdd);
        }
    }

    public sealed class ObjectUseItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectUseItem; }
        }

        public uint ObjectID;
        public string Name = string.Empty;
        public ItemType Type;
        public short Shape;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Name = reader.ReadString();
            Type = (ItemType)reader.ReadByte();
            Shape = reader.ReadInt16();

        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Name);
            writer.Write((byte)Type);
            writer.Write(Shape);
        }


    }




    public sealed class ObjectGold : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectGold; }
        }

        public uint ObjectID;
        public uint Gold;
        public Point Location;


        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Gold = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Gold);
            writer.Write(Location.X);
            writer.Write(Location.Y);
        }
    }
    public sealed class GainedItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GainedItem; }
        }

        public UserItem Item;

        protected override void ReadPacket(BinaryReader reader)
        {
            Item = new UserItem(reader);
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            Item.Save(writer);
        }
    }
    public sealed class GainedGold : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GainedGold; }
        }

        public uint Gold;

        protected override void ReadPacket(BinaryReader reader)
        {
            Gold = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Gold);
        }
    }
    public sealed class LoseGold : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.LoseGold; }
        }

        public uint Gold;

        protected override void ReadPacket(BinaryReader reader)
        {
            Gold = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Gold);
        }
    }
    public sealed class GainedCredit : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GainedCredit; }
        }

        public uint Credit;

        protected override void ReadPacket(BinaryReader reader)
        {
            Credit = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Credit);
        }
    }
    public sealed class LoseCredit : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.LoseCredit; }
        }

        public uint Credit;

        protected override void ReadPacket(BinaryReader reader)
        {
            Credit = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Credit);
        }
    }

    public sealed class ObjectMonster : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectMonster; }
        }

        public uint ObjectID;
        public string Name = string.Empty;
        public Color NameColor;
        public Point Location;
        public Monster Image;
        public MirDirection Direction;
        public byte Effect, AI, Light;
        public bool Dead, Skeleton;
        public PoisonType Poison;
        public bool Hidden, Extra;
        public byte ExtraByte;
        public long ShockTime;
        public bool BindingShotCenter;
        public int ObjectIndex = 0;

        public int Level;
        public int Undead_;
        public int FireMAC;
        public int IceMAC;
        public int LightMAC;
        public int WindMAC;
        public int HolyMAC;
        public int DarkMAC;
        public int PhantomMAC;
        public int CanTame;
        public int MCType;
        public int MoveSpeed;
        public int AttackSpeed;
        public int MinDC;
        public int MaxDC;
        public int HP, MaxHP;
        //
        //  public bool CanTame = false, Undead = false; // CanPush = false, AutoRev = false, ;
        //  public bool 
        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Name = reader.ReadString();
            NameColor = Color.FromArgb(reader.ReadInt32());
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Image = (Monster)reader.ReadUInt16();
            Direction = (MirDirection)reader.ReadByte();
            Effect = reader.ReadByte();
            AI = reader.ReadByte();
            Light = reader.ReadByte();
            Dead = reader.ReadBoolean();
            Skeleton = reader.ReadBoolean();
            Poison = (PoisonType)reader.ReadUInt16();
            Hidden = reader.ReadBoolean();
            ShockTime = reader.ReadInt64();
            BindingShotCenter = reader.ReadBoolean();
            Extra = reader.ReadBoolean();
            ExtraByte = reader.ReadByte();
            // CanTame = reader.ReadBoolean();
            // Undead = reader.ReadBoolean();
            ObjectIndex = reader.ReadInt32();
            Level = reader.ReadInt32();
            Undead_ = reader.ReadInt32();
            FireMAC = reader.ReadInt32();
            IceMAC = reader.ReadInt32();
            LightMAC = reader.ReadInt32();
            WindMAC = reader.ReadInt32();
            HolyMAC = reader.ReadInt32();
            DarkMAC = reader.ReadInt32();
            PhantomMAC = reader.ReadInt32();
            CanTame = reader.ReadInt32();
            MCType = reader.ReadInt32();
            MoveSpeed = reader.ReadInt32();
            AttackSpeed = reader.ReadInt32();
            MinDC = reader.ReadInt32();
            MaxDC = reader.ReadInt32();
            HP=reader.ReadInt32();
            MaxHP=reader.ReadInt32();
    }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Name);
            writer.Write(NameColor.ToArgb());
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((ushort)Image);
            writer.Write((byte)Direction);
            writer.Write(Effect);
            writer.Write(AI);
            writer.Write(Light);
            writer.Write(Dead);
            writer.Write(Skeleton);
            writer.Write((ushort)Poison);
            writer.Write(Hidden);
            writer.Write(ShockTime);
            writer.Write(BindingShotCenter);
            writer.Write(Extra);
            writer.Write((byte)ExtraByte);
            writer.Write(ObjectIndex);

            writer.Write(Level);
            writer.Write(Undead_);
            writer.Write(FireMAC);
            writer.Write(IceMAC);
            writer.Write(LightMAC);
            writer.Write(WindMAC);
            writer.Write(HolyMAC);
            writer.Write(DarkMAC);
            writer.Write(PhantomMAC);
            writer.Write(CanTame);
            writer.Write(MCType);
            writer.Write(MoveSpeed);
            writer.Write(AttackSpeed);
            writer.Write(MinDC);
            writer.Write(MaxDC);
            writer.Write(HP);
            writer.Write(MaxHP);
            // writer.Write(CanTame);
            //writer.Write(Undead);
        }

    }
    public sealed class ObjectAttack : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectAttack; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;
        public Spell Spell;
        public byte Level;
        public byte Type;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
            Spell = (Spell)reader.ReadByte();
            Level = reader.ReadByte();
            Type = reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
            writer.Write((byte)Spell);
            writer.Write(Level);
            writer.Write(Type);
        }
    }
    public sealed class Struck : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.Struck; }
        }

        public uint AttackerID;
        public sbyte EIType;
        public byte AttackerType;     //判断玩家还是怪物
        public uint time;

        protected override void ReadPacket(BinaryReader reader)
        {
            AttackerID = reader.ReadUInt32();
            EIType = reader.ReadSByte();
            AttackerType = reader.ReadByte();
            time = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(AttackerID);
            writer.Write(EIType);
            writer.Write(AttackerType);
            writer.Write(time);
        }
    }

    public sealed class ObjectStruck : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectStruck; }
        }

        public uint ObjectID;
        public uint AttackerID;
        public sbyte EIType;
        public Point Location;
        public MirDirection Direction;


        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            AttackerID = reader.ReadUInt32();
            EIType = reader.ReadSByte();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();


        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(AttackerID);
            writer.Write(EIType);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);

        }
    }

    // 飘血量指示器数据包
    public sealed class DamageIndicator : Packet
    {
        public int Damage;
        public DamageType Type;
        public uint ObjectID;
        //public byte PercentHealth;
        //public uint HP;
        //public uint MaxHP;

        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.DamageIndicator; }
        }

        protected override void ReadPacket(BinaryReader reader)
        {
            Damage = reader.ReadInt32();
            Type = (DamageType)reader.ReadByte();
            ObjectID = reader.ReadUInt32();
            //PercentHealth = reader.ReadByte();
            //HP = reader.ReadUInt32();
            //MaxHP = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Damage);
            writer.Write((byte)Type);
            writer.Write(ObjectID);
            // writer.Write(PercentHealth);
            //writer.Write(HP);
            //writer.Write(MaxHP);
        }
    }

    public sealed class DuraChanged : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.DuraChanged; }
        }

        public ulong UniqueID;
        public int CurrentDura;

        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
            CurrentDura = reader.ReadInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
            writer.Write(CurrentDura);
        }
    }

    public sealed class PoisonChangaChanged : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.PoisonChangaChanged; }
        }

        public byte Shape;

        protected override void ReadPacket(BinaryReader reader)
        {
            Shape = reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Shape);
        }
    }

    public sealed class HealthChanged : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.HealthChanged; }
        }

        public ushort HP, MP;

        protected override void ReadPacket(BinaryReader reader)
        {
            HP = reader.ReadUInt16();
            MP = reader.ReadUInt16();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(HP);
            writer.Write(MP);
        }
    }
    public sealed class DeleteItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.DeleteItem; }
        }

        public ulong UniqueID;
        public uint Count;

        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
            Count = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
            writer.Write(Count);
        }
    }
    public sealed class Death : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.Death; }
        }

        public Point Location;
        public MirDirection Direction;

        protected override void ReadPacket(BinaryReader reader)
        {
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }
    public sealed class ObjectDied : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectDied; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;
        public byte Type;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
            Type = reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
            writer.Write(Type);
        }
    }
    public sealed class ColorChanged : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ColorChanged; }
        }

        public Color NameColor;

        protected override void ReadPacket(BinaryReader reader)
        {
            NameColor = Color.FromArgb(reader.ReadInt32());
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(NameColor.ToArgb());
        }
    }
    public sealed class ObjectColorChanged : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectColorChanged; }
        }

        public uint ObjectID;
        public Color NameColor;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            NameColor = Color.FromArgb(reader.ReadInt32());
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(NameColor.ToArgb());
        }
    }
    public sealed class ObjectGuildNameChanged : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectGuildNameChanged; }
        }

        public uint ObjectID;
        public string GuildName;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            GuildName = reader.ReadString();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(GuildName);
        }
    }
    public sealed class GainExperience : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GainExperience; }
        }

        public uint Amount;
        public bool Levellock;
        public bool WepExp;

        protected override void ReadPacket(BinaryReader reader)
        {
            Amount = reader.ReadUInt32();
            Levellock = reader.ReadBoolean();
            WepExp = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Amount);
            writer.Write(Levellock);
            writer.Write(WepExp);
        }
    }


    public sealed class SubExperience : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.SubExperience; }
        }

        public uint Amount;


        protected override void ReadPacket(BinaryReader reader)
        {
            Amount = reader.ReadUInt32();

        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Amount);

        }
    }


    public sealed class LevelChanged : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.LevelChanged; }
        }

        public ushort Level;
        public long Experience, MaxExperience;

        protected override void ReadPacket(BinaryReader reader)
        {
            Level = reader.ReadUInt16();
            Experience = reader.ReadInt64();
            MaxExperience = reader.ReadInt64();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Level);
            writer.Write(Experience);
            writer.Write(MaxExperience);
        }
    }

    //自写扩展属性更新封包
    public sealed class ExtraChanged : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ExtraChanged; }
        }

        public ushort LevelBonus;
        public ushort ExtraHP;
        public ushort ExtraMP;
        public ushort ExtraAC;
        public ushort ExtraMAC;
        public ushort ExtraDC;
        public ushort ExtraMC;
        public ushort ExtraSC;

        public ushort ExtraFire;
        public ushort ExtraIce;
        public ushort ExtraLight;
        public ushort ExtraWind;
        public ushort ExtraHoly;
        public ushort ExtraDark;
        public ushort ExtraPhantom;

        protected override void ReadPacket(BinaryReader reader)
        {
            LevelBonus = reader.ReadUInt16();
            ExtraHP = reader.ReadUInt16();
            ExtraMP = reader.ReadUInt16();
            ExtraAC = reader.ReadUInt16();
            ExtraMAC = reader.ReadUInt16();
            ExtraDC = reader.ReadUInt16();
            ExtraMC = reader.ReadUInt16();
            ExtraSC = reader.ReadUInt16();

            ExtraFire = reader.ReadUInt16();
            ExtraIce = reader.ReadUInt16();
            ExtraLight = reader.ReadUInt16();
            ExtraWind = reader.ReadUInt16();
            ExtraHoly = reader.ReadUInt16();
            ExtraDark = reader.ReadUInt16();
            ExtraPhantom = reader.ReadUInt16();

        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(LevelBonus);
            writer.Write(ExtraHP);
            writer.Write(ExtraMP);
            writer.Write(ExtraAC);
            writer.Write(ExtraMAC);
            writer.Write(ExtraDC);
            writer.Write(ExtraMC);
            writer.Write(ExtraSC);

            writer.Write(ExtraFire);
            writer.Write(ExtraIce);
            writer.Write(ExtraLight);
            writer.Write(ExtraWind);
            writer.Write(ExtraHoly);
            writer.Write(ExtraDark);
            writer.Write(ExtraPhantom);



        }
    }

    public sealed class ObjectLeveled : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectLeveled; }
        }

        public uint ObjectID;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
        }
    }

    //武器升级广播包
    public sealed class ObjectWpLeveled : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectWpLeveled; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;
        public bool WepExp;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
            WepExp = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
            writer.Write(WepExp);
        }
    }


    // //自写头盔显示更新封包
    public sealed class ObjectShowHelmet : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectShowHelmet; }
        }

        public uint ObjectID;
        public bool Helmetoff;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Helmetoff = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Helmetoff);
        }
    }


    public sealed class ObjectHarvest : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectHarvest; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }
    public sealed class ObjectHarvested : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectHarvested; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }

    }
    public sealed class ObjectNPC : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectNpc; }
        }

        public uint ObjectID;
        public string Name = string.Empty;

        public Color NameColor;
        public byte Image;
        public Point Location;
        public MirDirection Direction;
        public List<int> QuestIDs = new List<int>();
        public int NPCIndex;
        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Name = reader.ReadString();
            NameColor = Color.FromArgb(reader.ReadInt32());
            Image = reader.ReadByte();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();

            int count = reader.ReadInt32();

            for (var i = 0; i < count; i++)
                QuestIDs.Add(reader.ReadInt32());
            NPCIndex= reader.ReadInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Name);
            writer.Write(NameColor.ToArgb());
            writer.Write(Image);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);

            writer.Write(QuestIDs.Count);

            for (int i = 0; i < QuestIDs.Count; i++)
                writer.Write(QuestIDs[i]);
            writer.Write(NPCIndex);
        }
    } 
    public sealed class QueryMapNPCs : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.QueryMapNPCs; }
        }
        public int MapIndex;
        public int BigMap, MiniMap;
        public string FileName;
        public List<string> Names=new List<string>();
        public List<Point> Locations=new List<Point>();

        public List<int> MovementMaps=new List<int>();
        public List<Point> MovementLocations=new List<Point>();
        protected override void ReadPacket(BinaryReader reader)
        {
            MapIndex = reader.ReadInt32();
            BigMap = reader.ReadInt32();
            MiniMap = reader.ReadInt32();
            FileName = reader.ReadString();
            int count = reader.ReadInt32();

            for (var i = 0; i < count; i++) 
            {
                Names.Add(reader.ReadString());
                Locations.Add(new Point(reader.ReadInt32(), reader.ReadInt32()));
            }
            count = reader.ReadInt32();
            for (var i = 0; i < count; i++)
            {
                MovementMaps.Add(reader.ReadInt32());
                MovementLocations.Add(new Point(reader.ReadInt32(), reader.ReadInt32()));
            }
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(MapIndex);
            writer.Write(BigMap);
            writer.Write(MiniMap);
            writer.Write(FileName);
            writer.Write(Names.Count);
            for (int i = 0; i < Names.Count; i++) 
            {
                writer.Write(Names[i]);
                writer.Write(Locations[i].X);
                writer.Write(Locations[i].Y);
            }
            writer.Write(MovementMaps.Count);
            for (int i = 0; i < MovementMaps.Count; i++)
            {
                writer.Write(MovementMaps[i]);
                writer.Write(MovementLocations[i].X);
                writer.Write(MovementLocations[i].Y);
            }
        }
    }

    public sealed class QueryAllMaps : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.QueryAllMaps; }
        }
        public List<int> MapIndexs = new List<int>();
        public List<string> MapNames = new List<string>();
        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (var i = 0; i < count; i++)
            {
                MapIndexs.Add(reader.ReadInt32());
                MapNames.Add(reader.ReadString());
            }
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(MapIndexs.Count);
            for (int i = 0; i < MapIndexs.Count; i++)
            {
                writer.Write(MapIndexs[i]);
                writer.Write(MapNames[i]);
            }
        }
    }


    public sealed class NPCResponse : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCResponse; } }

        public List<string> Page;

        protected override void ReadPacket(BinaryReader reader)
        {
            Page = new List<string>();

            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                Page.Add(reader.ReadString());
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Page.Count);

            for (int i = 0; i < Page.Count; i++)
                writer.Write(Page[i]);
        }
    }
    public sealed class NPCDocument : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCDocument; } }

        public string Html;

        protected override void ReadPacket(BinaryReader reader)
        {
            Html = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Html);
        }
    }
    public sealed class ObjectHide : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectHide; } }

        public uint ObjectID;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
        }
    }
    public sealed class ObjectShow : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectShow; } }

        public uint ObjectID;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
        }
    }
    public sealed class Poisoned : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.Poisoned; } }

        public PoisonType Poison;

        protected override void ReadPacket(BinaryReader reader)
        {
            Poison = (PoisonType)reader.ReadUInt16();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((ushort)Poison);
        }
    }
    public sealed class ObjectPoisoned : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectPoisoned; } }

        public uint ObjectID;
        public PoisonType Poison;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Poison = (PoisonType)reader.ReadUInt16();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write((ushort)Poison);
        }
    }
    public sealed class MapChanged : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.MapChanged; }
        }

        public string FileName = string.Empty;
        public string Title = string.Empty;
        public ushort MiniMap, BigMap, Music;
        public LightSetting Lights;
        public Point Location;
        public MirDirection Direction;
        public byte MapDarkLight;
        public int MapIndex;

        protected override void ReadPacket(BinaryReader reader)
        {
            FileName = reader.ReadString();
            Title = reader.ReadString();
            MiniMap = reader.ReadUInt16();
            BigMap = reader.ReadUInt16();
            Lights = (LightSetting)reader.ReadByte();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
            MapDarkLight = reader.ReadByte();
            Music = reader.ReadUInt16();
            MapIndex = reader.ReadInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(FileName);
            writer.Write(Title);
            writer.Write(MiniMap);
            writer.Write(BigMap);
            writer.Write((byte)Lights);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
            writer.Write(MapDarkLight);
            writer.Write(Music);
            writer.Write(MapIndex);
        }
    }
    public sealed class ObjectTeleportOut : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectTeleportOut; } }

        public uint ObjectID;
        public byte Type;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Type = reader.ReadByte();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Type);
        }
    }
    public sealed class ObjectTeleportIn : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectTeleportIn; } }

        public uint ObjectID;
        public byte Type;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Type = reader.ReadByte();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Type);
        }
    }
    public sealed class TeleportIn : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.TeleportIn; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }

    public sealed class NPCSelectGoods : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCSelectGoods; } }

        public List<UserItem> Items = new List<UserItem>();
        public float Rate;


        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                Items.Add(new UserItem(reader));

            Rate = reader.ReadSingle();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Items.Count);
            for (int i = 0; i < Items.Count; i++)
                Items[i].Save(writer);
            writer.Write(Rate);
        }
    }


    public sealed class NPCGoods : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCGoods; } }

        public List<UserItem> List = new List<UserItem>();
        public float Rate;
        public bool IsBuyBack = false;
        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                List.Add(new UserItem(reader));

            Rate = reader.ReadSingle();
            IsBuyBack = reader.ReadBoolean();
            //IsCanBuyUsed = reader.ReadBoolean();
            //count= reader.ReadInt32();
            //for (int i = 0; i < count; i++)
            //    UsedList.Add(new UserItem(reader));

        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(List.Count);
            for (int i = 0; i < List.Count; i++)
                List[i].Save(writer);
            writer.Write(Rate);
            writer.Write(IsBuyBack);
            //writer.Write(IsCanBuyUsed);
            //writer.Write(UsedList.Count);

            //for (int i = 0; i < UsedList.Count; i++)
            //    UsedList[i].Save(writer);
        }
    }
    public sealed class StartMACUpgrade : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.StartMACUpgrade; } }
        public string MACValue;
        public List<int> ItemList1=new List<int>();
        public List<int> ItemList2=new List<int>();
        protected override void ReadPacket(BinaryReader reader)
        {
            MACValue = reader.ReadString();
            int count= reader.ReadInt32();
            for (int i = 0; i < count; i++)
            {
                ItemList1.Add(reader.ReadInt32());
            }
            count = reader.ReadInt32();
            for (int i = 0; i < count; i++)
            {
                ItemList2.Add(reader.ReadInt32());
            }

        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(MACValue);
            writer.Write(ItemList1.Count);
            for (int i = 0; i < ItemList1.Count; i++) 
            {
                writer.Write(ItemList1[i]);
            }
            writer.Write(ItemList2.Count);
            for (int i = 0; i < ItemList2.Count; i++)
            {
                writer.Write(ItemList2[i]);
            }

        }
    }
    public sealed class ClearMACUpgrade : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ClearMACUpgrade; } }
        public string MACValue;
        protected override void ReadPacket(BinaryReader reader)
        {
            MACValue = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(MACValue);
        }
    }

    public sealed class MACUpgradeResult : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MACUpgradeResult; } }
        public int result;
        protected override void ReadPacket(BinaryReader reader)
        {
            result=reader.ReadInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(result);
        }
    }

    public sealed class NPCSell : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCSell; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class NPCRepair : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCRepair; } }
        public float Rate;

        protected override void ReadPacket(BinaryReader reader)
        {
            Rate = reader.ReadSingle();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Rate);
        }
    }
    public sealed class NPCSRepair : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCSRepair; } }

        public float Rate;

        protected override void ReadPacket(BinaryReader reader)
        {
            Rate = reader.ReadSingle();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Rate);
        }
    }

    public sealed class NPCRefine : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCRefine; } }

        public float Rate;
        public bool Refining;

        protected override void ReadPacket(BinaryReader reader)
        {
            Rate = reader.ReadSingle();
            Refining = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Rate);
            writer.Write(Refining);
        }
    }

    public sealed class NPCCheckRefine : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCCheckRefine; } }


        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }

    public sealed class NPCCollectRefine : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCCollectRefine; } }

        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            Success = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Success);
        }
    }

    public sealed class NPCReplaceWedRing : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCReplaceWedRing; } }

        public float Rate;

        protected override void ReadPacket(BinaryReader reader)
        {
            Rate = reader.ReadSingle();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Rate);
        }
    }

    public sealed class NPCStorage : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCStorage; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class SellItem : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.SellItem; } }

        public ulong UniqueID;
        public uint Count;
        public bool Success;

        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
            Count = reader.ReadUInt32();
            Success = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
            writer.Write(Count);
            writer.Write(Success);
        }
    }
    public sealed class RepairItem : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.RepairItem; } }

        public ulong UniqueID;

        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
        }
    }
    public sealed class ItemRepaired : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ItemRepaired; } }

        public ulong UniqueID;
        public int MaxDura, CurrentDura;

        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
            MaxDura = reader.ReadInt32();
            CurrentDura = reader.ReadInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
            writer.Write(MaxDura);
            writer.Write(CurrentDura);
        }
    }


    public sealed class NewMagic : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.NewMagic; }
        }

        public ClientMagic Magic;
        protected override void ReadPacket(BinaryReader reader)
        {
            Magic = new ClientMagic(reader);
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            Magic.Save(writer);
        }
    }
    public sealed class RemoveMagic : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.RemoveMagic; }
        }

        public int PlaceId;
        protected override void ReadPacket(BinaryReader reader)
        {
            PlaceId = reader.ReadInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(PlaceId);
        }

    }
    public sealed class MagicLeveled : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.MagicLeveled; }
        }

        public Spell Spell;
        public byte Level;
        public ushort Experience;

        protected override void ReadPacket(BinaryReader reader)
        {
            Spell = (Spell)reader.ReadByte();
            Level = reader.ReadByte();
            Experience = reader.ReadUInt16();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Spell);
            writer.Write(Level);
            writer.Write(Experience);
        }
    }

    public sealed class Magic : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.Magic; } }

        public Spell Spell;
        public uint TargetID;
        public Point Target;
        public bool Cast;
        public byte Level;

        protected override void ReadPacket(BinaryReader reader)
        {
            Spell = (Spell)reader.ReadByte();
            TargetID = reader.ReadUInt32();
            Target = new Point(reader.ReadInt32(), reader.ReadInt32());
            Cast = reader.ReadBoolean();
            Level = reader.ReadByte();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Spell);
            writer.Write(TargetID);
            writer.Write(Target.X);
            writer.Write(Target.Y);
            writer.Write(Cast);
            writer.Write(Level);
        }
    }
    public sealed class MagicDelay : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MagicDelay; } }

        public Spell Spell;
        public long Delay;

        protected override void ReadPacket(BinaryReader reader)
        {
            Spell = (Spell)reader.ReadByte();
            Delay = reader.ReadInt64();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Spell);
            writer.Write(Delay);
        }
    }
    public sealed class MagicCast : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MagicCast; } }

        public Spell Spell;

        protected override void ReadPacket(BinaryReader reader)
        {
            Spell = (Spell)reader.ReadByte();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Spell);
        }
    }

    public sealed class ObjectMagic : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectMagic; } }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;

        public Spell Spell;
        public uint TargetID;
        public Point Target;
        public bool Cast;
        public byte Level;
        public bool SelfBroadcast = false;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();

            Spell = (Spell)reader.ReadByte();
            TargetID = reader.ReadUInt32();
            Target = new Point(reader.ReadInt32(), reader.ReadInt32());
            Cast = reader.ReadBoolean();
            Level = reader.ReadByte();
            SelfBroadcast = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);

            writer.Write((byte)Spell);
            writer.Write(TargetID);
            writer.Write(Target.X);
            writer.Write(Target.Y);
            writer.Write(Cast);
            writer.Write(Level);
            writer.Write(SelfBroadcast);
        }
    }



    public sealed class ObjectEffect : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectEffect; } }

        public uint ObjectID;
        public SpellEffect Effect;
        public uint EffectType;
        public uint DelayTime = 0;
        public uint Time = 0;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Effect = (SpellEffect)reader.ReadByte();
            EffectType = reader.ReadUInt32();
            DelayTime = reader.ReadUInt32();
            Time = reader.ReadUInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write((byte)Effect);
            writer.Write(EffectType);
            writer.Write(DelayTime);
            writer.Write(Time);
        }
    }
    public sealed class RangeAttack : Packet //ArcherTest
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.RangeAttack; } }

        public uint TargetID;
        public Point Target;
        public Spell Spell;

        protected override void ReadPacket(BinaryReader reader)
        {
            TargetID = reader.ReadUInt32();
            Target = new Point(reader.ReadInt32(), reader.ReadInt32());
            Spell = (Spell)reader.ReadByte();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(TargetID);
            writer.Write(Target.X);
            writer.Write(Target.Y);
            writer.Write((byte)Spell);
        }
    }

    public sealed class Pushed : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.Pushed; }
        }

        public Point Location;
        public MirDirection Direction;


        protected override void ReadPacket(BinaryReader reader)
        {
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }
    public sealed class ObjectPushed : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectPushed; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }
    public sealed class ObjectName : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectName; } }

        public uint ObjectID;
        public string Name = string.Empty;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Name = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Name);
        }
    }
    public sealed class UserStorage : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.UserStorage; } }

        public UserItem[] Storage;
        public List<bool> StorageBox;
        protected override void ReadPacket(BinaryReader reader)
        {
            if (!reader.ReadBoolean()) return;

            Storage = new UserItem[reader.ReadInt32()];
            for (int i = 0; i < Storage.Length; i++)
            {
                if (!reader.ReadBoolean()) continue;
                Storage[i] = new UserItem(reader);
            }

            int count=reader.ReadInt32();
            StorageBox= new List<bool>();
            for (int i = 0; i < count; i++)
            {
                StorageBox.Add(reader.ReadBoolean());
            }


        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Storage != null);
            if (Storage == null) return;

            writer.Write(Storage.Length);
            for (int i = 0; i < Storage.Length; i++)
            {
                writer.Write(Storage[i] != null);
                if (Storage[i] == null) continue;

                Storage[i].Save(writer);
            }

            writer.Write(StorageBox.Count);
            for (int i = 0; i < StorageBox.Count; i++)
            {
                writer.Write(StorageBox[i]);
            }


        }
    }
    public sealed class SwitchGroup : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.SwitchGroup; } }

        public bool AllowGroup;
        protected override void ReadPacket(BinaryReader reader)
        {
            AllowGroup = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(AllowGroup);
        }
    }
    public sealed class DeleteGroup : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.DeleteGroup; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class DeleteMember : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.DeleteMember; } }

        public string Name = string.Empty;
        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Name);
        }
    }


    public sealed class MemberLocation : Packet     //广播组队位置包类
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MemberLocation; } }

        public Point Location;
        public int CurrentMapIndex;
        public uint ObjectID;
        public string Name;
        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            CurrentMapIndex = reader.ReadInt32();
            Name = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write(CurrentMapIndex);
            writer.Write(Name);
        }


    }



    public sealed class GroupInvite : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.GroupInvite; } }

        public string Name = string.Empty;
        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Name);
        }
    }
    public sealed class AddMember : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.AddMember; } }

        public string Name = string.Empty;
        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(string.IsNullOrEmpty(Name)?"":Name);
        }
    }

    public sealed class EnterAlive : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.EnterAlive; }
        }
        public byte[] tag;
        protected override void ReadPacket(BinaryReader reader)
        {
            tag = reader.ReadBytes(8);
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(tag);
        }
    }

    public sealed class Revived : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.Revived; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class ObjectRevived : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectRevived; } }
        public uint ObjectID;
        public bool Effect;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Effect = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Effect);
        }
    }
    public sealed class SpellToggle : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.SpellToggle; } }
        public Spell Spell;
        public bool CanUse;

        protected override void ReadPacket(BinaryReader reader)
        {
            Spell = (Spell)reader.ReadByte();
            CanUse = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Spell);
            writer.Write(CanUse);
        }
    }
    public sealed class ObjectHealth : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectHealth; } }
        public uint ObjectID;
        public byte Percent, Expire;
        public uint HP, MaxHP;
        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Percent = reader.ReadByte();
            Expire = reader.ReadByte();
            HP = reader.ReadUInt32();
            MaxHP = reader.ReadUInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Percent);
            writer.Write(Expire);
            writer.Write(HP);
            writer.Write(MaxHP);
        }
    }
    public sealed class MapEffect : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MapEffect; } }

        public Point Location;
        public SpellEffect Effect;
        public byte Value;

        protected override void ReadPacket(BinaryReader reader)
        {
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Effect = (SpellEffect)reader.ReadByte();
            Value = reader.ReadByte();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Effect);
            writer.Write(Value);
        }
    }
    public sealed class ObjectRangeAttack : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectRangeAttack; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;
        public uint TargetID;
        public Point Target;
        public byte Type;
        public Spell Spell;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
            TargetID = reader.ReadUInt32();
            Target = new Point(reader.ReadInt32(), reader.ReadInt32());
            Type = reader.ReadByte();
            Spell = (Spell)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
            writer.Write(TargetID);
            writer.Write(Target.X);
            writer.Write(Target.Y);
            writer.Write(Type);
            writer.Write((byte)Spell);
        }
    }
    public sealed class AddBuff : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.AddBuff; } }

        public BuffType Type;
        public string Caster = string.Empty;
        public uint ObjectID;
        public bool Visible;
        public long Expire;
        public int[] Values;
        public bool Infinite;

        protected override void ReadPacket(BinaryReader reader)
        {
            Type = (BuffType)reader.ReadByte();
            Caster = reader.ReadString();
            Visible = reader.ReadBoolean();
            ObjectID = reader.ReadUInt32();
            Expire = reader.ReadInt64();

            Values = new int[reader.ReadInt32()];
            for (int i = 0; i < Values.Length; i++)
            {
                Values[i] = reader.ReadInt32();
            }

            Infinite = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Type);
            writer.Write(Caster);
            writer.Write(Visible);
            writer.Write(ObjectID);
            writer.Write(Expire);

            writer.Write(Values.Length);
            for (int i = 0; i < Values.Length; i++)
            {
                writer.Write(Values[i]);
            }

            writer.Write(Infinite);
        }
    }
    public sealed class RemoveBuff : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.RemoveBuff; } }

        public BuffType Type;
        public uint ObjectID;

        protected override void ReadPacket(BinaryReader reader)
        {
            Type = (BuffType)reader.ReadByte();
            ObjectID = reader.ReadUInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Type);
            writer.Write(ObjectID);
        }
    }
    public sealed class ObjectHidden : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectHidden; } }
        public uint ObjectID;
        public bool Hidden;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Hidden = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Hidden);
        }
    }
    public sealed class ObjectSpHidden : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectSpHidden; } }
        public uint ObjectID;
        public bool SpHidden;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            SpHidden = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(SpHidden);
        }
    }



    public sealed class RefreshItem : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.RefreshItem; } }
        public UserItem Item;
        protected override void ReadPacket(BinaryReader reader)
        {
            Item = new UserItem(reader);

        }
        protected override void WritePacket(BinaryWriter writer)
        {
            Item.Save(writer);
        }
    }

    public sealed class RefreshHair : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.RefreshHair; } }
        public byte hair;
        public Color hairColor;

        protected override void ReadPacket(BinaryReader reader)
        {
            hair = reader.ReadByte();
            hairColor = Color.FromArgb(reader.ReadInt32());
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(hair);
            writer.Write(hairColor.ToArgb());
        }
    }


    public sealed class ObjectRefreshHair : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectRefreshHair; }
        }

        public uint ObjectID;
        public byte hair;
        public Color hairColor;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            hair = reader.ReadByte();
            hairColor = Color.FromArgb(reader.ReadInt32());
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(hair);
            writer.Write(hairColor.ToArgb());
        }
    }


    public sealed class ObjectSpell : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectSpell; }
        }

        public uint ObjectID;
        public Point Location;
        public Spell Spell;
        public MirDirection Direction;
        public bool Param;
        public long ExpireTime;      //添加返回地面魔法持续时间数据包

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Spell = (Spell)reader.ReadByte();
            Direction = (MirDirection)reader.ReadByte();
            Param = reader.ReadBoolean();
            ExpireTime = reader.ReadInt64();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Spell);
            writer.Write((byte)Direction);
            writer.Write(Param);
            writer.Write(ExpireTime);
        }
    }
    public sealed class UserDash : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.UserDash; }
        }

        public Point Location;
        public MirDirection Direction;


        protected override void ReadPacket(BinaryReader reader)
        {
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }
    public sealed class ObjectDash : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectDash; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;


        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }
    public sealed class UserDashFail : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.UserDashFail; }
        }

        public Point Location;
        public MirDirection Direction;


        protected override void ReadPacket(BinaryReader reader)
        {
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }
    public sealed class ObjectDashFail : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectDashFail; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;


        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }
    public sealed class RemoveDelayedExplosion : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.RemoveDelayedExplosion; } }

        public uint ObjectID;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
        }
    }

    public sealed class ZanZhuChangeName : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ZanZhuChangeName; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class NPCConsign : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCConsign; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class NPCMarket : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCMarket; } }

        public List<ClientAuction> Listings = new List<ClientAuction>();
        public int Pages;
        public bool UserMode;

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                Listings.Add(new ClientAuction(reader));

            Pages = reader.ReadInt32();
            UserMode = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Listings.Count);

            for (int i = 0; i < Listings.Count; i++)
                Listings[i].Save(writer);

            writer.Write(Pages);
            writer.Write(UserMode);
        }
    }

    public sealed class ExchangeConfigSearch : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ExchangeConfigSearch; } }
        public string ExchangeConfigsJson;

        protected override void ReadPacket(BinaryReader reader)
        {
            ExchangeConfigsJson = reader.ReadString();
            //int count = reader.ReadInt32();
            //for (int i = 0; i < count; i++)
            //{
            //    ItemInfos.Add(new UserItem(reader));
            //}
            //int count = reader.ReadInt32();
            //ExchangeConfigsJson = "";
            //for (int i = 0; i < count; i++) 
            //{
            //    ExchangeConfigsJson += reader.ReadString();
            //}

        }
        protected override void WritePacket(BinaryWriter writer)
        {
            //writer.Write(ExchangeConfigsJson.Length / 1000+1);


            //for (int i = 0; i < ExchangeConfigsJson.Length; i+=1000)
            //{
            //    if (i+1000>= ExchangeConfigsJson.Length)
            //    {
            //        writer.Write(ExchangeConfigsJson.Substring(i, i + 1000));
            //    }
            //    else
            //    {
            //        writer.Write(ExchangeConfigsJson.Substring(i, ExchangeConfigsJson.Length));
            //    }
            //}
            writer.Write(ExchangeConfigsJson);
            //writer.Write(ItemInfos.Count);
            //for (int i = 0; i < ItemInfos.Count; i++)
            //{
            //    ItemInfos[i].Save(writer);
            //}
        }
    }
    public sealed class ItemProtectStart : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ItemProtectStart; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class GameShopSearch : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.GameShopSearch; } }
        public string GameItemsJson;
        public List<UserItem> GoodsInfos = new List<UserItem>();

        protected override void ReadPacket(BinaryReader reader)
        {
            GameItemsJson= reader.ReadString();
            int count= reader.ReadInt32();
            for (int i = 0; i < count; i++)
            {
                GoodsInfos.Add(new UserItem(reader));
            }
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(GameItemsJson);
            writer.Write(GoodsInfos.Count);
            for (int i = 0; i < GoodsInfos.Count; i++)
            {
                GoodsInfos[i].Save(writer);
            }
        }
    }

    public sealed class AuctionGroups : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.AuctionGroups; } }

        public List<ItemInfo> ItemInfos = new List<ItemInfo>();
        public List<int> Counts= new List<int>();  

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                ItemInfos.Add(new ItemInfo(reader));
            for (int i = 0; i < count; i++)
                Counts.Add(reader.ReadInt32());
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ItemInfos.Count);
            for (int i = 0; i < ItemInfos.Count; i++)
                ItemInfos[i].Save(writer);
            for (int i = 0; i < ItemInfos.Count; i++)
                writer.Write(Counts[i]);
        }
    }

    public sealed class ItemAuctionSearch : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ItemAuctionSearch; } }

        public List<ClientAuction> Auctions = new List<ClientAuction>();

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                Auctions.Add(new ClientAuction(reader));
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Auctions.Count);
            for (int i = 0; i < Auctions.Count; i++)
                Auctions[i].Save(writer);
        }
    }

    public sealed class MyAuctionSearch : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MyAuctionSearch; } }

        public List<ClientAuction> Auctions = new List<ClientAuction>();

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                Auctions.Add(new ClientAuction(reader));
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Auctions.Count);
            for (int i = 0; i < Auctions.Count; i++)
                Auctions[i].Save(writer);
        }
    }
    //public sealed class GNPCMarket : Packet
    //{
    //    public override ushort Index { get { return (ushort)ServerPacketIds.GNPCMarket; } }

    //    public List<GClientAuction> Listings = new List<GClientAuction>();
    //    public int Pages;

    //    protected override void ReadPacket(BinaryReader reader)
    //    {
    //        int count = reader.ReadInt32();

    //        for (int i = 0; i < count; i++)
    //            Listings.Add(new GClientAuction(reader));

    //        Pages = reader.ReadInt32();

    //    }
    //    protected override void WritePacket(BinaryWriter writer)
    //    {
    //        writer.Write(Listings.Count);

    //        for (int i = 0; i < Listings.Count; i++)
    //            Listings[i].Save(writer);

    //        writer.Write(Pages);

    //    }
    //}




    public sealed class NPCMarketPage : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCMarketPage; } }

        public List<ClientAuction> Listings = new List<ClientAuction>();

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                Listings.Add(new ClientAuction(reader));
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Listings.Count);

            for (int i = 0; i < Listings.Count; i++)
                Listings[i].Save(writer);
        }
    }
    public sealed class ConsignItem : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ConsignItem; } }

        public ulong UniqueID; 
        public bool Success;
        public int Error;
        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
            Success = reader.ReadBoolean();
            Error = reader.ReadInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
            writer.Write(Success);
            writer.Write(Error);
        }
    }
    public sealed class MarketFail : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MarketFail; } }

        public byte Reason;

        /*
         * 0: Dead.
         * 1: Not talking to TrustMerchant.
         * 2: Already Sold.
         * 3: Expired.
         * 4: Not enough Gold.
         * 5: Too heavy or not enough bag space.
         * 6: You cannot buy your own items.
         * 7: Trust Merchant is too far.
         * 8: Too much Gold.
         */

        protected override void ReadPacket(BinaryReader reader)
        {
            Reason = reader.ReadByte();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Reason);
        }
    }
    public sealed class MarketSuccess : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MarketSuccess; } }

        public string Message = string.Empty;

        protected override void ReadPacket(BinaryReader reader)
        {
            Message = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Message);
        }
    }

    public sealed class RefreshSeasonExitTime : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.RefreshSeasonExitTime; } }
        public long Time;

        protected override void ReadPacket(BinaryReader reader)
        {
            Time=reader.ReadInt64();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Time);
        }
    }


    public sealed class ObjectSitDown : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectSitDown; } }
        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;
        public bool Sitting;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
            Sitting = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
            writer.Write(Sitting);
        }
    }
    public sealed class InTrapRock : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.InTrapRock; } }
        public bool Trapped;

        protected override void ReadPacket(BinaryReader reader)
        {
            Trapped = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Trapped);
        }
    }
    public sealed class BaseStatsInfo : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.BaseStatsInfo; }
        }

        public BaseStats Stats;

        protected override void ReadPacket(BinaryReader reader)
        {
            Stats = new BaseStats(reader);
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            Stats.Save(writer);
        }
    }

    public sealed class UserName : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.UserName; } }
        public uint Id;
        public string Name;
        protected override void ReadPacket(BinaryReader reader)
        {
            Id = reader.ReadUInt32();
            Name = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Id);
            writer.Write(Name);
        }
    }
    public sealed class ChatItemStats : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ChatItemStats; } }
        public ulong ChatItemId;
        public UserItem Stats;
        protected override void ReadPacket(BinaryReader reader)
        {
            ChatItemId = reader.ReadUInt64();
            Stats = new UserItem(reader);
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ChatItemId);
            if (Stats != null) Stats.Save(writer);
        }
    }

    public sealed class GuildNoticeChange : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GuildNoticeChange; }
        }
        public int update = 0;
        public List<string> notice = new List<string>();
        protected override void ReadPacket(BinaryReader reader)
        {
            update = reader.ReadInt32();
            for (int i = 0; i < update; i++)
                notice.Add(reader.ReadString());
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            if (update < 0)
            {
                writer.Write(update);
                return;
            }
            writer.Write(notice.Count);
            for (int i = 0; i < notice.Count; i++)
                writer.Write(notice[i]);
        }
    }

    public sealed class GuildMemberChange : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GuildMemberChange; }
        }
        public string Name = string.Empty;
        public byte Status = 0;
        public byte RankIndex = 0;
        public List<Rank> Ranks = new List<Rank>();
        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
            RankIndex = reader.ReadByte();
            Status = reader.ReadByte();
            if (Status > 5)
            {
                int rankcount = reader.ReadInt32();
                for (int i = 0; i < rankcount; i++)
                    Ranks.Add(new Rank(reader));
            }
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Name);
            writer.Write(RankIndex);
            writer.Write(Status);
            if (Status > 5)
            {
                writer.Write(Ranks.Count);
                for (int i = 0; i < Ranks.Count; i++)
                    Ranks[i].Save(writer);
            }
        }
    }

    public sealed class GetAllGuild : Packet 
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GetAllGuild; }
        }
        public List<GuildStatus> guildStatuses = new List<GuildStatus>();

        protected override void ReadPacket(BinaryReader reader)
        {
            int count=reader.ReadInt32();
            for (int i = 0; i < count; i++) 
            {
                var guild = new GuildStatus();
                guild.Read(reader);
                guildStatuses.Add(guild);
            
            }
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(guildStatuses.Count);
            for (int i = 0; i < guildStatuses.Count; i++) 
            {
                guildStatuses[i].Write(writer);
            
            }
        }
    }

    public sealed class GetAllJoinRequest : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GetAllJoinRequest; }
        }
        public List<JoinRequestInfo> JoinRequestInfos = new List<JoinRequestInfo>();

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();
            for (int i = 0; i < count; i++)
            {
                var requestInfo = new JoinRequestInfo();
                requestInfo.Read(reader);
                JoinRequestInfos.Add(requestInfo);

            }
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(JoinRequestInfos.Count);
            for (int i = 0; i < JoinRequestInfos.Count; i++)
            {
                JoinRequestInfos[i].Write(writer);

            }
        }
    }
    public sealed class JoinRequestInfo
    {
        public int Index;
        public string Name;
        public byte Class;
        public int Level;
        public DateTime RequestTime;
        public string Remark;
        public void Read(BinaryReader reader)
        {
            Index=reader.ReadInt32();
            Name=reader.ReadString();
            Class=reader.ReadByte();
            Level=reader.ReadInt32();
            RequestTime= DateTime.FromBinary(reader.ReadInt64());
            //Remark=reader.ReadString();
        }

        public void Write(BinaryWriter writer)
        {
            writer.Write(Index);
            writer.Write(Name);
            writer.Write(Class);
            writer.Write(Level);
            writer.Write(RequestTime.ToBinary());
            //writer.Write(Remark);
        }
    }

    public sealed class GuildStatus : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GuildStatus; }
        }
        public string GuildName = string.Empty;
        public string GuildRankName = string.Empty;
        public byte Level;
        public long Experience;
        public long MaxExperience;
        public uint Gold;
        public byte SparePoints;
        public int MemberCount;
        public int MaxMembers;
        public int Votes;
        public bool Voting;
        public byte ItemCount;
        public byte BuffCount;
        public RankOptions MyOptions;
        public int MyRankId;
        public int GuildIndex;
        public string Leader;
        public List<string> EnemyGuilds= new List<string>();
        protected override void ReadPacket(BinaryReader reader)
        {
            GuildName = reader.ReadString();
            GuildRankName = reader.ReadString();
            Level = reader.ReadByte();
            Experience = reader.ReadInt64();
            MaxExperience = reader.ReadInt64();
            Gold = reader.ReadUInt32();
            SparePoints = reader.ReadByte();
            MemberCount = reader.ReadInt32();
            MaxMembers = reader.ReadInt32();
            Votes = reader.ReadInt32();
            Voting = reader.ReadBoolean();
            ItemCount = reader.ReadByte();
            BuffCount = reader.ReadByte();
            MyOptions = (RankOptions)reader.ReadByte();
            MyRankId = reader.ReadInt32();
            GuildIndex = reader.ReadInt32();
            Leader = reader.ReadString();
            int count=reader.ReadInt32();
            for (int i = 0; i < count; i++)
            {
                EnemyGuilds.Add(reader.ReadString());
            }
        }
        public void Read(BinaryReader reader) 
        {
            ReadPacket(reader);
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(GuildName);
            writer.Write(GuildRankName);
            writer.Write(Level);
            writer.Write(Experience);
            writer.Write(MaxExperience);
            writer.Write(Gold);
            writer.Write(SparePoints);
            writer.Write(MemberCount);
            writer.Write(MaxMembers);
            writer.Write(Votes);
            writer.Write(Voting);
            writer.Write(ItemCount);
            writer.Write(BuffCount);
            writer.Write((byte)MyOptions);
            writer.Write(MyRankId);
            writer.Write(GuildIndex);
            writer.Write(Leader);
            writer.Write(EnemyGuilds.Count);
            for (int i = 0; i < EnemyGuilds.Count; i++)
            {
                writer.Write(EnemyGuilds[i]);
            }
        }
        public void Write(BinaryWriter writer)
        {
            WritePacket(writer);
        }
    }
    public sealed class GuildInvite : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.GuildInvite; } }

        public string Name = string.Empty;
        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Name);
        }
    }
    public sealed class GuildExpGain : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.GuildExpGain; } }

        public uint Amount = 0;
        protected override void ReadPacket(BinaryReader reader)
        {
            Amount = reader.ReadUInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Amount);
        }
    }
    public sealed class GuildNameRequest : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.GuildNameRequest; } }
        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }

    public sealed class GuildStorageGoldChange : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.GuildStorageGoldChange; } }
        public uint Amount = 0;
        public byte Type = 0;
        public string Name = string.Empty;

        protected override void ReadPacket(BinaryReader reader)
        {
            Amount = reader.ReadUInt32();
            Type = reader.ReadByte();
            Name = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Amount);
            writer.Write(Type);
            writer.Write(Name);
        }
    }
    public sealed class GuildStorageItemChange : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.GuildStorageItemChange; } }
        public int User = 0;
        public byte Type = 0;
        public int To = 0;
        public int From = 0;
        public GuildStorageItem Item = null;
        protected override void ReadPacket(BinaryReader reader)
        {
            Type = reader.ReadByte();
            To = reader.ReadInt32();
            From = reader.ReadInt32();
            User = reader.ReadInt32();
            if (!reader.ReadBoolean()) return;
            Item = new GuildStorageItem();
            Item.UserId = reader.ReadInt64();
            Item.Item = new UserItem(reader);
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Type);
            writer.Write(To);
            writer.Write(From);
            writer.Write(User);
            writer.Write(Item != null);
            if (Item == null) return;
            writer.Write(Item.UserId);
            Item.Item.Save(writer);
        }
    }
    public sealed class GuildStorageList : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GuildStorageList; }
        }
        public GuildStorageItem[] Items;
        protected override void ReadPacket(BinaryReader reader)
        {
            Items = new GuildStorageItem[reader.ReadInt32()];
            for (int i = 0; i < Items.Length; i++)
            {
                if (reader.ReadBoolean() == true)
                    Items[i] = new GuildStorageItem(reader);
            }
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Items.Length);
            for (int i = 0; i < Items.Length; i++)
            {
                writer.Write(Items[i] != null);
                if (Items[i] != null)
                    Items[i].save(writer);
            }
        }

    }
    public sealed class GuildRequestWar : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.GuildRequestWar; } }
        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class DefaultNPC : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.DefaultNPC; } }

        public uint ObjectID;
        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
        }
    }

    public sealed class NPCUpdate : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCUpdate; } }

        public uint NPCID;

        protected override void ReadPacket(BinaryReader reader)
        {
            NPCID = reader.ReadUInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(NPCID);
        }
    }

    public sealed class MountUpdate : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MountUpdate; } }

        public long ObjectID;
        public short MountType;
        public bool RidingMount;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadInt64();
            MountType = reader.ReadInt16();
            RidingMount = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(MountType);
            writer.Write(RidingMount);
        }
    }

    public sealed class TransformUpdate : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.TransformUpdate; } }

        public long ObjectID;
        public short TransformType;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadInt64();
            TransformType = reader.ReadInt16();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(TransformType);
        }
    }

    public sealed class EquipSlotItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.EquipSlotItem; }
        }

        public MirGridType Grid;
        public ulong UniqueID;
        public int To;
        public bool Success;
        public MirGridType GridTo;

        protected override void ReadPacket(BinaryReader reader)
        {
            Grid = (MirGridType)reader.ReadByte();
            UniqueID = reader.ReadUInt64();
            To = reader.ReadInt32();
            GridTo = (MirGridType)reader.ReadByte();
            Success = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)Grid);
            writer.Write(UniqueID);
            writer.Write(To);
            writer.Write((byte)GridTo);
            writer.Write(Success);
        }
    }

    public sealed class FishingUpdate : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.FishingUpdate; } }

        public long ObjectID;
        public bool Fishing;
        public int ProgressPercent;
        public int ChancePercent;
        public Point FishingPoint;
        public bool FoundFish;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadInt64();
            Fishing = reader.ReadBoolean();
            ProgressPercent = reader.ReadInt32();
            ChancePercent = reader.ReadInt32();
            FishingPoint = new Point(reader.ReadInt32(), reader.ReadInt32());
            FoundFish = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Fishing);
            writer.Write(ProgressPercent);
            writer.Write(ChancePercent);
            writer.Write(FishingPoint.X);
            writer.Write(FishingPoint.Y);
            writer.Write(FoundFish);
        }
    }

    //public sealed class UpdateQuests : Packet
    //{
    //    public override ushort Index
    //    {
    //        get { return (ushort)ServerPacketIds.UpdateQuests; }
    //    }

    //    public List<ClientQuestProgress> CurrentQuests = new List<ClientQuestProgress>();
    //    public List<int> CompletedQuests = new List<int>();

    //    protected override void ReadPacket(BinaryReader reader)
    //    {
    //        int count = reader.ReadInt32();
    //        for (var i = 0; i < count; i++)
    //            CurrentQuests.Add(new ClientQuestProgress(reader));

    //        count = reader.ReadInt32();
    //        for (var i = 0; i < count; i++)
    //            CompletedQuests.Add(reader.ReadInt32());
    //    }
    //    protected override void WritePacket(BinaryWriter writer)
    //    {
    //        writer.Write(CurrentQuests.Count);
    //        foreach (var q in CurrentQuests)
    //            q.Save(writer);

    //        writer.Write(CompletedQuests.Count);
    //        foreach (int q in CompletedQuests)
    //            writer.Write(q);
    //    }
    //}


    public sealed class ChangeQuest : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ChangeQuest; }
        }

        public ClientQuestProgress Quest = new ClientQuestProgress();
        public QuestState QuestState;
        public bool TrackQuest;

        protected override void ReadPacket(BinaryReader reader)
        {
            Quest = new ClientQuestProgress(reader);
            QuestState = (QuestState)reader.ReadByte();
            TrackQuest = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            Quest.Save(writer);
            writer.Write((byte)QuestState);
            writer.Write(TrackQuest);
        }
    }

    public sealed class CompleteQuest : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.CompleteQuest; }
        }

        public List<int> CompletedQuests = new List<int>();

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();
            for (var i = 0; i < count; i++)
                CompletedQuests.Add(reader.ReadInt32());
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(CompletedQuests.Count);
            foreach (int q in CompletedQuests)
                writer.Write(q);
        }
    }

    public sealed class ShareQuest : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ShareQuest; }
        }

        public int QuestIndex;
        public string SharerName;

        protected override void ReadPacket(BinaryReader reader)
        {
            QuestIndex = reader.ReadInt32();
            SharerName = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(QuestIndex);
            writer.Write(SharerName);
        }
    }


    public sealed class NewQuestInfo : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.NewQuestInfo; }
        }

        public ClientQuestInfo Info;

        protected override void ReadPacket(BinaryReader reader)
        {
            Info = new ClientQuestInfo(reader);
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            Info.Save(writer);
        }
    }

    public sealed class GainedQuestItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GainedQuestItem; }
        }

        public UserItem Item;

        protected override void ReadPacket(BinaryReader reader)
        {
            Item = new UserItem(reader);
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            Item.Save(writer);
        }
    }

    public sealed class DeleteQuestItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.DeleteQuestItem; }
        }

        public ulong UniqueID;
        public uint Count;

        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
            Count = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
            writer.Write(Count);
        }
    }

    public sealed class GameShopInfo : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GameShopInfo; }
        }

        public GameShopItem Item;
        public int StockLevel;

        protected override void ReadPacket(BinaryReader reader)
        {
            Item = new GameShopItem(reader, true);
            StockLevel = reader.ReadInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            Item.Save(writer, true);
            writer.Write(StockLevel);
        }
    }

    public sealed class GameShopStock : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.GameShopStock; }
        }

        public int GIndex;
        public int StockLevel;

        protected override void ReadPacket(BinaryReader reader)
        {
            GIndex = reader.ReadInt32();
            StockLevel = reader.ReadInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(GIndex);
            writer.Write(StockLevel);
        }
    }

    public sealed class CancelReincarnation : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.CancelReincarnation; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }

    public sealed class RequestReincarnation : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.RequestReincarnation; } }


        protected override void ReadPacket(BinaryReader reader)
        {
        }

        protected override void WritePacket(BinaryWriter writer)
        {
        }

    }

    public sealed class UserBackStep : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.UserBackStep; }
        }

        public Point Location;
        public MirDirection Direction;


        protected override void ReadPacket(BinaryReader reader)
        {
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }

    public sealed class ObjectBackStep : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectBackStep; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;
        public int Distance;


        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
            Distance = reader.ReadInt16();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
            writer.Write(Distance);
        }
    }

    public sealed class UserDashAttack : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.UserDashAttack; }
        }

        public Point Location;
        public MirDirection Direction;

        protected override void ReadPacket(BinaryReader reader)
        {
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }

    public sealed class ObjectDashAttack : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectDashAttack; }
        }

        public uint ObjectID;
        public Point Location;
        public MirDirection Direction;
        public int Distance;


        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
            Distance = reader.ReadInt16();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
            writer.Write(Distance);
        }
    }

    public sealed class UserAttackMove : Packet//warrior skill - SlashingBurst move packet 
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.UserAttackMove; }
        }


        public Point Location;
        public MirDirection Direction;

        protected override void ReadPacket(BinaryReader reader)
        {
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Direction = (MirDirection)reader.ReadByte();
        }


        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write((byte)Direction);
        }
    }

    public sealed class CombineItem : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.CombineItem; }
        }

        public ulong IDFrom, IDTo;
        public bool Success;
        public bool Destroy;

        protected override void ReadPacket(BinaryReader reader)
        {
            IDFrom = reader.ReadUInt64();
            IDTo = reader.ReadUInt64();
            Success = reader.ReadBoolean();
            Destroy = reader.ReadBoolean();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(IDFrom);
            writer.Write(IDTo);
            writer.Write(Success);
            writer.Write(Destroy);
        }
    }

    public sealed class ItemUpgraded : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ItemUpgraded; }
        }

        public UserItem Item;

        protected override void ReadPacket(BinaryReader reader)
        {
            Item = new UserItem(reader);
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            Item.Save(writer);
        }
    }

    public sealed class SetConcentration : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.SetConcentration; } }

        public uint ObjectID;
        public bool Enabled;
        public bool Interrupted;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Enabled = reader.ReadBoolean();
            Interrupted = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Enabled);
            writer.Write(Interrupted);
        }
    }
    public sealed class SetObjectConcentration : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.SetObjectConcentration; } }

        public uint ObjectID;
        public bool Enabled;
        public bool Interrupted;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Enabled = reader.ReadBoolean();
            Interrupted = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Enabled);
            writer.Write(Interrupted);
        }
    }
    public sealed class SetElemental : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.SetElemental; } }

        public uint ObjectID;
        public bool Enabled;
        public uint Value;
        public uint ElementType;
        public uint ExpLast;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Enabled = reader.ReadBoolean();
            Value = reader.ReadUInt32();
            ElementType = reader.ReadUInt32();
            ExpLast = reader.ReadUInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Enabled);
            writer.Write(Value);
            writer.Write(ElementType);
            writer.Write(ExpLast);
        }
    }
    public sealed class SetObjectElemental : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.SetObjectElemental; } }

        public uint ObjectID;
        public bool Enabled;
        public bool Casted;
        public uint Value;
        public uint ElementType;
        public uint ExpLast;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Enabled = reader.ReadBoolean();
            Casted = reader.ReadBoolean();
            Value = reader.ReadUInt32();
            ElementType = reader.ReadUInt32();
            ExpLast = reader.ReadUInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Enabled);
            writer.Write(Casted);
            writer.Write(Value);
            writer.Write(ElementType);
            writer.Write(ExpLast);
        }
    }

    public sealed class ObjectDeco : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ObjectDeco; }
        }

        public uint ObjectID;
        public Point Location;
        public ushort Image;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Location = new Point(reader.ReadInt32(), reader.ReadInt32());
            Image = reader.ReadUInt16();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Location.X);
            writer.Write(Location.Y);
            writer.Write(Image);
        }
    }
    public sealed class ObjectSneaking : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectSneaking; } }
        public uint ObjectID;
        public bool SneakingActive;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            SneakingActive = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(SneakingActive);
        }
    }

    public sealed class ObjectLevelEffects : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ObjectLevelEffects; } }

        public uint ObjectID;
        public LevelEffects LevelEffects;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            LevelEffects = (LevelEffects)reader.ReadByte();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write((byte)LevelEffects);
        }
    }

    public sealed class SetBindingShot : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.SetBindingShot; } }

        public uint ObjectID;
        public bool Enabled;
        public long Value;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
            Enabled = reader.ReadBoolean();
            Value = reader.ReadInt64();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
            writer.Write(Enabled);
            writer.Write(Value);
        }
    }

    public sealed class SendOutputMessage : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.SendOutputMessage; } }

        public string Message;
        public OutputMessageType Type;

        protected override void ReadPacket(BinaryReader reader)
        {
            Message = reader.ReadString();
            Type = (OutputMessageType)reader.ReadByte();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Message);
            writer.Write((byte)Type);
        }
    }
    public sealed class NPCAwakening : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCAwakening; } }
        public string AwakeInfosJson;
        protected override void ReadPacket(BinaryReader reader)
        {
            AwakeInfosJson = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(AwakeInfosJson);
        }
    }
    public sealed class NPCUnAwaken : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCUnAwaken; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class NPCDisassemble : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCDisassemble; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class NPCDowngrade : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCDowngrade; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class NPCReset : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCReset; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }
        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }
    public sealed class AwakeningNeedMaterials : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.AwakeningNeedMaterials; } }

        public ItemInfo[] Materials;
        public byte[] MaterialsCount;
        public bool IsHaveEnoughMat;
        protected override void ReadPacket(BinaryReader reader)
        {
            if (!reader.ReadBoolean()) return;

            int count = reader.ReadInt32();
            Materials = new ItemInfo[count];
            MaterialsCount = new byte[count];

            for (int i = 0; i < Materials.Length; i++)
            {
                if (!reader.ReadBoolean()) continue;
                Materials[i] = new ItemInfo(reader);
                MaterialsCount[i] = reader.ReadByte();
            }
            IsHaveEnoughMat = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Materials != null);
            if (Materials == null) return;

            writer.Write(Materials.Length);
            for (int i = 0; i < Materials.Length; i++)
            {
                writer.Write(Materials[i] != null);
                if (Materials[i] == null) continue;

                Materials[i].Save(writer);
                writer.Write(MaterialsCount[i]);
            }
            writer.Write(IsHaveEnoughMat);
        }
    }

    public sealed class DropProtectNeedMaterials : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.DropProtectNeedMaterials; } }

        public ItemInfo[] Materials;
        public byte[] MaterialsCount;
        public bool IsHaveEnoughMat;
        protected override void ReadPacket(BinaryReader reader)
        {
            if (!reader.ReadBoolean()) return;

            int count = reader.ReadInt32();
            Materials = new ItemInfo[count];
            MaterialsCount = new byte[count];

            for (int i = 0; i < Materials.Length; i++)
            {
                if (!reader.ReadBoolean()) continue;
                Materials[i] = new ItemInfo(reader);
                MaterialsCount[i] = reader.ReadByte();
            }
            IsHaveEnoughMat = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Materials != null);
            if (Materials == null) return;

            writer.Write(Materials.Length);
            for (int i = 0; i < Materials.Length; i++)
            {
                writer.Write(Materials[i] != null);
                if (Materials[i] == null) continue;

                Materials[i].Save(writer);
                writer.Write(MaterialsCount[i]);
            }
            writer.Write(IsHaveEnoughMat);
        }
    }


    public sealed class AwakeningLockedItem : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.AwakeningLockedItem; } }

        public ulong UniqueID;
        public bool Locked;

        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
            Locked = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
            writer.Write(Locked);
        }
    }

    public sealed class Awakening : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.Awakening; }
        }

        public int result;
        public long removeID;        //= -1
        public ulong resultUid;
        protected override void ReadPacket(BinaryReader reader)
        {
            result = reader.ReadInt32();
            removeID = reader.ReadInt64();
            resultUid = reader.ReadUInt64();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(result);
            writer.Write(removeID);
            writer.Write(resultUid);
        }
    }

    public sealed class UnAwakening : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.UnAwakening; }
        }

        public int result;
        public long removeID;        //= -1
        public ulong resultUid;
        protected override void ReadPacket(BinaryReader reader)
        {
            result = reader.ReadInt32();
            removeID = reader.ReadInt64();
            resultUid = reader.ReadUInt64();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(result);
            writer.Write(removeID);
            writer.Write(resultUid);
        }
    }

    public sealed class ReceiveMail : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ReceiveMail; }
        }

        public List<ClientMail> Mail = new List<ClientMail>();

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            try
            {
                for (int i = 0; i < count; i++)
                {
                    System.Console.WriteLine(i);
                    Mail.Add(new ClientMail(reader));
                }

            }
            catch (Exception e)
            {
                System.Console.WriteLine( e.Message + e.StackTrace);
                throw;
            }
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Mail.Count);

            for (int i = 0; i < Mail.Count; i++)
                Mail[i].Save(writer);
        }
    }
    public sealed class MailLockedItem : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MailLockedItem; } }

        public ulong UniqueID;
        public bool Locked;

        protected override void ReadPacket(BinaryReader reader)
        {
            UniqueID = reader.ReadUInt64();
            Locked = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(UniqueID);
            writer.Write(Locked);
        }
    }

    public sealed class MailSent : Packet
    {
        public sbyte Result;

        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.MailSent; }
        }

        protected override void ReadPacket(BinaryReader reader)
        {
            Result = reader.ReadSByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Result);
        }
    }

    public sealed class MailSendRequest : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.MailSendRequest; }
        }

        protected override void ReadPacket(BinaryReader reader)
        {
        }

        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }

    public sealed class ParcelCollected : Packet
    {
        public sbyte Result;

        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.ParcelCollected; }
        }

        protected override void ReadPacket(BinaryReader reader)
        {
            Result = reader.ReadSByte();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Result);
        }
    }

    public sealed class MailCost : Packet
    {
        public uint Cost;

        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.MailCost; }
        }

        protected override void ReadPacket(BinaryReader reader)
        {
            Cost = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Cost);
        }
    }

    public sealed class ResizeInventory : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ResizeInventory; } }

        public int Size;

        protected override void ReadPacket(BinaryReader reader)
        {
            Size = reader.ReadInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Size);
        }
    }
    public sealed class NewIntelligentCreature : Packet//IntelligentCreature
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.NewIntelligentCreature; }
        }

        public ClientIntelligentCreature Creature;
        protected override void ReadPacket(BinaryReader reader)
        {
            Creature = new ClientIntelligentCreature(reader);
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            Creature.Save(writer);
        }
    }
    public sealed class UpdateIntelligentCreatureList : Packet//IntelligentCreature
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.UpdateIntelligentCreatureList; }
        }

        public List<ClientIntelligentCreature> CreatureList = new List<ClientIntelligentCreature>();
        public bool CreatureSummoned = false;
        public IntelligentCreatureType SummonedCreatureType = IntelligentCreatureType.None;
        public int PearlCount = 0;

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();
            for (int i = 0; i < count; i++)
                CreatureList.Add(new ClientIntelligentCreature(reader));
            CreatureSummoned = reader.ReadBoolean();
            SummonedCreatureType = (IntelligentCreatureType)reader.ReadByte();
            PearlCount = reader.ReadInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(CreatureList.Count);
            for (int i = 0; i < CreatureList.Count; i++)
                CreatureList[i].Save(writer);
            writer.Write(CreatureSummoned);
            writer.Write((byte)SummonedCreatureType);
            writer.Write(PearlCount);
        }
    }

    public sealed class IntelligentCreatureEnableRename : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.IntelligentCreatureEnableRename; }
        }

        protected override void ReadPacket(BinaryReader reader)
        {
        }

        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }

    public sealed class IntelligentCreaturePickup : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.IntelligentCreaturePickup; }
        }

        public uint ObjectID;

        protected override void ReadPacket(BinaryReader reader)
        {
            ObjectID = reader.ReadUInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ObjectID);
        }
    }

    public sealed class NPCPearlGoods : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCPearlGoods; } }

        public List<UserItem> List = new List<UserItem>();
        public float Rate;

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                List.Add(new UserItem(reader));

            Rate = reader.ReadSingle();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(List.Count);

            for (int i = 0; i < List.Count; i++)
                List[i].Save(writer);

            writer.Write(Rate);
        }
    }

    public sealed class FriendUpdate : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.FriendUpdate; }
        }

        public List<ClientFriend> Friends = new List<ClientFriend>();

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
                Friends.Add(new ClientFriend(reader));
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Friends.Count);

            for (int i = 0; i < Friends.Count; i++)
                Friends[i].Save(writer);
        }
    }

    public sealed class FriendRequest : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.FriendRequest; }
        }

        public string RequestName;

        protected override void ReadPacket(BinaryReader reader)
        {
            RequestName=reader.ReadString();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(RequestName);

        }
    }

    public sealed class GuildBuffList : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.GuildBuffList; } }

        public byte Remove = 0;
        public List<GuildBuff> ActiveBuffs = new List<GuildBuff>();
        public List<GuildBuffInfo> GuildBuffs = new List<GuildBuffInfo>();

        protected override void ReadPacket(BinaryReader reader)
        {
            Remove = reader.ReadByte();
            int count = reader.ReadInt32();
            for (int i = 0; i < count; i++)
                ActiveBuffs.Add(new GuildBuff(reader));
            count = reader.ReadInt32();
            for (int i = 0; i < count; i++)
                GuildBuffs.Add(new GuildBuffInfo(reader));
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Remove);
            writer.Write(ActiveBuffs.Count);
            for (int i = 0; i < ActiveBuffs.Count; i++)
                ActiveBuffs[i].Save(writer);
            writer.Write(GuildBuffs.Count);
            for (int i = 0; i < GuildBuffs.Count; i++)
                GuildBuffs[i].Save(writer);
        }
    }
    public sealed class LoverUpdate : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.LoverUpdate; }
        }

        public string Name;
        public DateTime Date;
        public string MapName;
        public short MarriedDays;

        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
            Date = DateTime.FromBinary(reader.ReadInt64());
            MapName = reader.ReadString();
            MarriedDays = reader.ReadInt16();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Name);
            writer.Write(Date.ToBinary());
            writer.Write(MapName);
            writer.Write(MarriedDays);
        }
    }

    public sealed class MentorUpdate : Packet
    {
        public override ushort Index
        {
            get { return (ushort)ServerPacketIds.MentorUpdate; }
        }

        public string Name;
        public ushort Level;
        public bool Online;
        public long MenteeEXP;

        protected override void ReadPacket(BinaryReader reader)
        {
            Name = reader.ReadString();
            Level = reader.ReadUInt16();
            Online = reader.ReadBoolean();
            MenteeEXP = reader.ReadInt64();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Name);
            writer.Write(Level);
            writer.Write(Online);
            writer.Write(MenteeEXP);
        }
    }

    public sealed class NPCRequestInput : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.NPCRequestInput; } }

        public uint NPCID;
        public string PageName;

        protected override void ReadPacket(BinaryReader reader)
        {
            NPCID = reader.ReadUInt32();
            PageName = reader.ReadString();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(NPCID);
            writer.Write(PageName);
        }
    }

    public sealed class Rankings : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.Rankings; } }

        public byte RankType = 0;
        public int MyRank = 0;
        public List<Rank_Character_Info> Listings = new List<Rank_Character_Info>();

        protected override void ReadPacket(BinaryReader reader)
        {
            RankType = reader.ReadByte();
            MyRank = reader.ReadInt32();
            int count = reader.ReadInt32();
            for (int i = 0; i < count; i++)
            {
                Listings.Add(new Rank_Character_Info(reader));
            }
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(RankType);
            writer.Write(MyRank);
            writer.Write(Listings.Count);
            for (int i = 0; i < Listings.Count; i++)
                Listings[i].Save(writer);
        }
    }

    public sealed class Opendoor : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.Opendoor; } }

        public bool Close = false;
        public byte DoorIndex;

        protected override void ReadPacket(BinaryReader reader)
        {
            DoorIndex = reader.ReadByte();
            Close = reader.ReadBoolean();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(DoorIndex);
            writer.Write(Close);
        }
    }


    public sealed class ReshRecipes : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ReshRecipes; } }

        public List<int> Recipes = new List<int>();

        protected override void ReadPacket(BinaryReader reader)
        {
            int count = reader.ReadInt32();

            for (var i = 0; i < count; i++)
                Recipes.Add(reader.ReadInt32());
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(Recipes.Count);

            for (int i = 0; i < Recipes.Count; i++)
                writer.Write(Recipes[i]);
        }


    }


    public sealed class AboutToQuest : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.AboutToQuest; } }

        public QuestState questState = QuestState.None;

        public int questindex = 0;

        protected override void ReadPacket(BinaryReader reader)
        {
            questState = (QuestState)reader.ReadByte();
            questindex = reader.ReadInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write((byte)questState);
            writer.Write(questindex);
        }
    }

    public sealed class ServerArea : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.ServerArea; } }

        public string areas = "";

        protected override void ReadPacket(BinaryReader reader)
        {
            areas = reader.ReadString();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(areas);
        }
    }

    public sealed class OpenJyxt : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.OpenJyxt; } }

        protected override void ReadPacket(BinaryReader reader)
        {
        }

        protected override void WritePacket(BinaryWriter writer)
        {
        }
    }


    public sealed class InitialItem : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.InitialItem; } }

        public int result = 0;

        protected override void ReadPacket(BinaryReader reader)
        {
            result = reader.ReadInt32();
        }

        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(result);
        }
    }

    public sealed class MoveShield : Packet
    {
        public override ushort Index { get { return (ushort)ServerPacketIds.MoveShield; } }

        public string ShieldID;
        public int SessionID;
        public string NewShieldIP;
        public int NewShieldPort;

        protected override void ReadPacket(BinaryReader reader)
        {
            ShieldID = reader.ReadString();
            SessionID = reader.ReadInt32();
            NewShieldIP = reader.ReadString();
            NewShieldPort = reader.ReadInt32();
        }
        protected override void WritePacket(BinaryWriter writer)
        {
            writer.Write(ShieldID);
            writer.Write(SessionID);
            writer.Write(NewShieldIP);
            writer.Write(NewShieldPort);
        }
    }
}