Register for your free account! | Forgot your password?

Go Back   elitepvpers › MMORPGs › Conquer Online 2 › CO2 Private Server
help whit entity.cs and equipment.cs help whit entity.cs and equipment.cs
You last visited: Today at 10:13

  • Please register to post and access all features, it's quick, easy and FREE!

Advertisement


Advertise with us!

help whit entity.cs and equipment.cs

Discussion on help whit entity.cs and equipment.cs within the CO2 Private Server forum part of the Conquer Online 2 category.

Reply
 
Old   #1
 
†Pôwèrfull†'s Avatar
 
elite*gold: 0
The Black Market: 0/0/0
Join Date: Aug 2011
Posts: 30
Received Thanks: 2
help whit entity.cs and equipment.cs

hi i have a problem i was updated my source to 5519 but cant see the name of the monsters and items this is my entity,cs whit spawn packet updated, and equipment.cs updated what i need to see it?

thanks help please

PHP Code:
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using Conquer_Online_Server.Network;
using Conquer_Online_Server.Network.GamePackets;
using System.Collections;
using Conquer_Online_Server.Game.Features;

namespace Conquer_Online_Server.Game
{
    public class Entity : Writer, Interfaces.IBaseEntity, Interfaces.IMapObject
    {
        #region Variables
        #region Discity
        public int DisKO = 0;
        public bool DisQuest = false;
        public class DisCity
        {
            public static Hashtable RightFlank = new Hashtable();
            public static Hashtable LeftFlank = new Hashtable();

            public static uint RightKills = 0;
            public static uint LeftKills = 0;

            public static bool dis = false;
            public static bool dis2 = false;
            public static byte DisMax1 = 0;
            public static byte DisMax2 = 0;
            public static byte DisMax3 = 0;
        }
        public uint ExpBallExp
        {
            get
            {
                if (Level < 30)
                    return (uint)(15000 + Level * 430);
                else if (Level < 50)
                    return (uint)(40000 + Level * 430);
                else if (Level < 80)
                    return (uint)(30000 + Level * 500);
                else if (Level < 80)
                    return (uint)(30000 + Level * 600);
                else if (Level < 100)
                    return (uint)(30000 + Level * 700);
                else if (Level < 110)
                    return (uint)(30000 + Level * 900);
                else if (Level < 120)
                    return (uint)(30000 + Level * 1100);
                else if (Level < 125)
                    return (uint)(30000 + Level * 1500);
                else if (Level < 130)
                    return (uint)(30000 + Level * 1000);
                else
                    return (uint)(30000 + Level * 1000);
            }
        }
        #endregion
        public Game.Features.Clan.Members ClanMember = null;
        public Dictionary<uint, Game.PkExpeliate> PkExplorerValues = new Dictionary<uint, PkExpeliate>();
        public BlessingContribution Contribution_Experience = null; //
        public Database.MonsterInformation MonsterInfo;
        public Time32 DeathStamp, VortexAttackStamp, AttackStamp, StaminaStamp, FlashingNameStamp, CycloneStamp, SupermanStamp,
                      StigmaStamp, InvisibilityStamp, StarOfAccuracyStamp, MagicShieldStamp, DodgeStamp, EnlightmentStamp,
                      AccuracyStamp, ShieldStamp, FlyStamp, NoDrugsStamp, ToxicFogStamp, FatalStrikeStamp, DoubleExpStamp,
                      ShurikenVortexStamp, IntensifyStamp, TransformationStamp, CounterKillStamp, PKPointDecreaseStamp,
                      HeavenBlessingStamp, OblivionStamp, ShackleStamp, AzureStamp, StunStamp, WhilrwindKick, Confuse;
        public bool Stunned = false, Confused = false;
        public bool Companion;
        public bool CauseOfDeathIsMagic = false;
        public bool OnIntensify;

        public short KOSpellTime
        {
            get
            {
                if (KOSpell == 1110)
                {
                    if (ContainsFlag(Network.GamePackets.Update.Flags.Cyclone))
                    {
                        return CycloneTime;
                    }
                }
                else if (KOSpell == 1025)
                {
                    if (ContainsFlag(Network.GamePackets.Update.Flags.Superman))
                    {
                        return SupermanTime;
                    }
                }
                return 0;
            }
            set
            {
                if (KOSpell == 1110)
                {
                    if (ContainsFlag(Network.GamePackets.Update.Flags.Cyclone))
                    {
                        int Seconds = CycloneStamp.AddSeconds(value).AllSeconds() - Time32.Now.AllSeconds();
                        if (Seconds >= 20)
                        {
                            CycloneTime = 20;
                            CycloneStamp = Time32.Now;
                        }
                        else
                        {
                            CycloneTime = (short)Seconds;
                            CycloneStamp = Time32.Now;
                        }
                    }
                }
                if (KOSpell == 1025)
                {
                    if (ContainsFlag(Network.GamePackets.Update.Flags.Superman))
                    {
                        int Seconds = SupermanStamp.AddSeconds(value).AllSeconds() - Time32.Now.AllSeconds();
                        if (Seconds >= 20)
                        {
                            SupermanTime = 20;
                            SupermanStamp = Time32.Now;
                        }
                        else
                        {
                            SupermanTime = (short)Seconds;
                            SupermanStamp = Time32.Now;
                        }
                    }
                }
            }
        }
        public short CycloneTime = 0, SupermanTime = 0, NoDrugsTime = 0, FatalStrikeTime = 0, ShurikenVortexTime = 0, OblivionTime = 0, ShackleTime = 0, AzureTime;
        public ushort KOSpell = 0;
        public int AzureDamage;
        private ushort _enlightenPoints;
        private byte _receivedEnlighenPoints;
        private ushort _enlightmenttime;
        public float ToxicFogPercent, StigmaIncrease, MagicShieldIncrease, DodgeIncrease, ShieldIncrease;
        public byte ToxicFogLeft, FlashingNameTime, FlyTime, StigmaTime, InvisibilityTime, StarOfAccuracyTime, MagicShieldTime, DodgeTime, AccuracyTime, ShieldTime;
        public ushort KOCount = 0;
        public bool CounterKillSwitch = false;
        public Network.GamePackets.Attack AttackPacket;
        public Network.GamePackets.Attack VortexPacket;
        public byte[] SpawnPacket;
        private string _Name, _Spouse;
        private ushort _Defence, _MDefence, _MDefencePercent;
        private Client.GameState _Owner;
        public ushort ItemHP = 0, ItemMP = 0, ItemBless = 0, PhysicalDamageDecrease = 0, PhysicalDamageIncrease = 0, MagicDamageDecrease = 0, MagicDamageIncrease = 0, AttackRange = 1, Vigor = 0, ExtraVigor = 0;
        public ushort[] Gems = new ushort[10];
        private uint _MinAttack, _MaxAttack, _MagicAttack;
        public uint BaseMinAttack, BaseMaxAttack, BaseMagicAttack, BaseDefence, BaseMagicDefence;
        private uint _TransMinAttack, _TransMaxAttack, _TransDodge, _TransPhysicalDefence, _TransMagicDefence;
        public bool Killed = false;
        public byte _SubClass, _SubClassLevel;
        public bool Transformed
        {
            get
            {
                return TransformationID != 98 && TransformationID != 99 && TransformationID != 0;
            }
        }
        public uint TransformationAttackRange = 0;
        public int TransformationTime = 0;
        public uint TransformationMaxHP = 0;
        private byte _Dodge;
        private Enums.PKMode _PKMode;
        private EntityFlag _EntityFlag;
        private MapObjectType _MapObjectType;
        public Enums.Mode Mode;
        private ulong _experience;
        private uint _heavenblessing, _money, _uid, _hitpoints, _maxhitpoints, _quizpoints;
        private uint _conquerpoints;
        private ushort _doubleexp, _body, _transformationid, _face, _strength, _agility, _spirit, _vitality, _atributes, _mana, _maxmana, _hairstyle, _mapid, _previousmapid, _x, _y, _pkpoints;
        private byte _stamina, _class, _reborn, _level;
        // public ClientStatus ClientStats;// if wrong
        //

        #region clan system
        public Statement.ClientClasses SubClasses = new Statement.ClientClasses(); // subclass
        public Game.Features.Clan.Clan Clan = null;//clan
        public ushort ClanRank
        {
            get { return BitConverter.ToUInt16(SpawnPacket, 159); }
            set { WriteUInt16(value, 159, SpawnPacket); }
        }
        string _ClanName = "";
        public string ClanName //NOT DONE
        {
            get { return _ClanName; }
            set
            {
                if (value != "")
                {
                    _ClanName = value;
                    byte[] Saved = new byte[SpawnPacket.Length];
                    SpawnPacket.CopyTo(Saved, 0);
                    SpawnPacket = new byte[8 + 216 + Name.Length + _ClanName.Length];

                    for (int i = 0; i < 210; i++)
                        SpawnPacket[i] = Saved[i];

                    WriteUInt16((ushort)(SpawnPacket.Length - 8), 0, SpawnPacket);
                    WriteUInt16(10014, 2, SpawnPacket);
                    SpawnPacket[145] = 2;
                    SpawnPacket[211] = 4;
                    SpawnPacket[212] = (byte)Name.Length;
                    WriteString(Name, 213, SpawnPacket);
                    SpawnPacket[214 + SpawnPacket[212]] = (byte)value.Length;
                    WriteString(value, 215 + SpawnPacket[212], SpawnPacket);
                }
                else
                {
                    byte[] Saved = new byte[SpawnPacket.Length];
                    SpawnPacket.CopyTo(Saved, 0);
                    SpawnPacket = new byte[8 + 214 + Name.Length];

                    for (int i = 0; i < 210; i++)
                        SpawnPacket[i] = Saved[i];

                    WriteUInt16((ushort)(214 + Name.Length), 0, SpawnPacket);
                    WriteUInt16(10014, 2, SpawnPacket);
                    SpawnPacket[145] = 0;
                    SpawnPacket[211] = 3;
                    SpawnPacket[212] = (byte)Name.Length;
                    WriteString(Name, 213, SpawnPacket);
                    _ClanName = value;
                }
            }
        }
        public uint ClanUID
        {
            get { return BitConverter.ToUInt32(SpawnPacket, 155); }
            set { WriteUInt32(value, 155, SpawnPacket); }
        }
        #endregion
        //
        public byte FirstRebornClass
        {
            get
            {
                return SpawnPacket[211];
            }
            set
            {
                SpawnPacket[211] = value;
            }
        }
        public byte SecondRebornClass
        {
            get
            {
                return SpawnPacket[209];
            }
            set
            {
                SpawnPacket[209] = value;
            }
        }
        public byte FirstRebornLevel, SecondRebornLevel;
        public bool FullyLoaded = false, SendUpdates = false, HandleTiming = false;
        private Network.GamePackets.Update update;

