![[Help] Spawn Packet](https://www.elitepvpers.com/forum/iconimages/co2-private-server/help-spawn-packet_ltr.gif){kind=small}
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, 153); }
set { WriteUInt16(value, 153, SpawnPacket); }
}
string _ClanName = "";
public string ClanName
{
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, 149); }
set { WriteUInt32(value, 149, SpawnPacket); }
}
#endregion
//
public byte FirstRebornClass
{
get
{
return SpawnPacket[201];
}
set
{
SpawnPacket[201] = value;
}
}
public byte SecondRebornClass
{
get
{
return SpawnPacket[203];
}
set
{
SpawnPacket[203] = 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 + 214 + Name.Length];
WriteUInt16((ushort)(214 + Name.Length), 0, SpawnPacket);
WriteUInt16(10014, 2, SpawnPacket);
SpawnPacket[211] = 4;
SpawnPacket[212] = (byte)_Name.Length;
WriteString(_Name, 213, 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[92] = _reborn;
return _reborn;
}
set
{
if (EntityFlag == EntityFlag.Player)
{
Update(Network.GamePackets.Update.Reborn, value, true);
}
_reborn = value;
SpawnPacket[92] = value;
}
}
public byte Level
{
get
{
SpawnPacket[93] = _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[93] = 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[96];
}
set
{
SpawnPacket[96] = 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, 78, SpawnPacket);
}
}
public ConquerStructures.NobilityRank NobilityRank
{
get
{
return (Conquer_Online_Server.Game.ConquerStructures.NobilityRank)SpawnPacket[113];
}
set
{
SpawnPacket[113] = (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, 80, SpawnPacket);
}
}
public ushort Y
{
get
{
return _y;
}
set
{
_y = value;
WriteUInt16(value, 82, SpawnPacket);
}
}
public ushort PX
{
get;
set;
}
public ushort PY
{
get;
set;
}
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, 85); }
set
{
WriteUInt16(value, 85, SpawnPacket);
}
}
public Enums.ConquerAngle Facing
{
get { return (Enums.ConquerAngle)SpawnPacket[84]; }
set
{
SpawnPacket[84] = (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[161]; }
set { SpawnPacket[161] = 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; }
}
}
