public static float GetSpeed(Entity entity, float stat)
{
float ret = 4 + 5.6f*(stat/75f);
if (entity.HasConditionEffect(ConditionEffectIndex.Speedy))
ret *= 1.5f;
if (entity.HasConditionEffect(ConditionEffectIndex.Slowed))
ret = 4;
if (entity.HasConditionEffect(ConditionEffectIndex.Paralyzed))
ret = 0;
return ret;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
BuzzStorage storage = (BuzzStorage)state;
Status = CycleStatus.NotStarted;
if (host.HasConditionEffect(ConditionEffects.Paralyzed)) return;
if (storage.RemainingTime > 0)
{
storage.RemainingTime -= time.thisTickTimes;
Status = CycleStatus.NotStarted;
}
else
{
Status = CycleStatus.InProgress;
if (storage.RemainingDistance <= 0)
{
do
{
storage.Direction = new Vector2(Random.Next(-1, 2), Random.Next(-1, 2));
} while (storage.Direction.X == 0 && storage.Direction.Y == 0);
storage.Direction.Normalize();
storage.RemainingDistance = this.dist;
Status = CycleStatus.Completed;
}
float dist = host.GetSpeed(speed) * (time.thisTickTimes / 1000f);
host.ValidateAndMove(host.X + storage.Direction.X * dist, host.Y + storage.Direction.Y * dist);
host.UpdateCount++;
storage.RemainingDistance -= dist;
}
state = storage;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
int cool = (int) state;
if (cool <= 0)
{
if (host.HasConditionEffect(ConditionEffectIndex.Stunned)) return;
Position target = new Position
{
X = host.X + (float) (range*Math.Cos(angle.Value)),
Y = host.Y + (float) (range*Math.Sin(angle.Value)),
};
host.Owner.Timers.Add(new WorldTimer(0, (world, t) =>
{
Entity entity = Entity.Resolve(world.Manager, child);
entity.Move(target.X, target.Y);
(entity as Enemy).Terrain = (host as Enemy).Terrain;
world.EnterWorld(entity);
}));
cool = coolDown.Next(Random);
}
else
cool -= time.thisTickTimes;
state = cool;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
int cool = (int)state;
if (cool <= 0)
{
if (host.HasConditionEffect(ConditionEffects.Stunned)) return;
Position target = new Position()
{
X = host.X + (float)(range * Math.Cos(angle.Value)),
Y = host.Y + (float)(range * Math.Sin(angle.Value)),
};
host.Owner.BroadcastPacket(new ShowEffectPacket()
{
EffectType = EffectType.Throw,
Color = new ARGB(0xffffbf00),
TargetId = host.Id,
PosA = target
}, null);
host.Owner.Timers.Add(new WorldTimer(1500, (world, t) =>
{
Entity entity = Entity.Resolve(child);
entity.Move(target.X, target.Y);
(entity as Enemy).Terrain = (host as Enemy).Terrain;
world.EnterWorld(entity);
}));
cool = coolDown.Next(Random);
}
else
cool -= time.thisTickTimes;
state = cool;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
WanderStorage storage;
if (state == null) storage = new WanderStorage();
else storage = (WanderStorage)state;
Status = CycleStatus.NotStarted;
if (host.HasConditionEffect(ConditionEffects.Paralyzed)) return;
Status = CycleStatus.InProgress;
if (storage.RemainingDistance <= 0)
{
storage.Direction = new Vector2(Random.Next(-1, 2), Random.Next(-1, 2));
storage.Direction.Normalize();
storage.RemainingDistance = period.Next(Random) / 1000f;
Status = CycleStatus.Completed;
}
float dist = host.GetSpeed(speed) * (time.thisTickTimes / 1000f);
host.ValidateAndMove(host.X + storage.Direction.X * dist, host.Y + storage.Direction.Y * dist);
host.UpdateCount++;
storage.RemainingDistance -= dist;
state = storage;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
if (!returned)
{
if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed)) return;
var spd = host.GetSpeed(speed) * (time.thisTickTimes / 1000f);
Position pos = (host as Enemy).SpawnPoint;
var tx = pos.X;
var ty = pos.Y;
if (Math.Abs(tx - host.X) > 1 || Math.Abs(ty - host.Y) > 1)
{
var x = host.X;
var y = host.Y;
Vector2 vect = new Vector2(tx, ty) - new Vector2(host.X, host.Y);
vect.Normalize();
vect *= spd;
host.Move(host.X + vect.X, host.Y + vect.Y);
host.UpdateCount++;
}
if (host.X == pos.X && host.Y == pos.Y && once)
{
once = true;
returned = true;
}
}
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
var s = (OrbitState) state;
Status = CycleStatus.NotStarted;
if (host.HasConditionEffect(ConditionEffects.Paralyzed)) return;
Entity entity = host.GetNearestEntity(acquireRange, target);
if (entity != null)
{
double angle;
if (host.Y == entity.Y && host.X == entity.X) //small offset
angle = Math.Atan2(host.Y - entity.Y + (Random.NextDouble()*2 - 1),
host.X - entity.X + (Random.NextDouble()*2 - 1));
else
angle = Math.Atan2(host.Y - entity.Y, host.X - entity.X);
float angularSpd = host.GetSpeed(s.Speed)/s.Radius;
angle += angularSpd*(time.thisTickTimes/1000f);
double x = entity.X + Math.Cos(angle)*radius;
double y = entity.Y + Math.Sin(angle)*radius;
Vector2 vect = new Vector2((float) x, (float) y) - new Vector2(host.X, host.Y);
vect.Normalize();
vect *= host.GetSpeed(s.Speed)*(time.thisTickTimes/1000f);
host.ValidateAndMove(host.X + vect.X, host.Y + vect.Y);
host.UpdateCount++;
Status = CycleStatus.InProgress;
}
state = s;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
ProtectState s;
if (state == null) s = ProtectState.DontKnowWhere;
else s = (ProtectState) state;
Status = CycleStatus.NotStarted;
if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed)) return;
Entity entity = host.GetNearestEntity(acquireRange, protectee);
Vector2 vect;
switch (s)
{
case ProtectState.DontKnowWhere:
if (entity != null)
{
s = ProtectState.Protecting;
goto case ProtectState.Protecting;
}
break;
case ProtectState.Protecting:
if (entity == null)
{
s = ProtectState.DontKnowWhere;
break;
}
vect = new Vector2(entity.X - host.X, entity.Y - host.Y);
if (vect.Length > reprotectRange)
{
Status = CycleStatus.InProgress;
vect.Normalize();
float dist = host.GetSpeed(speed)*(time.thisTickTimes/1000f);
host.ValidateAndMove(host.X + vect.X*dist, host.Y + vect.Y*dist);
host.UpdateCount++;
}
else
{
Status = CycleStatus.Completed;
s = ProtectState.Protected;
}
break;
case ProtectState.Protected:
if (entity == null)
{
s = ProtectState.DontKnowWhere;
break;
}
Status = CycleStatus.Completed;
vect = new Vector2(entity.X - host.X, entity.Y - host.Y);
if (vect.Length > protectionRange)
{
s = ProtectState.Protecting;
goto case ProtectState.Protecting;
}
break;
}
state = s;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
int cooldown;
if (state == null) cooldown = 1000;
else cooldown = (int)state;
Status = CycleStatus.NotStarted;
if (host.HasConditionEffect(ConditionEffects.Paralyzed)) return;
var player = (Player)host.GetNearestEntity(distance, null);
if (player != null)
{
Vector2 vect;
vect = new Vector2(player.X - host.X, player.Y - host.Y);
vect.Normalize();
float dist = host.GetSpeed(speed) * (time.thisTickTimes / 1000f);
host.ValidateAndMove(host.X + (-vect.X) * dist, host.Y + (-vect.Y) * dist);
host.UpdateCount++;
if (cooldown <= 0)
{
Status = CycleStatus.Completed;
cooldown = 1000;
}
else
{
Status = CycleStatus.InProgress;
cooldown -= time.thisTickTimes;
}
}
state = cooldown;
}
public static float GetDefenseDamage(Entity host, int dmg, int def)
{
if (host.HasConditionEffect(ConditionEffectIndex.Armored))
def *= 2;
if (host.HasConditionEffect(ConditionEffectIndex.ArmorBroken))
def = 0;
float limit = dmg*0.15f;
float ret;
if (dmg - def < limit) ret = limit;
else ret = dmg - def;
if (host.HasConditionEffect(ConditionEffectIndex.Invulnerable) ||
host.HasConditionEffect(ConditionEffectIndex.Invincible))
ret = 0;
return ret;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
int cool = (int)state;
if (cool <= 0)
{
if (host.HasConditionEffect(ConditionEffects.Stunned)) return;
Entity player = host.GetNearestEntity(range, null);
if (player != null || fixedAngle != null)
{
Position target;
if (fixedAngle != null)
target = new Position()
{
X = (float)(range * Math.Cos(fixedAngle.Value)),
Y = (float)(range * Math.Sin(fixedAngle.Value)),
};
else
target = new Position()
{
X = player.X,
Y = player.Y,
};
host.Owner.BroadcastPacket(new ShowEffectPacket()
{
EffectType = EffectType.Throw,
Color = new ARGB(0xffff0000),
TargetId = host.Id,
PosA = target
}, null);
host.Owner.Timers.Add(new WorldTimer(1500, (world, t) =>
{
world.BroadcastPacket(new AOEPacket()
{
Position = target,
Radius = radius,
Damage = (ushort)damage,
EffectDuration = 0,
Effects = 0,
OriginType = host.ObjectType
}, null);
EntityUtils.AOE(world, target, radius, true, p =>
{
(p as IPlayer).Damage(damage, host as Character);
});
}));
}
cool = coolDown.Next(Random);
}
else
cool -= time.thisTickTimes;
state = cool;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
int cool = (int) state;
if (cool <= 0)
{
if (host.HasConditionEffect(ConditionEffectIndex.Stunned)) return;
double? tossAngle = randomToss ? Random.Next(0, 360)*Math.PI/180 : angle;
Entity en = null;
if(tossAngle == null)
en = host.GetNearestEntity(range, null);
if (tossAngle == null && en == null) return;
Position target = tossAngle == null ?
new Position
{
X = en.X,
Y = en.Y
} :
new Position
{
X = host.X + (float)(range * Math.Cos(tossAngle.Value)),
Y = host.Y + (float)(range * Math.Sin(tossAngle.Value)),
};
host.Owner.BroadcastPacket(new ShowEffectPacket
{
EffectType = EffectType.Throw,
Color = new ARGB(0xffffbf00),
TargetId = host.Id,
PosA = target
}, null);
host.Owner.Timers.Add(new WorldTimer(1500, (world, t) =>
{
Entity entity = Entity.Resolve(world.Manager, child);
entity.Move(target.X, target.Y);
if(entity is Enemy && host is Enemy)
(entity as Enemy).Terrain = (host as Enemy).Terrain;
world.EnterWorld(entity);
}));
cool = coolDown.Next(Random);
}
else
cool -= time.thisTickTimes;
state = cool;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
int cool = (int)state;
if (cool <= 0)
{
if (host.HasConditionEffect(ConditionEffectIndex.Sick)) return;
Player entity = host.GetNearestEntity(range, null) as Player;
if (entity != null)
{
int maxHp = entity.Stats[0] + entity.Boost[0];
int newHp = Math.Min(maxHp, entity.HP + amount);
if (newHp != entity.HP)
{
int n = newHp - entity.HP;
entity.HP = newHp;
entity.UpdateCount++;
entity.Owner.BroadcastPacket(new ShowEffectPacket
{
EffectType = EffectType.Potion,
TargetId = entity.Id,
Color = new ARGB(0xffffffff)
}, null);
entity.Owner.BroadcastPacket(new ShowEffectPacket
{
EffectType = EffectType.Trail,
TargetId = host.Id,
PosA = new Position { X = entity.X, Y = entity.Y },
Color = new ARGB(0xffffffff)
}, null);
entity.Owner.BroadcastPacket(new NotificationPacket
{
ObjectId = entity.Id,
Text = "{\"key\":\"blank\",\"tokens\":{\"data\":\"+" + n + "\"}}",
Color = new ARGB(0xff00ff00)
}, null);
}
}
cool = coolDown.Next(Random);
}
else
cool -= time.thisTickTimes;
state = cool;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
//var en = host.GetNearestEntity(20, null);
//var player = en as Player;
//if (en == null)
//{
// return;
//}
float dist;
if (state == null) dist = distance;
else dist = (float)state;
Status = CycleStatus.NotStarted;
if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed)) return;
float moveDist = host.GetSpeed(speed) * (time.thisTickTimes / 1000f);
if (dist > 0)
{
Status = CycleStatus.InProgress;
host.ValidateAndMove(host.X + moveDist, host.Y);
host.UpdateCount++;
dist -= moveDist;
if (dist <= 0)
{
dist = -distance;
Status = CycleStatus.Completed;
}
}
else
{
Status = CycleStatus.InProgress;
host.ValidateAndMove(host.X - moveDist, host.Y);
host.UpdateCount++;
dist += moveDist;
if (dist >= 0)
{
dist = distance;
Status = CycleStatus.Completed;
}
}
state = dist;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
ChargeState s;
if (state == null) s = new ChargeState();
else s = (ChargeState)state;
Status = CycleStatus.NotStarted;
if (host.HasConditionEffect(ConditionEffects.Paralyzed)) return;
if (s.RemainingTime <= 0)
{
if (s.Direction == Vector2.Zero)
{
var player = (Player)host.GetNearestEntity(range, null);
if (player != null && player.X != host.X && player.Y != host.Y)
{
s.Direction = new Vector2(player.X - host.X, player.Y - host.Y);
var d = s.Direction.Length();
s.Direction.Normalize();
s.RemainingTime = coolDown.Next(Random);
if (d / host.GetSpeed(speed) < s.RemainingTime)
s.RemainingTime = (int)(d / host.GetSpeed(speed) * 1000);
Status = CycleStatus.InProgress;
}
}
else
{
s.Direction = Vector2.Zero;
s.RemainingTime = coolDown.Next(Random);
Status = CycleStatus.Completed;
}
}
if (s.Direction != Vector2.Zero)
{
float dist = host.GetSpeed(speed) * (time.thisTickTimes / 1000f);
host.ValidateAndMove(host.X + s.Direction.X * dist, host.Y + s.Direction.Y * dist);
host.UpdateCount++;
Status = CycleStatus.InProgress;
}
s.RemainingTime -= time.thisTickTimes;
state = s;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
var cool = (int) state;
if (cool <= 0)
{
if (host.HasConditionEffect(ConditionEffects.Stunned)) return;
foreach (Enemy entity in host.GetNearestEntitiesByGroup(range, group).OfType<Enemy>())
{
int newHp = entity.ObjectDesc.MaxHP;
if (newHp != entity.HP)
{
int n = newHp - entity.HP;
entity.HP = newHp;
entity.UpdateCount++;
entity.Owner.BroadcastPacket(new ShowEffectPacket
{
EffectType = EffectType.Potion,
TargetId = entity.Id,
Color = new ARGB(0xffffffff)
}, null);
entity.Owner.BroadcastPacket(new ShowEffectPacket
{
EffectType = EffectType.Trail,
TargetId = host.Id,
PosA = new Position {X = entity.X, Y = entity.Y},
Color = new ARGB(0xffffffff)
}, null);
entity.Owner.BroadcastPacket(new NotificationPacket
{
ObjectId = entity.Id,
Text = "+" + n,
Color = new ARGB(0xff00ff00)
}, null);
}
}
cool = coolDown.Next(Random);
}
else
cool -= time.thisTickTimes;
state = cool;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
Status = CycleStatus.NotStarted;
if (host.HasConditionEffect(ConditionEffects.Paralyzed)) return;
var vect = (Vector2) state;
if ((vect - new Vector2(host.X, host.Y)).Length() > range)
{
vect -= new Vector2(host.X, host.Y);
vect.Normalize();
float dist = host.GetSpeed(speed)*(time.thisTickTimes/1000f);
host.ValidateAndMove(host.X + vect.X*dist, host.Y + vect.Y*dist);
host.UpdateCount++;
Status = CycleStatus.InProgress;
}
else
Status = CycleStatus.Completed;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
if (host is Pet) if ((host as Pet).PlayerOwner != null) return;
WmapTile tile = host.Owner.Map[(int)host.X, (int)host.Y].Clone();
if (tile.Region == TileRegion.None && host.Owner is PetYard)
{
Position pos = (host as Pet).SpawnPoint;
host.Move(pos.X, pos.Y);
return;
}
if (host.GetNearestEntity(1, null) == null)
{
WanderStorage storage;
if (state == null) storage = new WanderStorage();
else storage = (WanderStorage)state;
Status = CycleStatus.NotStarted;
if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed)) return;
Status = CycleStatus.InProgress;
if (storage.RemainingDistance <= 0)
{
storage.Direction = new Vector2(Random.Next(-2, 2), Random.Next(-2, 2));
storage.Direction.Normalize();
storage.RemainingDistance = coolDown.Next(Random) / 1000f;
Status = CycleStatus.Completed;
}
float dist = host.GetSpeed(speed) * (time.thisTickTimes / 1000f);
host.ValidateAndMove(host.X + storage.Direction.X * dist, host.Y + storage.Direction.Y * dist);
host.UpdateCount++;
storage.RemainingDistance -= dist;
state = storage;
}
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
Status = CycleStatus.NotStarted;
if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed)) return;
Wmap map = host.Owner.Map;
WmapTile tile = map[(int)host.X, (int)host.Y];
if (tile.Elevation != 0 && tile.Elevation < altitude)
{
Vector2 vect;
vect = new Vector2(map.Width / 2 - host.X, map.Height / 2 - host.Y);
vect.Normalize();
float dist = host.GetSpeed(speed) * (time.thisTickTimes / 1000f);
host.ValidateAndMove(host.X + vect.X * dist, host.Y + vect.Y * dist);
host.UpdateCount++;
Status = CycleStatus.InProgress;
}
else
Status = CycleStatus.Completed;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
if (instant) return;
if (!returned)
{
if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed)) return;
var spd = host.GetSpeed(speed) * (time.thisTickTimes / 1000f);
if (Math.Abs(X - host.X) > 0.5 || Math.Abs(Y - host.Y) > 0.5)
{
Vector2 vect = new Vector2(X, Y) - new Vector2(host.X, host.Y);
vect.Normalize();
vect *= spd;
host.Move(host.X + vect.X, host.Y + vect.Y);
host.UpdateCount++;
if (host.X == X && host.Y == Y && once)
{
once = true;
returned = true;
}
}
}
}
protected float GetSpeedMultiplier(Entity entity)
{
float ret = 1;
if (entity.HasConditionEffect(ConditionEffects.Speedy))
ret *= 2f;
if (entity.HasConditionEffect(ConditionEffects.Slowed))
ret *= 0.5f;
if (entity.HasConditionEffect(ConditionEffects.Paralyzed) ||
entity.HasConditionEffect(ConditionEffects.Stasis))
ret = 0;
return ret;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
SwirlState s = (SwirlState)state;
Status = CycleStatus.NotStarted;
if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed)) return;
int period = (int)(1000 * radius / host.GetSpeed(speed) * (2 * Math.PI));
if (!s.Acquired &&
s.RemainingTime <= 0 &&
targeted)
{
Entity entity = host.GetNearestEntity(acquireRange, null);
if (entity != null && entity.X != host.X && entity.Y != host.Y)
{
//find circle which pass through host and player pos
double l = entity.Dist(host);
float hx = (host.X + entity.X) / 2;
float hy = (host.Y + entity.Y) / 2;
double c = Math.Sqrt(Math.Abs(radius * radius - l * l) / 4);
s.Center = new Vector2(
(float)(hx + c * (host.Y - entity.Y) / l),
(float)(hy + c * (entity.X - host.X) / l));
s.RemainingTime = period;
s.Acquired = true;
}
else
s.Acquired = false;
}
else if (s.RemainingTime <= 0 || (s.RemainingTime - period > 200 && host.GetNearestEntity(2, null) != null))
{
if (targeted)
{
s.Acquired = false;
Entity entity = host.GetNearestEntity(acquireRange, null);
if (entity != null)
s.RemainingTime = 0;
else
s.RemainingTime = 5000;
}
else
s.RemainingTime = 5000;
}
else
s.RemainingTime -= time.thisTickTimes;
double angle;
if (host.Y == s.Center.Y && host.X == s.Center.X) //small offset
angle = Math.Atan2(host.Y - s.Center.Y + (Random.NextDouble() * 2 - 1),
host.X - s.Center.X + (Random.NextDouble() * 2 - 1));
else
angle = Math.Atan2(host.Y - s.Center.Y, host.X - s.Center.X);
double spd = host.GetSpeed(speed) * (s.Acquired ? 1 : 0.2);
double angularSpd = spd / radius;
angle += angularSpd * (time.thisTickTimes / 1000f);
double x = s.Center.X + Math.Cos(angle) * radius;
double y = s.Center.Y + Math.Sin(angle) * radius;
Vector2 vect = new Vector2((float)x, (float)y) - new Vector2(host.X, host.Y);
vect.Normalize();
vect *= (float)spd * (time.thisTickTimes / 1000f);
host.ValidateAndMove(host.X + vect.X, host.Y + vect.Y);
host.UpdateCount++;
Status = CycleStatus.InProgress;
state = s;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
if (state == null) return;
int cool = (int) state;
Status = CycleStatus.NotStarted;
if (cool <= 0)
{
if (host.HasConditionEffect(ConditionEffectIndex.Stunned)) return;
Entity player = host.GetNearestEntity(radius, null);
if (player != null || defaultAngle != null || fixedAngle != null)
{
ProjectileDesc desc = host.ObjectDesc.Projectiles[projectileIndex];
double a = fixedAngle ??
(player == null ? defaultAngle.Value : Math.Atan2(player.Y - host.Y, player.X - host.X));
a += angleOffset;
if (predictive != 0 && player != null)
a += Predict(host, player, desc)*predictive;
int dmg;
if (host is Character)
dmg = (host as Character).Random.Next(desc.MinDamage, desc.MaxDamage);
else
dmg = Random.Next(desc.MinDamage, desc.MaxDamage);
double startAngle = a - shootAngle*(count - 1)/2;
byte prjId = 0;
Position prjPos = new Position {X = host.X, Y = host.Y};
for (int i = 0; i < count; i++)
{
Projectile prj = host.CreateProjectile(
desc, host.ObjectType, dmg, time.tickTimes,
prjPos, (float) (startAngle + shootAngle*i));
host.Owner.EnterWorld(prj);
if (i == 0)
prjId = prj.ProjectileId;
}
host.Owner.BroadcastPacket(new ShootPacket
{
BulletId = prjId,
OwnerId = host.Id,
Position = prjPos,
Angle = (float)startAngle,
Damage = (short)dmg,
BulletType = (byte)desc.BulletType,
AngleInc = (float)shootAngle,
NumShots = (byte)count,
}, null);
}
cool = coolDown.Next(Random);
Status = CycleStatus.Completed;
}
else
{
cool -= time.thisTickTimes;
Status = CycleStatus.InProgress;
}
state = cool;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
FollowState s;
if (state == null) s = new FollowState();
else s = (FollowState) state;
Status = CycleStatus.NotStarted;
if (host.HasConditionEffect(ConditionEffects.Paralyzed)) return;
var player = host.GetNearestEntity(acquireRange, null);
Vector2 vect;
switch (s.State)
{
case F.DontKnowWhere:
if (player != null && s.RemainingTime <= 0)
{
s.State = F.Acquired;
if (duration > 0)
s.RemainingTime = duration;
goto case F.Acquired;
}
if (s.RemainingTime > 0)
s.RemainingTime -= time.thisTickTimes;
break;
case F.Acquired:
if (player == null)
{
s.State = F.DontKnowWhere;
s.RemainingTime = 0;
break;
}
if (s.RemainingTime <= 0 && duration > 0)
{
s.State = F.DontKnowWhere;
s.RemainingTime = coolDown.Next(Random);
Status = CycleStatus.Completed;
break;
}
if (s.RemainingTime > 0)
s.RemainingTime -= time.thisTickTimes;
vect = new Vector2(player.X - host.X, player.Y - host.Y);
if (vect.Length() > range)
{
Status = CycleStatus.InProgress;
vect.X -= Random.Next(-2, 2)/2f;
vect.Y -= Random.Next(-2, 2)/2f;
vect.Normalize();
float dist = host.GetSpeed(speed)*(time.thisTickTimes/1000f);
host.ValidateAndMove(host.X + vect.X*dist, host.Y + vect.Y*dist);
host.UpdateCount++;
}
else
{
Status = CycleStatus.Completed;
s.State = F.Resting;
s.RemainingTime = 0;
}
break;
case F.Resting:
if (player == null)
{
s.State = F.DontKnowWhere;
if (duration > 0)
s.RemainingTime = duration;
break;
}
Status = CycleStatus.Completed;
vect = new Vector2(player.X - host.X, player.Y - host.Y);
if (vect.Length() > range + 1)
{
s.State = F.Acquired;
s.RemainingTime = duration;
goto case F.Acquired;
}
break;
}
state = s;
}
public static bool ValidateAndMove(Entity entity, float x, float y)
{
if (entity.Owner == null ||
entity.HasConditionEffect(ConditionEffects.Paralyzed))
return false;
if (Validate(entity, x, y))
entity.Move(x, y);
else if (Validate(entity, entity.X, y))
entity.Move(entity.X, y);
else if (Validate(entity, x, entity.Y))
entity.Move(x, entity.Y);
else
return false;
return true;
}
protected override void TickCore(Entity host, RealmTime time, ref object state)
{
var cool = (int)state;
if (cool <= 0)
{
if (host.HasConditionEffect(ConditionEffects.Sick)) return;
if(host.GetNearestEntity(radius, null) != null)
{
var pkts = new List<Packet>();
foreach (var player in host.GetNearestEntities(radius, null).Select(p => (p as Player)).Where(player => player.Stats[0] + player.Boost[0] != player.HP))
{
player.EntityHealHp(player, host, amount, pkts);
pkts.Add(new ShowEffectPacket
{
EffectType = EffectType.Trail,
TargetId = host.Id,
PosA = new Position {X = player.X, Y = player.Y},
Color = new ARGB(0xffffffff)
});
}
host.Owner.BroadcastPackets(pkts, null);
}
cool = coolDown.Next(Random);
}
else
cool -= time.thisTickTimes;
state = cool;
}
public static bool Validate(Entity entity, float x, float y)
{
if (entity.Owner == null ||
entity.HasConditionEffect(ConditionEffects.Paralyzed))
return false;
if (x < 0 || x >= entity.Owner.Map.Width ||
y < 0 || y >= entity.Owner.Map.Height)
return false;
if (entity.ObjectDesc.Flying &&
entity.Owner.Obstacles[(int)x, (int)y] != 2)
return true;
var objId = entity.Owner.Map[(int)x, (int)y].ObjType;
if (objId != 0 &&
XmlData.ObjectDescs[objId].OccupySquare)
return false;
return entity.Owner.Obstacles[(int)x, (int)y] == 0;
}