        #endregion
        public Game.ConquerStructures.Society.Guild Guild;

        #region Acessors
        public int BattlePower
        {
            get
            {
                int potBase = (int)(Level + Reborn * 5);//+ExtraBattlePower);
                potBase += (byte)NobilityRank;
                if (EntityFlag == EntityFlag.Player)
                {
                    foreach (Interfaces.IConquerItem item in Owner.Equipment.Objects)
                    {
                        if (item != null)
                        {
                            potBase += item.BattlePower;
                        }
                    }
                }
                return Math.Min(potBase, 400);
            }
        }

        public string Name
        {
            get
            {
                return _Name;
            }
            set
            {
                _Name = value;
                if (SpawnPacket == null || SpawnPacket.Length < 200)
                    SpawnPacket = new byte[8 + 221 + Name.Length];
                WriteUInt16((ushort)(221 + Name.Length), 0, SpawnPacket);
                WriteUInt16(10014, 2, SpawnPacket);
                SpawnPacket[212] = 4;
                SpawnPacket[220] = (byte)_Name.Length;
                WriteString(_Name, 220, SpawnPacket);
            }
        }
        public string Spouse
        {
            get
            {
                return _Spouse;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                {
                    UpdateDatabase("Spouse", value); // i dont now yet if this work
                    Update(Network.GamePackets._String.Spouse, value, false);
                }
                _Spouse = value;
            }
        }
        public uint Money
        {
            get
            {
                return _money;
            }
            set
            {
                _money = value;
                if (EntityFlag == EntityFlag.Player)
                    Update(Network.GamePackets.Update.Money, value, false);


            }
        }
        //
        /*   public uint StudyPoints
           {
               get
               {
                   return _study;
               }
               set
               {
                   _study = value;
                   if (EntityFlag == EntityFlag.Player)
                       Update(Network.GamePackets.Update.StudyPoints, value, false);
                


               }
           } */
        //
        private byte _vipLevel;
        public byte VIPLevel
        {
            get
            {
                return _vipLevel;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                {
                    Update(Network.GamePackets.Update.VIPLevel, value, false);
                }
                _vipLevel = value;
            }
        }
        //

        //
        public uint ConquerPoints
        {
            get
            {
                return _conquerpoints;
            }
            set
            {
                if (value <= 0)
                    value = 0;

                _conquerpoints = value;

                if (EntityFlag == EntityFlag.Player)
                    Update(Network.GamePackets.Update.ConquerPoints, (uint)value, false);
            }
        }
        public ushort Body
        {
            get
            {
                return _body;
            }
            set
            {
                WriteUInt32((uint)(TransformationID * 10000000 + Face * 10000 + value), 4, SpawnPacket);
                _body = value;
                if (EntityFlag == EntityFlag.Player)
                {
                    if (Owner != null)
                    {
                        Owner.ArenaStatistic.Model = (uint)(Face * 10000 + value);
                        Update(Network.GamePackets.Update.Mesh, Mesh, true);
                    }
                }
            }
        }
        public ushort DoubleExperienceTime
        {
            get
            {
                return _doubleexp;
            }
            set
            {
                ushort oldVal = DoubleExperienceTime;
                _doubleexp = value;
                if (FullyLoaded)
                    if (oldVal <= _doubleexp)
                        if (EntityFlag == EntityFlag.Player)
                        {
                            if (Owner != null)
                            {
                                Update(Network.GamePackets.Update.DoubleExpTimer, DoubleExperienceTime, false);
                            }
                        }
            }
        }

        public uint HeavenBlessing
        {
            get
            {
                return _heavenblessing;
            }
            set
            {
                uint oldVal = HeavenBlessing;
                _heavenblessing = value;
                if (FullyLoaded)
                    if (value > 0)
                        if (!ContainsFlag(Network.GamePackets.Update.Flags.HeavenBlessing) || oldVal <= _heavenblessing)
                        {
                            AddFlag(Network.GamePackets.Update.Flags.HeavenBlessing);
                            Update(Network.GamePackets.Update.HeavensBlessing, HeavenBlessing, false);
                            Update(Network.GamePackets._String.Effect, "bless", true);
                        }
            }
        }

        public byte Stamina
        {
            get
            {
                return _stamina;
            }
            set
            {
                _stamina = value;
                if (EntityFlag == EntityFlag.Player)
                    Update(Network.GamePackets.Update.Stamina, value, false);
            }
        }
        //
        public byte SubClass
        {
            get { return _SubClass; }
            set
            {
                _SubClass = value;
                switch (EntityFlag)
                {
                    case EntityFlag.Player:
                        if (FullyLoaded)
                        { UpdateDatabase("SubClass", _SubClass); }
                        SpawnPacket[192] = _SubClass;
                        break;
                }
            }
        }
        public byte SubClassLevel
        {
            get { return _SubClassLevel; }
            set
            {
                _SubClassLevel = value;
                switch (EntityFlag)
                {
                    case EntityFlag.Player:
                        if (FullyLoaded)
                        { UpdateDatabase("SubClassLevel", value); }

                        break;
                }
            }
        }
        //
        public ushort TransformationID
        {
            get
            {
                return _transformationid;
            }
            set
            {
                _transformationid = value;
                WriteUInt32((uint)(value * 10000000 + Face * 10000 + Body), 4, SpawnPacket);
                if (EntityFlag == EntityFlag.Player)
                    Update(Network.GamePackets.Update.Mesh, Mesh, true);
            }
        }
        public ushort Face
        {
            get
            {
                return _face;
            }
            set
            {
                WriteUInt32((uint)(TransformationID * 10000000 + value * 10000 + Body), 4, SpawnPacket);
                _face = value;
                if (EntityFlag == EntityFlag.Player)
                {
                    if (Owner != null)
                    {
                        Owner.ArenaStatistic.Model = (uint)(value * 10000 + Body);
                        Update(Network.GamePackets.Update.Mesh, Mesh, true);
                    }
                }
            }
        }
        public uint Mesh
        {
            get
            {
                return BitConverter.ToUInt32(SpawnPacket, 4);
            }
        }
        public byte Class
        {
            get
            {
                return _class;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                {
                    if (Owner != null)
                    {
                        Owner.ArenaStatistic.Class = value;
                        Update(Network.GamePackets.Update.Class, value, false);
                    }
                }
                _class = value;
                SpawnPacket[205] = value;
            }
        }
        public byte Reborn
        {
            get
            {
                SpawnPacket[98] = _reborn;
                return _reborn;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                {
                    Update(Network.GamePackets.Update.Reborn, value, true);
                }
                _reborn = value;
                SpawnPacket[98] = value;
            }
        }
        public byte Level
        {
            get
            {
                SpawnPacket[99] = _level;
                return _level;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                {
                    Update(Network.GamePackets.Update.Level, value, true);
                    Data update = new Data(true);
                    update.UID = UID;
                    update.ID = Data.Leveled;
                    if (Owner != null)
                    {
                        (Owner as Client.GameState).SendScreen(update, true);
                        Owner.ArenaStatistic.Level = value;
                        Owner.ArenaStatistic.ArenaPoints = 1000;
                    }
                    if (Owner != null)
                    {
                        if (Owner.AsMember != null)
                        {
                            Owner.AsMember.Level = value;
                        }
                    }
                    SpawnPacket[99] = value;
                }
                else
                {
                    SpawnPacket[76] = value;
                }
                _level = value;

            }
        }


        public uint ExtraBattlePower
        {
            get
            {
                return BitConverter.ToUInt32(SpawnPacket, 97);
            }
            set
            {
                if (value > 200)
                    value = 0;
                if (ExtraBattlePower > 1000)
                    WriteUInt32(0, 97, SpawnPacket);
                if (ExtraBattlePower > 0 && value == 0 || value > 0)
                {
                    if (value == 0 && ExtraBattlePower == 0)
                        return;
                    Update(Network.GamePackets.Update.ExtraBattlePower, value, false);
                    WriteUInt32(value, 97, SpawnPacket);
                }
            }
        }

        public byte Away
        {
            get
            {
                return SpawnPacket[102];
            }
            set
            {
                SpawnPacket[102] = value;
            }
        }
        public byte Boss
        {
            get
            {
                return SpawnPacket[175];
            }
            set
            {
                SpawnPacket[175] = 1;
                SpawnPacket[176] = 2;
                SpawnPacket[177] = 3;
            }
        }
        public uint UID
        {
            get
            {
                if (SpawnPacket != null)
                    return BitConverter.ToUInt32(SpawnPacket, 8);
                else
                    return _uid;
            }
            set
            {
                _uid = value;
                WriteUInt32(value, 8, SpawnPacket);
            }
        }

        public ushort GuildID
        {
            get
            {
                return BitConverter.ToUInt16(SpawnPacket, 12);
            }
            set
            {
                WriteUInt32(value, 12, SpawnPacket);
            }
        }

        public ushort GuildRank
        {
            get
            {
                return BitConverter.ToUInt16(SpawnPacket, 16);
            }
            set
            {
                WriteUInt16(value, 16, SpawnPacket);
            }
        }
        public ushort Strength
        {
            get
            {
                return _strength;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                {
                    Update(Network.GamePackets.Update.Strength, value, false);
                }
                _strength = value;
            }
        }
        public ushort Agility
        {
            get
            {
                if (OnCyclone())
                    return (ushort)(_agility);
                return _agility;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                    Update(Network.GamePackets.Update.Agility, value, false);
                _agility = value;
            }
        }
        public ushort Spirit
        {
            get
            {
                return _spirit;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                    Update(Network.GamePackets.Update.Spirit, value, false);
                _spirit = value;
            }
        }
        public ushort Vitality
        {
            get
            {
                return _vitality;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                    Update(Network.GamePackets.Update.Vitality, value, false);
                _vitality = value;
            }
        }
        public ushort Atributes
        {
            get
            {
                return _atributes;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                    Update(Network.GamePackets.Update.Atributes, value, false);
                _atributes = value;
            }
        }
        public uint Hitpoints
        {
            get
            {
                return _hitpoints;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                    Update(Network.GamePackets.Update.Hitpoints, value, false);
                _hitpoints = value;

                if (Boss > 0)
                {
                    uint key = (uint)(MaxHitpoints / 10000);
                    if (key != 0)
                        WriteUInt16((ushort)(value / key), 74, SpawnPacket);
                    else
                        WriteUInt16((ushort)(value * MaxHitpoints / 1000 / 1.09), 74, SpawnPacket);
                }
                else
                    WriteUInt16((ushort)value, 74, SpawnPacket);
            }
        }
        public ushort Mana
        {
            get
            {
                return _mana;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                    Update(Network.GamePackets.Update.Mana, value, false);
                _mana = value;
            }
        }
        public ushort MaxMana
        {
            get
            {
                return _maxmana;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                    Update(Network.GamePackets.Update.MaxMana, value, false);
                _maxmana = value;
            }
        }
        public ushort HairStyle
        {
            get
            {
                return _hairstyle;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                {
                    Update(Network.GamePackets.Update.HairStyle, value, true);
                }
                _hairstyle = value;
                WriteUInt16(value, 84, SpawnPacket);
            }
        }


        public ConquerStructures.NobilityRank NobilityRank
        {
            get
            {
                return (Conquer_Online_Server.Game.ConquerStructures.NobilityRank)SpawnPacket[119];
            }
            set
            {
                SpawnPacket[119] = (byte)value;
                if (Owner != null)
                {
                    if (Owner.AsMember != null)
                    {
                        Owner.AsMember.NobilityRank = value;
                    }
                }
            }
        }

        public byte HairColor
        {
            get
            {
                return (byte)(HairStyle / 100);
            }
            set
            {
                HairStyle = (ushort)((value * 100) + (HairStyle % 100));
            }
        }
        public ushort MapID
        {
            get
            {
                return _mapid;
            }
            set
            {
                _mapid = value;
            }
        }
        public ushort PreviousMapID
        {
            get
            {
                return _previousmapid;
            }
            set
            {
                _previousmapid = value;
            }
        }
        public ushort X
        {
            get
            {
                return _x;
            }
            set
            {
                _x = value;
                WriteUInt16(value, 86, SpawnPacket);
            }
        }
        public ushort Y
        {
            get
            {
                return _y;
            }
            set
            {
                _y = value;
                WriteUInt16(value, 88, SpawnPacket);
            }
        }
        public ushort PX
        {
            get;
            set;
        }
        public ushort PY
        {
            get;
            set;
        }
        public ushort ArenaMap
        {
            get
            {
                return _arenamap;
            }
            set
            {
                _arenamap = value;
            }
        }
        public bool Dead
        {
            get
            {
                return Hitpoints < 1;
            }
            set
            {
                throw new NotImplementedException();
            }
        }
        public ushort Defence
        {
            get
            {
                return _Defence;
            }
            set { _Defence = value; }
        }
        public ushort TransformationDefence
        {
            get
            {
                if (ContainsFlag(Network.GamePackets.Update.Flags.MagicShield))
                {
                    if (ShieldTime > 0)
                        return (ushort)(_TransPhysicalDefence * ShieldIncrease);
                    else
                        return (ushort)(_TransPhysicalDefence * MagicShieldIncrease);
                }
                return (ushort)_TransPhysicalDefence;
            }
            set { _TransPhysicalDefence = value; }
        }
        public ushort MagicDefencePercent
        {
            get { return _MDefencePercent; }
            set { _MDefencePercent = value; }
        }
        public ushort TransformationMagicDefence
        {
            get { return (ushort)_TransMagicDefence; }
            set { _TransMagicDefence = value; }
        }
        public ushort MagicDefence
        {
            get { return _MDefence; }
            set { _MDefence = value; }
        }
        public Client.GameState Owner
        {
            get { return _Owner; }
            set { _Owner = value; }
        }
        public uint TransformationMinAttack
        {
            get
            {
                if (ContainsFlag(Network.GamePackets.Update.Flags.Stigma))
                    return (uint)(_TransMinAttack * StigmaIncrease);
                return _TransMinAttack;
            }
            set { _TransMinAttack = value; }
        }
        public uint TransformationMaxAttack
        {
            get
            {
                if (ContainsFlag(Network.GamePackets.Update.Flags.Stigma))
                    return (uint)(_TransMaxAttack * StigmaIncrease);
                return _TransMaxAttack;
            }
            set { _TransMaxAttack = value; }
        }
        public uint MinAttack
        {
            get
            {
                return _MinAttack;
            }
            set { _MinAttack = value; }
        }
        public uint MaxAttack
        {
            get
            {
                return _MaxAttack;
            }
            set { _MaxAttack = value; }
        }
        public uint MaxHitpoints
        {
            get
            {
                return _maxhitpoints;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                    if (TransformationID != 0 && TransformationID != 98)
                        Update(Network.GamePackets.Update.MaxHitpoints, value, true);
                _maxhitpoints = value;
            }
        }
        public uint MagicAttack
        {
            get
            {
                return _MagicAttack;
            }
            set { _MagicAttack = value; }
        }
        public byte Dodge
        {
            get
            {
                if (ContainsFlag(Network.GamePackets.Update.Flags.Dodge))
                    return (byte)(_Dodge * DodgeIncrease);
                return _Dodge;
            }
            set { _Dodge = value; }
        }
        public byte TransformationDodge
        {
            get
            {
                if (ContainsFlag(Network.GamePackets.Update.Flags.Dodge))
                    return (byte)(_TransDodge * DodgeIncrease);
                return (byte)_TransDodge;
            }
            set { _TransDodge = value; }
        }
        public MapObjectType MapObjType
        {
            get { return _MapObjectType; }
            set { _MapObjectType = value; }
        }

        public EntityFlag EntityFlag
        {
            get { return _EntityFlag; }
            set { _EntityFlag = value; }
        }
        public ulong Experience
        {
            get
            {
                return _experience;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                    Update(Network.GamePackets.Update.Experience, value, false);
                _experience = value;
            }
        }

        public ushort EnlightenPoints
        {
            get
            {
                return _enlightenPoints;
            }
            set
            {
                _enlightenPoints = value;
            }
        }

        public byte ReceivedEnlightenPoints
        {
            get
            {
                return _receivedEnlighenPoints;
            }
            set
            {
                _receivedEnlighenPoints = value;
            }
        }

        public ushort EnlightmentTime
        {
            get
            {
                return _enlightmenttime;
            }
            set
            {
                _enlightmenttime = value;
            }
        }

        public ushort PKPoints
        {
            get
            {
                return _pkpoints;
            }
            set
            {
                _pkpoints = value;
                if (EntityFlag == EntityFlag.Player)
                {
                    Update(Network.GamePackets.Update.PKPoints, value, false);
                    if (PKPoints > 99)
                    {
                        RemoveFlag(Network.GamePackets.Update.Flags.RedName);
                        AddFlag(Network.GamePackets.Update.Flags.BlackName);
                    }
                    else if (PKPoints > 29)
                    {
                        AddFlag(Network.GamePackets.Update.Flags.RedName);
                        RemoveFlag(Network.GamePackets.Update.Flags.BlackName);
                    }
                    else if (PKPoints < 30)
                    {
                        RemoveFlag(Network.GamePackets.Update.Flags.RedName);
                        RemoveFlag(Network.GamePackets.Update.Flags.BlackName);
                    }
                }
            }
        }
        public uint QuizPoints
        {
            get
            {
                return _quizpoints;
            }
            set
            {
                if (EntityFlag == EntityFlag.Player)
                {
                    Update(Network.GamePackets.Update.QuizPoints, value, true);
                }
                _quizpoints = value;
                WriteUInt32(value, 122, SpawnPacket);
            }
        }
        public Enums.PKMode PKMode
        {
            get { return _PKMode; }
            set { _PKMode = value; }
        }
        public ushort Action
        {
            get { return BitConverter.ToUInt16(SpawnPacket, 91); }
            set
            {
                WriteUInt16(value, 91, SpawnPacket);
            }
        }
        public Enums.ConquerAngle Facing
        {
            get { return (Enums.ConquerAngle)SpawnPacket[90]; }
            set
            {
                SpawnPacket[90] = (byte)value;
            }
        }
        public ulong StatusFlag
        {
            get
            {
                return BitConverter.ToUInt64(SpawnPacket, 22);
            }
            set
            {
                ulong OldV = StatusFlag;
                if (value != OldV)
                {
                    WriteUInt64(value, 22, SpawnPacket);
                    Update(Network.GamePackets.Update.StatusFlag, value, !ContainsFlag(Network.GamePackets.Update.Flags.XPList));
                }
            }
        }
        private ulong _Stateff2 = 0;
        public ulong StatusFlag2
        {
            get { return _Stateff2; }
            set
            {
                ulong OldV = StatusFlag2;
                if (value != OldV)
                {
                    _Stateff2 = value;
                    WriteUInt64(value, 30, SpawnPacket);
                    Update2(Network.GamePackets.Update.StatusFlag, value, true);// !ContainsFlag(Network.GamePackets.Update.Flags.XPList));//you need to update the SECOND value of stateff
                }
            }
        }

        #endregion

        #region Functions
        public Entity(EntityFlag Flag, bool companion)
        {

            Companion = companion;
            this.EntityFlag = Flag;
            Mode = Enums.Mode.None;
            update = new Conquer_Online_Server.Network.GamePackets.Update(true);
            update.UID = UID;
            switch (Flag)
            {
                case EntityFlag.Player: MapObjType = Game.MapObjectType.Player; break;
                case EntityFlag.Monster: MapObjType = Game.MapObjectType.Monster; break;
            }
        }

        public void Ressurect()
        {
            Hitpoints = MaxHitpoints;
            TransformationID = 0;
            Stamina = 100;
            FlashingNameTime = 0;
            FlashingNameStamp = Time32.Now;
            RemoveFlag(Network.GamePackets.Update.Flags.FlashingName);
            RemoveFlag(Network.GamePackets.Update.Flags.Dead | Network.GamePackets.Update.Flags.Ghost);
            if (EntityFlag == EntityFlag.Player)
                Owner.Send(new MapStatus() { BaseID = Owner.Map.BaseID, ID = Owner.Map.ID, Status = Database.MapsTable.MapInformations[Owner.Map.ID].Status });
        }

        public void DropRandomStuff(string KillerName)
        {
            if (Money > 100)
            {
                int amount = (int)(Money / 2);
                amount = ServerBase.Kernel.Random.Next(amount);
                if (ServerBase.Kernel.Rate(40))
                {
                    uint ItemID = Network.PacketHandler.MoneyItemID((uint)amount);
                    ushort x = X, y = Y;
                    Game.Map Map = ServerBase.Kernel.Maps[MapID];
                    if (Map.SelectCoordonates(ref x, ref y))
                    {
                        Money -= (uint)amount;
                        Network.GamePackets.FloorItem floorItem = new Network.GamePackets.FloorItem(true);
                        floorItem.ValueType = Network.GamePackets.FloorItem.FloorValueType.Money;
                        floorItem.Value = (uint)amount;
                        floorItem.ItemID = ItemID;
                        floorItem.MapID = MapID;
                        floorItem.MapObjType = Game.MapObjectType.Item;
                        floorItem.X = x;
                        floorItem.Y = y;
                        floorItem.Type = Network.GamePackets.FloorItem.Drop;
                        floorItem.OnFloor = Time32.Now;
                        floorItem.UID = Network.GamePackets.FloorItem.FloorUID.Next;
                        while (Map.Npcs.ContainsKey(floorItem.UID))
                            floorItem.UID = Network.GamePackets.FloorItem.FloorUID.Next;
                        Map.AddFloorItem(floorItem);
                        Owner.SendScreenSpawn(floorItem, true);
                    }
                }
            }
            if (Owner.Inventory.Count > 0)
            {
                uint count = (uint)(Owner.Inventory.Count / 4);
                byte startfrom = (byte)ServerBase.Kernel.Random.Next((int)count);
                for (int c = 0; c < count; c++)
                {
                    if (Owner.Inventory.Objects.Length < c + startfrom)
                        break;
                    if (Owner.Inventory.Objects[c + startfrom] != null)
                    {
                        if (Owner.Inventory.Objects[c + startfrom].Lock == 0 || PKPoints > 99)
                        {
                            if (!Owner.Inventory.Objects[c + startfrom].Bound)
                            {
                                if (!Owner.Inventory.Objects[c + startfrom].Suspicious)
                                {
                                    if (ServerBase.Kernel.Rate(140))
                                    {
                                        var Item = Owner.Inventory.Objects[c + startfrom];
                                        Item.Lock = 0;
                                        var infos = Database.ConquerItemInformation.BaseInformations[(uint)Item.ID];
                                        ushort x = X, y = Y;
                                        Game.Map Map = ServerBase.Kernel.Maps[MapID];
                                        if (Map.SelectCoordonates(ref x, ref y))
                                        {
                                            Network.GamePackets.FloorItem floorItem = new Network.GamePackets.FloorItem(true);
                                            Owner.Inventory.Remove(Item, Enums.ItemUse.Remove);
                                            floorItem.Item = Item;
                                            floorItem.ValueType = Network.GamePackets.FloorItem.FloorValueType.Item;
                                            floorItem.ItemID = (uint)Item.ID;
                                            floorItem.MapID = MapID;
                                            floorItem.MapObjType = Game.MapObjectType.Item;
                                            floorItem.X = x;
                                            floorItem.Y = y;
                                            floorItem.Type = Network.GamePackets.FloorItem.Drop;
                                            floorItem.OnFloor = Time32.Now;
                                            floorItem.ItemColor = floorItem.Item.Color;
                                            floorItem.UID = Network.GamePackets.FloorItem.FloorUID.Next;
                                            while (Map.Npcs.ContainsKey(floorItem.UID))
                                                floorItem.UID = Network.GamePackets.FloorItem.FloorUID.Next;
                                            Map.AddFloorItem(floorItem);
                                            Owner.SendScreenSpawn(floorItem, true);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            if (PKPoints > 29 && Killer != null && Killer.Owner != null)
            {
                foreach (var Item in Owner.Equipment.Objects)
                {
                    if (Item != null)
                    {
                        //5 = LeftHand, 9 = Garment, 12 = Horse
                        if (Item.Position == 9 || Item.Position == 12)
                            return;
                        if (Item.Position == 5)
                            if (Item.ID.ToString().StartsWith("105"))
                                return;
                        if (ServerBase.Kernel.Rate(35 + (int)(PKPoints > 99 ? 75 : 0)))
                        {
                            ushort x = X, y = Y;
                            Game.Map Map = ServerBase.Kernel.Maps[MapID];
                            if (Map.SelectCoordonates(ref x, ref y))
                            {
                                Owner.Equipment.RemoveToGround(Item.Position);
                                var infos = Database.ConquerItemInformation.BaseInformations[(uint)Item.ID];

                                Network.GamePackets.FloorItem floorItem = new Network.GamePackets.FloorItem(true);
                                floorItem.Item = Item;
                                floorItem.ValueType = Network.GamePackets.FloorItem.FloorValueType.Item;
                                floorItem.ItemID = (uint)Item.ID;
                                floorItem.MapID = MapID;
                                floorItem.MapObjType = Game.MapObjectType.Item;
                                floorItem.X = x;
                                floorItem.Y = y;
                                floorItem.Type = Network.GamePackets.FloorItem.DropDetain;
                                floorItem.OnFloor = Time32.Now;
                                floorItem.ItemColor = floorItem.Item.Color;
                                floorItem.UID = Network.GamePackets.FloorItem.FloorUID.Next;
                                while (Map.Npcs.ContainsKey(floorItem.UID))
                                    floorItem.UID = Network.GamePackets.FloorItem.FloorUID.Next;
                                Owner.SendScreenSpawn(floorItem, true);

                                Database.DetainedItemTable.DetainItem(Item, Owner, Killer.Owner);
                                break;
                            }
                        }
                    }
                }
            }
            if (PKPoints > 99)
            {
                if (KillerName != "")
                    ServerBase.Kernel.SendWorldMessage(new Network.GamePackets.Message(Name + " has been captured by " + KillerName + " and sent in jail! The world is now safer!", System.Drawing.Color.Red, Message.Talk), ServerBase.Kernel.GamePool.Values);
                else
                    ServerBase.Kernel.SendWorldMessage(new Network.GamePackets.Message(Name + " has been captured and sent in jail! The world is now safer!", System.Drawing.Color.Red, Message.Talk), ServerBase.Kernel.GamePool.Values);

                Teleport(6001, 30, 76);
            }
        }

        public void Die()
        {
            if (EntityFlag == EntityFlag.Player)
                Owner.XPCount = 0;
            Killed = true;
            Hitpoints = 0;
            DeathStamp = Time32.Now;
            ToxicFogLeft = 0;
            if (Companion)
            {
                AddFlag(Network.GamePackets.Update.Flags.Ghost | Network.GamePackets.Update.Flags.Dead | Network.GamePackets.Update.Flags.FadeAway);
                Network.GamePackets.Attack attack = new Network.GamePackets.Attack(true);
                attack.Attacked = UID;
                attack.AttackType = Network.GamePackets.Attack.Kill;
                attack.X = X;
                attack.Y = Y;
                MonsterInfo.SendScreen(attack);
                Owner.Map.RemoveEntity(this);
                Owner.Companion = null;
            }
            if (EntityFlag == EntityFlag.Player)
            {
                if (ServerBase.Constants.PKFreeMaps.Contains(MapID))
                    goto Over;

                DropRandomStuff("");

            Over:
                AddFlag(Network.GamePackets.Update.Flags.Dead | Network.GamePackets.Update.Flags.Ghost);
                RemoveFlag(Network.GamePackets.Update.Flags.Fly);
                RemoveFlag(Network.GamePackets.Update.Flags.Ride);
                RemoveFlag(Network.GamePackets.Update.Flags.Cyclone);
                RemoveFlag(Network.GamePackets.Update.Flags.Superman);
                RemoveFlag(Network.GamePackets.Update.Flags.FatalStrike);
                RemoveFlag(Network.GamePackets.Update.Flags.FlashingName);
                RemoveFlag(Network.GamePackets.Update.Flags.ShurikenVortex);
                RemoveFlag2(Network.GamePackets.Update.Flags2.Oblivion);

                Network.GamePackets.Attack attack = new Attack(true);
                attack.AttackType = Network.GamePackets.Attack.Kill;
                attack.X = X;
                attack.Y = Y;
                attack.Attacked = UID;
                Owner.SendScreen(attack, true);

                if (Body % 10 < 3)
                    TransformationID = 99;
                else
                    TransformationID = 98;

                Owner.Send(new MapStatus() { BaseID = Owner.Map.BaseID, ID = Owner.Map.ID, Status = Database.MapsTable.MapInformations[Owner.Map.ID].Status });

                if (Owner.QualifierGroup != null)
                {
                    Owner.QualifierGroup.End(Owner);
                }
            }
            else
            {
                ServerBase.Kernel.Maps[MapID].Floor[X, Y, MapObjType, this] = true;
            }
        }
        public Entity Killer;
        public void Die(Entity killer)
        {
            if (EntityFlag == EntityFlag.Player)
                Owner.XPCount = 0;
            Killer = killer;
            Hitpoints = 0;
            DeathStamp = Time32.Now;
            ToxicFogLeft = 0;
            if (Companion)
            {
                AddFlag(Network.GamePackets.Update.Flags.Ghost | Network.GamePackets.Update.Flags.Dead | Network.GamePackets.Update.Flags.FadeAway);
                Network.GamePackets.Attack zattack = new Network.GamePackets.Attack(true);
                zattack.Attacked = UID;
                zattack.AttackType = Network.GamePackets.Attack.Kill;
                zattack.X = X;
                zattack.Y = Y;
                MonsterInfo.SendScreen(zattack);
                Owner.Map.RemoveEntity(this);
                Owner.Companion = null;
            }
            if (EntityFlag == EntityFlag.Player)
            {
                if (killer.EntityFlag == EntityFlag.Player)
                {
                    if (ServerBase.Constants.PKFreeMaps.Contains(killer.Owner.Map.ID) || (killer.Owner.Map.ID != 700 && killer.Owner.Map.BaseID == 700 && killer.Owner.Map.ID != Conquer_Online_Server.Game.ConquerStructures.Quarantine.Map))
                        goto Over;
                    if (!ContainsFlag(Network.GamePackets.Update.Flags.FlashingName | Network.GamePackets.Update.Flags.BlackName))
                    {
                        killer.AddFlag(Network.GamePackets.Update.Flags.FlashingName);
                        killer.FlashingNameStamp = Time32.Now;
                        killer.FlashingNameTime = 60;
                        if (killer.GuildID != 0)
                        {
                            if (killer.Owner.Guild.Enemy.ContainsKey(GuildID))
                            {
                                killer.PKPoints += 3;
                            }
                            else
                            {
                                if (!killer.Owner.Enemy.ContainsKey(UID))
                                    killer.PKPoints += 10;
                                else
                                    killer.PKPoints += 5;
                            }
                        }
                        else
                        {
                            if (!killer.Owner.Enemy.ContainsKey(UID))
                                killer.PKPoints += 10;
                            else
                                killer.PKPoints += 5;
                        }
                        if (!this.Owner.Enemy.ContainsKey(killer.UID))
                            Network.PacketHandler.AddEnemy(this.Owner, killer.Owner);
                    }
                    if (killer.EntityFlag == EntityFlag.Player)
                        DropRandomStuff(killer.Name);
                    else
                        DropRandomStuff("");
                }
            }
            RemoveFlag(Network.GamePackets.Update.Flags.FlashingName);
        Over:

            Network.GamePackets.Attack attack = new Attack(true);
            attack.Attacker = killer.UID;
            attack.Attacked = UID;
            attack.AttackType = Network.GamePackets.Attack.Kill;
            attack.X = X;
            attack.Y = Y;

            if (EntityFlag == EntityFlag.Player)
            {
                AddFlag(Network.GamePackets.Update.Flags.Dead | Network.GamePackets.Update.Flags.Ghost);
                RemoveFlag(Network.GamePackets.Update.Flags.Fly);
                RemoveFlag(Network.GamePackets.Update.Flags.Ride);
                RemoveFlag(Network.GamePackets.Update.Flags.Cyclone);
                RemoveFlag(Network.GamePackets.Update.Flags.Superman);
                RemoveFlag(Network.GamePackets.Update.Flags.FatalStrike);
                RemoveFlag(Network.GamePackets.Update.Flags.FlashingName);
                RemoveFlag(Network.GamePackets.Update.Flags.ShurikenVortex);
                RemoveFlag2(Network.GamePackets.Update.Flags2.Oblivion);

                if (Body % 10 < 3)
                    TransformationID = 99;
                else
                    TransformationID = 98;

                Owner.SendScreen(attack, true);
                Owner.Send(new MapStatus() { BaseID = Owner.Map.BaseID, ID = Owner.Map.ID, Status = Database.MapsTable.MapInformations[Owner.Map.ID].Status });

                if (Owner.QualifierGroup != null)
                {
                    Owner.QualifierGroup.End(Owner);
                }
            }
            else
            {
                if (!Companion)
                    MonsterInfo.Drop(killer);
                ServerBase.Kernel.Maps[MapID].Floor[X, Y, MapObjType, this] = true;
                if (killer.EntityFlag == EntityFlag.Player)
                {
                    killer.Owner.IncreaseExperience(MaxHitpoints, true);
                    if (killer.Owner.Team != null)
                    {
                        foreach (Client.GameState teammate in killer.Owner.Team.Teammates)
                        {
                            if (ServerBase.Kernel.GetDistance(killer.X, killer.Y, teammate.Entity.X, teammate.Entity.Y) <= ServerBase.Constants.pScreenDistance)
                            {
                                if (killer.UID != teammate.Entity.UID)
                                {
                                    uint extraExperience = MaxHitpoints / 2;
                                    if (killer.Spouse == teammate.Entity.Name)
                                        extraExperience = MaxHitpoints * 2;
                                    byte TLevelN = teammate.Entity.Level;
                                    if (killer.Owner.Team.CanGetNoobExperience(teammate))
                                    {
                                        if (teammate.Entity.Level < 137)
                                        {
                                            extraExperience *= 2;
                                            teammate.IncreaseExperience(extraExperience, false);
                                            teammate.Send(ServerBase.Constants.NoobTeamExperience(extraExperience));
                                        }
                                    }
                                    else
                                    {
                                        if (teammate.Entity.Level < 137)
                                        {
                                            teammate.IncreaseExperience(extraExperience, false);
                                            teammate.Send(ServerBase.Constants.TeamExperience(extraExperience));
                                        }
                                    }
                                    byte TLevelNn = teammate.Entity.Level;
                                    byte newLevel = (byte)(TLevelNn - TLevelN);
                                    if (newLevel != 0)
                                    {
                                        if (TLevelN < 70)
                                        {
                                            for (int i = TLevelN; i < TLevelNn; i++)
                                            {
                                                teammate.Team.Teammates[0].VirtuePoints += (uint)(i * 3.83F);
                                                teammate.Team.SendMessage(new Message("The leader, " + teammate.Team.Teammates[0].Entity.Name + ", has gained " + (uint)(i * 7.7F) + " virtue points for power leveling the rookies.", System.Drawing.Color.Red, Message.Team));
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if (killer.Level < 137)
                    {
                        uint extraExp = MaxHitpoints;
                        extraExp *= ServerBase.Constants.ExtraExperienceRate;
                        extraExp += extraExp * killer.Gems[3] / 100;
                        extraExp += (uint)(extraExp * ((float)killer.BattlePower / 100));
                        if (killer.DoubleExperienceTime > 0)
                            extraExp *= 2;
                        if (killer.HeavenBlessing > 0)
                            extraExp += (uint)(extraExp * 20 / 100);
                        if (killer.Reborn >= 2)
                            extraExp /= 3;
                        killer.Owner.Send(ServerBase.Constants.ExtraExperience(extraExp));
                    }
                    killer.Owner.XPCount++;
                    if (killer.OnKOSpell())
                        killer.KOSpellTime++;
                }
            }
        }

        public void Update(byte type, byte value, bool screen)
        {
            if (!SendUpdates)
                return;
            update = new Update(true);
            update.UID = UID;
            update.Append(type, value);
            if (!screen)
                update.Send(Owner as Client.GameState);
            else
                (Owner as Client.GameState).SendScreen(update, true);
        }
        public void Update(byte type, ushort value, bool screen)
        {
            if (!SendUpdates)
                return;
            update = new Update(true);
            update.UID = UID;
            update.Append(type, value);
            if (!screen)
                update.Send(Owner as Client.GameState);
            else
                (Owner as Client.GameState).SendScreen(update, true);
        }
        public void Update(byte type, uint value, bool screen)
        {
            if (!SendUpdates)
                return;
            update = new Update(true);
            update.UID = UID;
            update.Append(type, value);
            if (!screen)
                update.Send(Owner as Client.GameState);
            else
                (Owner as Client.GameState).SendScreen(update, true);
        }
        public void Update(byte type, ulong value, bool screen)
        {
            if (!SendUpdates)
                return;
            update = new Update(true);
            update.UID = UID;
            update.Append(type, value);
            if (EntityFlag == EntityFlag.Player)
            {
                if (!screen)
                    update.Send(Owner as Client.GameState);
                else
                    (Owner as Client.GameState).SendScreen(update, true);
            }
            else
            {
                MonsterInfo.SendScreen(update);
            }
        }
        public void Update2(byte type, ulong value, bool screen)
        {
            if (!SendUpdates)
                return;
            update = new Update(true);
            update.UID = UID;
            update.Append2(type, value);
            if (EntityFlag == EntityFlag.Player)
            {
                if (!screen)
                    update.Send(Owner as Client.GameState);
                else
                    (Owner as Client.GameState).SendScreen(update, true);
            }
            else
            {
                MonsterInfo.SendScreen(update);
            }
        }
        public void Update(byte type, string value, bool screen)
        {
            if (!SendUpdates)
                return;
            Network.GamePackets._String update = new _String(true);
            update.UID = this.UID;
            update.Type = type;
            update.TextsCount = 1;
            update.Texts.Add(value);
            if (EntityFlag == EntityFlag.Player)
            {
                if (!screen)
                    update.Send(Owner as Client.GameState);
                else
                    (Owner as Client.GameState).SendScreen(update, true);
            }
            else
            {
                MonsterInfo.SendScreen(update);
            }
        }
        private void UpdateDatabase(string column, byte value)
        {
            new Database.MySqlCommand(Conquer_Online_Server.Database.MySqlCommandType.UPDATE).Update("entities").Set(column, value).Where("UID", UID).Execute();
        }
        private void UpdateDatabase(string column, long value)
        {
            new Database.MySqlCommand(Conquer_Online_Server.Database.MySqlCommandType.UPDATE).Update("entities").Set(column, value).Where("UID", UID).Execute();
        }
        private void UpdateDatabase(string column, ulong value)
        {
            new Database.MySqlCommand(Conquer_Online_Server.Database.MySqlCommandType.UPDATE).Update("entities").Set(column, value).Where("UID", UID).Execute();
        }
        private void UpdateDatabase(string column, bool value)
        {
            new Database.MySqlCommand(Conquer_Online_Server.Database.MySqlCommandType.UPDATE).Update("entities").Set(column, value).Where("UID", UID).Execute();
        }
        private void UpdateDatabase(string column, string value)
        {
            new Database.MySqlCommand(Conquer_Online_Server.Database.MySqlCommandType.UPDATE).Update("entities").Set(column, value).Where("UID", UID).Execute();
        }
        public bool Move(Enums.ConquerAngle Direction)
        {
            ushort _X = X, _Y = Y;
            Facing = Direction;
            sbyte xi = 0, yi = 0;
            switch (Direction)
            {
                case Enums.ConquerAngle.North: xi = -1; yi = -1; break;
                case Enums.ConquerAngle.South: xi = 1; yi = 1; break;
                case Enums.ConquerAngle.East: xi = 1; yi = -1; break;
                case Enums.ConquerAngle.West: xi = -1; yi = 1; break;
                case Enums.ConquerAngle.NorthWest: xi = -1; break;
                case Enums.ConquerAngle.SouthWest: yi = 1; break;
                case Enums.ConquerAngle.NorthEast: yi = -1; break;
                case Enums.ConquerAngle.SouthEast: xi = 1; break;
            }
            _X = (ushort)(X + xi);
            _Y = (ushort)(Y + yi);
            Game.Map Map = null;
            if (ServerBase.Kernel.Maps.TryGetValue(MapID, out Map))
            {
                if (Map.Floor[_X, _Y, MapObjType, this])
                {
                    if (MapObjType == MapObjectType.Monster)
                    {
                        Map.Floor[_X, _Y, MapObjType, this] = false;
                        Map.Floor[X, Y, MapObjType, this] = true;
                    }
                    X = _X;
                    Y = _Y;
                    return true;
                }
                else
                {
                    if (Mode == Enums.Mode.None)
                    {
                        if (EntityFlag != EntityFlag.Monster)
                            Teleport(X, Y, MapID);
                        else
                            return false;
                    }
                }
            }
            else
            {
                if (EntityFlag != EntityFlag.Monster)
                    Teleport(X, Y, MapID);
                else
                    return false;
            }
            return true;
        }
        public void SendSpawn(Client.GameState client)
        {
            SendSpawn(client, true);
        }
        public void SendSpawn(Client.GameState client, bool checkScreen)
        {
            if (client.Screen.Add(this) || !checkScreen)
            {
                client.Send(SpawnPacket);
                if (EntityFlag == EntityFlag.Player)
                {
                    if (Owner.Booth != null)
                    {
                        client.Send(Owner.Booth);
                        if (Owner.Booth.HawkMessage != null)
                            client.Send(Owner.Booth.HawkMessage);
                    }
                }
            }
        }

        public void AddFlag(ulong flag)
        {
            //if (!ContainsFlag(Network.GamePackets.Update.Flags.Dead) && !ContainsFlag(Network.GamePackets.Update.Flags.Ghost))
            StatusFlag |= flag;
        }

        public bool ContainsFlag(ulong flag)
        {
            ulong aux = StatusFlag;
            aux &= ~flag;
            return !(aux == StatusFlag);
        }
        public void RemoveFlag(ulong flag)
        {
            if (ContainsFlag(flag))
            {
                StatusFlag &= ~flag;
            }
        }
        public void AddFlag2(ulong flag)
        {
            // if (!ContainsFlag(Network.GamePackets.Update.Flags.Dead) && !ContainsFlag(Network.GamePackets.Update.Flags.Ghost))
            StatusFlag2 |= flag;
        }
        public bool ContainsFlag2(ulong flag)
        {
            ulong aux = StatusFlag2;
            aux &= ~flag;
            return !(aux == StatusFlag2);
        }
        public void RemoveFlag2(ulong flag)
        {
            if (ContainsFlag2(flag))
            {
                StatusFlag2 &= ~flag;
            }
        }
        public void Shift(ushort X, ushort Y)
        {
            if (EntityFlag == EntityFlag.Player)
            {
                if (!Database.MapsTable.MapInformations.ContainsKey(MapID))
                    return;
                this.X = X;
                this.Y = Y;
                Network.GamePackets.Data Data = new Network.GamePackets.Data(true);
                Data.UID = UID;
                Data.ID = Network.GamePackets.Data.FlashStep;
                Data.dwParam = MapID;
                Data.wParam1 = X;
                Data.wParam2 = Y;
                Owner.SendScreen(Data, true);
                Owner.Screen.Reload(null);
            }
        }
        public void Teleport(ushort X, ushort Y)
        {
            if (EntityFlag == EntityFlag.Player)
            {
                if (!Database.MapsTable.MapInformations.ContainsKey(MapID))
                    return;
                this.X = X;
                this.Y = Y;
                Network.GamePackets.Data Data = new Network.GamePackets.Data(true);
                Data.UID = UID;
                Data.ID = Network.GamePackets.Data.Teleport;
                Data.dwParam = Database.MapsTable.MapInformations[MapID].BaseID;
                Data.wParam1 = X;
                Data.wParam2 = Y;
                Owner.Send(Data);
            }
        }
        public void SetLocation(ushort MapID, ushort X, ushort Y)
        {
            if (EntityFlag == EntityFlag.Player)
            {
                this.X = X;
                this.Y = Y;
                this.MapID = MapID;
            }
        }
        public void Teleport(ushort MapID, ushort X, ushort Y)
        {
            if (EntityFlag == EntityFlag.Player)
            {
                if (!Database.MapsTable.MapInformations.ContainsKey(MapID))
                    return;
                if (EntityFlag == EntityFlag.Player)
                {
                    if (Owner.Companion != null)
                    {
                        Owner.Map.RemoveEntity(Owner.Companion);
                        Data data = new Data(true);
                        data.UID = Owner.Companion.UID;
                        data.ID = Network.GamePackets.Data.RemoveEntity;
                        Owner.Companion.MonsterInfo.SendScreen(data);
                        Owner.Companion = null;
                    }
                }
                if (MapID == this.MapID)
                {
                    Teleport(X, Y);
                    return;
                }
                this.X = X;
                this.Y = Y;
                this.PreviousMapID = this.MapID;
                this.MapID = MapID;
                Network.GamePackets.Data Data = new Network.GamePackets.Data(true);
                Data.UID = UID;
                Data.ID = Network.GamePackets.Data.Teleport;
                Data.dwParam = Database.MapsTable.MapInformations[MapID].BaseID;
                Data.wParam1 = X;
                Data.wParam2 = Y;
                Owner.Send(Data);
                Owner.Send(new MapStatus() { BaseID = Owner.Map.BaseID, ID = Owner.Map.ID, Status = Database.MapsTable.MapInformations[Owner.Map.ID].Status });
                if (!Owner.Equipment.Free(12))
                    if (Owner.Map.ID == 1036 && Owner.Equipment.TryGetItem((byte)12).Plus < 6)
                        RemoveFlag(Network.GamePackets.Update.Flags.Ride);
            }
        }
        public ushort PrevX, PrevY;
        public void Teleport(ushort MapID, ushort DynamicID, ushort X, ushort Y)
        {
            if (EntityFlag == EntityFlag.Player)
            {
                if (!Database.DMaps.MapPaths.ContainsKey(MapID))
                    return;

                this.PrevX = this.X;
                this.PrevY = this.Y;
                this.X = X;
                this.Y = Y;
                this.PreviousMapID = this.MapID;
                this.MapID = DynamicID;
                Network.GamePackets.Data Data = new Network.GamePackets.Data(true);
                Data.UID = UID;
                Data.ID = Network.GamePackets.Data.Teleport;
                Data.dwParam = MapID;
                Data.wParam1 = X;
                Data.wParam2 = Y;
                Owner.Send(Data);
                Owner.Send(new MapStatus() { BaseID = Owner.Map.BaseID, ID = Owner.Map.ID, Status = Database.MapsTable.MapInformations[Owner.Map.ID].Status });
                if (!Owner.Equipment.Free(12))
                    if (Owner.Map.ID == 1036 && Owner.Equipment.TryGetItem((byte)12).Plus < 6)
                        RemoveFlag(Network.GamePackets.Update.Flags.Ride);
            }
        }

        public bool OnKOSpell()
        {
            return OnCyclone() || OnSuperman();
        }
        public bool OnOblivion()
        {
            return ContainsFlag2(Network.GamePackets.Update.Flags2.Oblivion);
        }
        public bool OnCyclone()
        {
            return ContainsFlag(Network.GamePackets.Update.Flags.Cyclone);
        }
        public bool OnSuperman()
        {
            return ContainsFlag(Network.GamePackets.Update.Flags.Superman);
        }
        public bool OnFatalStrike()
        {
            return ContainsFlag(Network.GamePackets.Update.Flags.FatalStrike);
        }

        public void Untransform()
        {
            if (MapID == 1036 && TransformationTime == 3600)
                return;
            this.TransformationID = 0;

            double maxHP = TransformationMaxHP;
            double HP = Hitpoints;
            double point = HP / maxHP;

            Hitpoints = (uint)(MaxHitpoints * point);
            Update(Network.GamePackets.Update.MaxHitpoints, MaxHitpoints, false);
        }
        public byte[] WindowSpawn()
        {
            byte[] buffer = new byte[SpawnPacket.Length];
            SpawnPacket.CopyTo(buffer, 0);
            buffer[77] = 1;
            return buffer;
        }
        //
        public byte TitleActivated
        {
            get { return SpawnPacket[167]; }
            set { SpawnPacket[167] = value; }
        }
        //


        #endregion

        public uint topguildleader { get; set; }
        public uint topdeputyleader { get; set; }
        public uint weeklyPKwar { get; set; }
        public TitlePacket TitlePacket { get; set; }
        public Features.Flowers.Flowers Flowers { get; set; }
        public int TopTrojan { get; set; }
        public int TopWarrior { get; set; }
        public int TopNinja { get; set; }
        public int TopWater { get; set; }
        public int TopFire { get; set; }
        public int TopArcher { get; set; }
        public int TopMonk { get; set; }

        //public ClientStatus ClientStats;
        //public StatusStatics Statistics;

        public uint PkChampion { get; set; }

        public uint InteractionWith = 0;

        public bool InteractionSet = false;

        public bool InteractionInProgress = false;

        public uint InteractionType = 0;

        internal void SendScreen1(Interfaces.IPacket Data)
        {
            Client.GameState[] Chars = new Client.GameState[ServerBase.Kernel.GamePool.Count];
            ServerBase.Kernel.GamePool.Values.CopyTo(Chars, 0);
            foreach (Client.GameState C in Chars)
                if (C != null)
                    if (C.Entity != null)
                        if (Game.Attacking.Calculate.PointDistance(X, Y, C.Entity.X, C.Entity.Y) <= 20)
                            C.Send(Data);
            Chars = null;
        }


        public ushort Intensification { get; set; }

        public uint CriticalStrike { get; set; }

        public uint Immunity { get; set; }

        public uint Penetration { get; set; }

        public uint Block { get; set; }

        public ushort Counteraction { get; set; }

        public uint Detoxication { get; set; }

        public uint SkillCStrike { get; set; }
        public uint tID = 0;

        public int HeavenBlessingTime { get; set; }

        public uint BoundConquerPoints { get; set; }

        public uint RidingCropID { get; set; }

        public ushort _arenamap { get; set; }
    }
} 

this is my equipment.cs updated what i need here?

PHP Code:
using System;
using System.Collections.Generic;
using Conquer_Online_Server.Network.GamePackets;

namespace Conquer_Online_Server.Game.ConquerStructures
{
    public class Equipment
    {
        Interfaces.IConquerItem[] objects;
        Client.GameState Owner;
        public Equipment(Client.GameState client)
        {
            Owner = client;
            objects = new Interfaces.IConquerItem[20];
        }

        public void UpdateEntityPacket()
        {
            for (byte Position = 1; Position < 19; Position++)
            {
                if (Free(Position))
                {
                    ClearItemview(Position);
                }
                else
                {
                    var item = TryGetItem(Position);
                    UpdateItemview(item);
                }
            }
            Owner.SendScreen(Owner.Entity.SpawnPacket, false);
        }
        public bool Add(Interfaces.IConquerItem item)
        {
            if (objects[item.Position - 1] == null)
            {
                UpdateItemview(item);
                objects[item.Position - 1] = item;
                item.Position = item.Position;
                item.Send(Owner);
                Owner.LoadItemStats(item);
                Owner.SendScreenSpawn(Owner.Entity, false);

                return true;
            }
            else return false;
        }
        public bool Add(Interfaces.IConquerItem item, Enums.ItemUse use)
        {
            if (objects[item.Position - 1] == null)
            {
                objects[item.Position - 1] = item;
                item.Mode = Enums.ItemMode.Default;

                if (use != Enums.ItemUse.None)
                {
                    UpdateItemview(item);
                    item.Send(Owner);
                    Owner.LoadItemStats(item);
                }
                return true;
            }
            else return false;
        }


        public void ClearItemview(uint Position)
        {
            switch ((ushort)Position)
            {
                case Network.GamePackets.ConquerItem.Head:
                    Network.Writer.WriteUInt32(0, 176, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt32(0, 40, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt16(0, 109, Owner.Entity.SpawnPacket);
                    break;
                case Network.GamePackets.ConquerItem.Garment:
                    Network.Writer.WriteUInt32(0, 44, Owner.Entity.SpawnPacket);
                    break;
                case Network.GamePackets.ConquerItem.Armor:
                    Network.Writer.WriteUInt32(0, 180, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt32(0, 48, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt16(0, 123, Owner.Entity.SpawnPacket);
                    break;
                case Network.GamePackets.ConquerItem.RightWeapon:
                    Network.Writer.WriteUInt32(0, 188, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt32(0, 56, Owner.Entity.SpawnPacket);
                    break;
                case Network.GamePackets.ConquerItem.LeftWeapon:
                    Network.Writer.WriteUInt32(0, 184, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt32(0, 52, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt16(0, 107, Owner.Entity.SpawnPacket);
                    break;
                case Network.GamePackets.ConquerItem.RightWeaponAccessory:
                    Network.Writer.WriteUInt32(0, 54, Owner.Entity.SpawnPacket);
                    if (!Free(Network.GamePackets.ConquerItem.RightWeapon))
                    {
                        var item = TryGetItem(Network.GamePackets.ConquerItem.RightWeapon);
                        Network.Writer.WriteUInt32(item.ID, 64, Owner.Entity.SpawnPacket);
                    }
                    break;
                case Network.GamePackets.ConquerItem.LeftWeaponAccessory:
                    Network.Writer.WriteUInt32(0, 60, Owner.Entity.SpawnPacket);
                    if (!Free(Network.GamePackets.ConquerItem.LeftWeapon))
                    {
                        var item = TryGetItem(Network.GamePackets.ConquerItem.LeftWeapon);

                        Network.Writer.WriteUInt32(item.ID, 50, Owner.Entity.SpawnPacket);
                    }
                    break;
                case Network.GamePackets.ConquerItem.Steed:
                    Network.Writer.WriteUInt32(0, 68, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt16(0, 133, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt32(0, 139, Owner.Entity.SpawnPacket);
                    break;
            }
        }
        public void UpdateItemview(Interfaces.IConquerItem item)
        {
            switch ((ushort)item.Position)
            {
                case Network.GamePackets.ConquerItem.Head:
                    if (item.Purification.Available)
                        Network.Writer.WriteUInt32(item.Purification.PurificationItemID, 176, Owner.Entity.SpawnPacket);

                    Network.Writer.WriteUInt32(item.ID, 40, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt16((byte)item.Color, 109, Owner.Entity.SpawnPacket);
                    break;
                case Network.GamePackets.ConquerItem.Garment:
                    Network.Writer.WriteUInt32(item.ID, 44, Owner.Entity.SpawnPacket);
                    break;
                case Network.GamePackets.ConquerItem.Armor:
                    if (item.Purification.Available)
                        Network.Writer.WriteUInt32(item.Purification.PurificationItemID, 180, Owner.Entity.SpawnPacket);

                    Network.Writer.WriteUInt32(item.ID, 48, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt16((byte)item.Color, 109, Owner.Entity.SpawnPacket);
                    break;
                case Network.GamePackets.ConquerItem.RightWeapon:
                    if (item.Purification.Available)
                        Network.Writer.WriteUInt32(item.Purification.PurificationItemID, 188, Owner.Entity.SpawnPacket);
                    if (!Free(Network.GamePackets.ConquerItem.RightWeaponAccessory))
                    {
                        var Item = TryGetItem(Network.GamePackets.ConquerItem.RightWeaponAccessory);
                        //2-Handed accessories
                        if (Item.ID >= 350001 && Item.ID <= 350020)
                        {
                            if (Network.PacketHandler.IsTwoHand(item.ID))
                            {
                                Network.Writer.WriteUInt32(Item.ID, 56, Owner.Entity.SpawnPacket);
                                break;
                            }
                        }
                        //1-Handed accessories
                        if (Item.ID >= 360001 && Item.ID <= 360040)
                        {
                            if (!Network.PacketHandler.IsTwoHand(item.ID))
                            {
                                Network.Writer.WriteUInt32(Item.ID, 54, Owner.Entity.SpawnPacket);
                                break;
                            }
                        }
                        //Bow accessories
                        if (Item.ID >= 370001 && Item.ID <= 370015)
                        {
                            if (item.ID / 1000 == 500)
                            {
                                Network.Writer.WriteUInt32(Item.ID, 54, Owner.Entity.SpawnPacket);
                                break;
                            }
                        }
                    }
                    Network.Writer.WriteUInt32(item.ID, 54, Owner.Entity.SpawnPacket);
                    break;
                case Network.GamePackets.ConquerItem.RightWeaponAccessory:
                    if (!Free(Network.GamePackets.ConquerItem.RightWeapon))
                    {
                        var Item = TryGetItem(Network.GamePackets.ConquerItem.RightWeapon);
                        //2-Handed accessories
                        if (item.ID >= 350001 && item.ID <= 350020)
                        {
                            if (Network.PacketHandler.IsTwoHand(Item.ID))
                            {
                                Network.Writer.WriteUInt32(item.ID, 54, Owner.Entity.SpawnPacket);
                                break;
                            }
                        }
                        //1-Handed accessories
                        if (item.ID >= 360001 && item.ID <= 360040)
                        {
                            if (!Network.PacketHandler.IsTwoHand(Item.ID))
                            {
                                Network.Writer.WriteUInt32(item.ID, 54, Owner.Entity.SpawnPacket);
                                break;
                            }
                        }
                        //Bow accessories
                        if (item.ID >= 370001 && item.ID <= 370015)
                        {
                            if (Item.ID / 1000 == 500)
                            {
                                Network.Writer.WriteUInt32(item.ID, 54, Owner.Entity.SpawnPacket);
                                break;
                            }
                        }
                    }
                    break;
                case Network.GamePackets.ConquerItem.LeftWeapon:
                    if (item.Purification.Available)
                        Network.Writer.WriteUInt32(item.Purification.PurificationItemID, 184, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt16((byte)item.Color, 107, Owner.Entity.SpawnPacket);
                    if (!Free(Network.GamePackets.ConquerItem.LeftWeaponAccessory))
                    {
                        var Item = TryGetItem(Network.GamePackets.ConquerItem.LeftWeaponAccessory);

                        //1-Handed accessories
                        if (Item.ID >= 360001 && Item.ID <= 360040 && item.ID / 1000 != 900)
                        {
                            if (!Network.PacketHandler.IsTwoHand(item.ID))
                            {
                                Network.Writer.WriteUInt32(Item.ID, 60, Owner.Entity.SpawnPacket);
                                break;
                            }
                        }
                        //Shield accessories
                        if (Item.ID >= 380001 && Item.ID <= 380015)
                        {
                            if (item.ID / 1000 == 900)
                            {
                                Network.Writer.WriteUInt32(Item.ID, 50, Owner.Entity.SpawnPacket);
                                break;
                            }
                        }
                    }
                    Network.Writer.WriteUInt32(item.ID, 60, Owner.Entity.SpawnPacket);
                    break;
                case Network.GamePackets.ConquerItem.LeftWeaponAccessory:
                    if (!Free(Network.GamePackets.ConquerItem.LeftWeapon))
                    {
                        var Item = TryGetItem(Network.GamePackets.ConquerItem.LeftWeapon);

                        //1-Handed accessories
                        if (item.ID >= 360001 && item.ID <= 360040)
                        {
                            if (!Network.PacketHandler.IsTwoHand(Item.ID))
                            {
                                Network.Writer.WriteUInt32(item.ID, 60, Owner.Entity.SpawnPacket);
                                break;
                            }
                        }
                        //Shield accessories
                        if (item.ID >= 380001 && item.ID <= 380015)
                        {
                            if (Item.ID / 1000 == 900)
                            {
                                Network.Writer.WriteUInt32(item.ID, 50, Owner.Entity.SpawnPacket);
                                break;
                            }
                        }
                    }
                    break;
                case Network.GamePackets.ConquerItem.Steed:
                    Network.Writer.WriteUInt32(item.ID, 68, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt16((byte)item.Plus, 133, Owner.Entity.SpawnPacket);
                    Network.Writer.WriteUInt32(item.SocketProgress, 139, Owner.Entity.SpawnPacket);
                    break;
            }
        }

        public bool Remove(byte Position)
        {
            if (objects[Position - 1] != null)
            {
                if (Owner.Inventory.Count <= 39)
                {
                    if (Owner.Inventory.Add(objects[Position - 1], Enums.ItemUse.Move))
                    {
                        objects[Position - 1].Position = Position;
                        Owner.UnloadItemStats(objects[Position - 1], false);
                        objects[Position - 1].Position = 0;
                        if (Position == 12)
                            Owner.Entity.RemoveFlag(Network.GamePackets.Update.Flags.Ride);
                        if (Position == 4)
                            Owner.Entity.RemoveFlag(Network.GamePackets.Update.Flags.Fly);
                        Network.GamePackets.ItemUsage iu = new Network.GamePackets.ItemUsage(true);
                        iu.UID = objects[Position - 1].UID;
                        iu.dwParam = Position;
                        iu.ID = Network.GamePackets.ItemUsage.UnequipItem;
                        Owner.Send(iu);
                        ClearItemview(Position);
                        objects[Position - 1] = null;
                        Owner.SendScreenSpawn(Owner.Entity, false);
                        return true;
                    }
                }
                else
                {
                    Owner.Send(new Network.GamePackets.Message("Not enough room in your inventory.", System.Drawing.Color.Blue, Network.GamePackets.Message.TopLeft));
                }
            }
            return false;
        }
        public bool DestroyArrow(uint Position)
        {
            if (objects[Position - 1] != null)
            {
                objects[Position - 1].Position = (ushort)Position;
                if (objects[Position - 1].ID == 0)
                {
                    objects[Position - 1].Position = 0;
                    Database.ConquerItemTable.DeleteItem(objects[Position - 1].UID);
                    objects[Position - 1] = null;
                    return true;
                }
                if (!Network.PacketHandler.IsArrow(objects[Position - 1].ID))
                    return false;

                Owner.UnloadItemStats(objects[Position - 1], false);
                Database.ConquerItemTable.DeleteItem(objects[Position - 1].UID);
                Network.GamePackets.ItemUsage iu = new Network.GamePackets.ItemUsage(true);
                iu.UID = objects[Position - 1].UID;
                iu.dwParam = Position;
                iu.ID = Network.GamePackets.ItemUsage.UnequipItem;
                Owner.Send(iu);
                iu.dwParam = 0;
                iu.ID = Network.GamePackets.ItemUsage.RemoveInventory;
                Owner.Send(iu);
                ClearItemview(Position);
                objects[Position - 1].Position = 0;
                objects[Position - 1] = null;
                return true;
            }
            return false;
        }
        public bool RemoveToGround(uint Position)
        {
            if (Position == 0 || Position > 18)
                return true;
            if (objects[Position - 1] != null)
            {
                objects[Position - 1].Position = (ushort)Position;
                Owner.UnloadItemStats(objects[Position - 1], false);
                objects[Position - 1].Position = 0;
                Database.ConquerItemTable.RemoveItem(objects[Position - 1].UID);
                Network.GamePackets.ItemUsage iu = new Network.GamePackets.ItemUsage(true);
                iu.UID = objects[Position - 1].UID;
                iu.dwParam = Position;
                iu.ID = Network.GamePackets.ItemUsage.UnequipItem;
                Owner.Send(iu);
                iu.dwParam = 0;
                iu.ID = Network.GamePackets.ItemUsage.RemoveInventory;
                Owner.Send(iu);

                ClearItemview(Position);
                objects[Position - 1] = null;
                return true;
            }
            return false;
        }
        public Interfaces.IConquerItem[] Objects
        {
            get
            {
                return objects;
            }
        }
        public byte Count
        {
            get
            {
                byte count = 0; foreach (Interfaces.IConquerItem i in objects)
                    if (i != null)
                        count++; return count;
            }
        }
        public bool Free(byte Position)
        {
            return TryGetItem(Position) == null;
        }
        public bool Free(uint Position)
        {
            return TryGetItem((byte)Position) == null;
        }
        public Interfaces.IConquerItem TryGetItem(byte Position)
        {
            Interfaces.IConquerItem item = null;
            if (Position < 1 || Position > 17)
                return item;
            item = objects[Position - 1];
            return item;
        }
        public Interfaces.IConquerItem TryGetItem(uint uid)
        {
            try
            {
                foreach (Interfaces.IConquerItem item in objects)
                {
                    if (item != null)
                        if (item.UID == uid)
                            return item;
                }
            }
            catch (Exception e)
            {
                Program.SaveException(e);
                Console.WriteLine(e);
            }
            return TryGetItem((byte)uid);
        }

        public bool IsArmorSuper()
        {
            if (TryGetItem(3) != null)
                return TryGetItem(3).ID % 10 == 9;
            return false;
        }
        public bool IsAllSuper()
        {
            for (byte count = 1; count < 12; count++)
            {
                if (count == 5)
                {
                    if (Owner.Entity.Class > 100)
                        continue;
                    if (TryGetItem(count) != null)
                    {
                        if (Network.PacketHandler.IsArrow(TryGetItem(count).ID))
                            continue;
                        if (Network.PacketHandler.IsTwoHand(TryGetItem(4).ID))
                            continue;
                        if (TryGetItem(count).ID % 10 != 9)
                            return false;
                    }
                }
                else
                {
                    if (TryGetItem(count) != null)
                    {
                        if (count != Network.GamePackets.ConquerItem.Bottle && count != Network.GamePackets.ConquerItem.Garment)
                            if (TryGetItem(count).ID % 10 != 9)
                                return false;
                    }
                    else
                        if (count != Network.GamePackets.ConquerItem.Bottle && count != Network.GamePackets.ConquerItem.Garment)
                            return false;
                }
            }
            return true;
        }


        //

        internal static Interfaces.IConquerItem TrGetitem(byte Position)
        {
            Interfaces.IConquerItem item = null;
            if (Position < 1 || Position > 17)
                return item;
            //  item = objects[Position - 1];
            return item;
        }
    }
} 
please anyone help me

please anyone help me
†Pôwèrfull† is offline  
Old   #2
 
elite*gold: 21
The Black Market: 7/0/0
Join Date: Jul 2005
Posts: 9,193
Received Thanks: 5,385
No one is just going to 'do it for you'.

Learn to structure some packets (ooh wait... I as well as others have already written guides on how to do that) and log some packets (again... many guides and fully working tools) and upgrade your source.
pro4never is offline  
Old   #3
 
†Pôwèrfull†'s Avatar
 
elite*gold: 0
The Black Market: 0/0/0
Join Date: Aug 2011
Posts: 30
Received Thanks: 2
Quote:
Originally Posted by pro4never View Post
No one is just going to 'do it for you'.

Learn to structure some packets (ooh wait... I as well as others have already written guides on how to do that) and log some packets (again... many guides and fully working tools) and upgrade your source.
im learning men where is the guides to update? but look i was updated and dont work i woant to know what its my error?
†Pôwèrfull† is offline  
Reply

« Vote System | Exp Calculation »

Similar Threads Similar Threads
Was ist eine 16 bit entity ?
07/31/2011 - Minecraft - 1 Replies
Hallo Ich habe einen kleinen Bukkit Server. Nun wollte ich aber einnen Tiermod installieren ,dass es z.B Haie etc. gibt , da es kein Plugin gibt. Auf der Seite von dem Mod steht : Q.: Does this work for SMP? A.: Using itemcraft, you can play this mod for multiplayer Also muss ich ItemCraft Instalieren. Nun habe ich nur die Snapshot 0.0.1 , start.bat und den ItemCraft.jar in einen Ordner gezogen und die META-INF gelöscht. Mir wurde gesagt ,dass ich noch die 16 bit entyty hinzufügen...
Entity Movement
06/15/2011 - CO2 Programming - 6 Replies
These are the results from a quick sniffing session: ; west (x--, y++) 18 00 15 27 71 00 00 00 XX XX XX XX 01 00 00 00 DF 8D 47 04 00 00 00 00 ; north west (x--) 18 00 15 27 22 00 00 00 XX XX XX XX 01 00 00 00 D5 01 48 04 00 00 00 00 ; north (x--, y--) 18 00 15 27 03 00 00 00 XX XX XX XX 01 00 00 00 ED A6 48 04 00 00 00 00
WTT ISRO whit SWSRO2 clean or whit a noobie in it
06/28/2010 - Silkroad Online Trading - 0 Replies
lvl70 ISRO char server Eldorado name: IAmTheGame FF whit 190k sp and gold dragon flag WTT whit clean swsro2 account or whit a noob char in it thanks MSN: [email protected] Country: sweden
Special Entity
09/01/2005 - World of Warcraft - 4 Replies
Well, I was doing a stockade gangbang to lvl my mage. I pulled all the mobs to the beginning, and waited in the wall. As I looked on the minimap and point in the "Mob Train" I saw this strange "Jcffb0b" Entity/Player/Mob/Npc/Shit. I was like goddammnitagmigottagetthefuckouttahere. When I did it again later, there were the same thing... Maybe someone knows what it is? Don't think it's something harmful anymore, just curious about it :P ...



All times are GMT +2. The time now is 10:13.

elitepvpers - play less, get more - Top

Powered by vBulletin®
Copyright ©2000 - 2026, Jelsoft Enterprises Ltd.
SEO by vBSEO ©2011, Crawlability, Inc.

Support | Contact Us | FAQ | Advertising | Privacy Policy | Terms of Service | Abuse
Copyright ©2026 elitepvpers All Rights Reserved.