Example #1
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            var    s = (OrbitState)state;
            double effectiveSpeed;

            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffects.Paralyzed))
            {
                return;
            }

            if (host.HasConditionEffect(ConditionEffects.Slowed))
            {
                effectiveSpeed = s.Speed * 0.5;
            }
            else
            {
                effectiveSpeed = s.Speed;
            }

            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((float)effectiveSpeed) / s.Radius;

                if (orientation)
                {
                    angle += angularSpd * (time.ElaspedMsDelta / 1000f);
                }
                else
                {
                    angle -= angularSpd * (time.ElaspedMsDelta / 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((float)effectiveSpeed) * (time.ElaspedMsDelta / 1000f);

                host.ValidateAndMove(host.X + vect.X, host.Y + vect.Y);
                host.UpdateCount++;

                Status = CycleStatus.InProgress;
            }

            state = s;
        }
Example #2
0
        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;
        }
Example #3
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            if (state == null)
            {
                return;
            }
            int cool = (int)state;

            if (cool <= 0)
            {
                PetLevel level = null;
                if (host is Pet)
                {
                    Pet p = host as Pet;
                    level = p.GetPetLevelFromAbility(Ability.Savage, true);
                }
                else
                {
                    return;
                }
                if (level == null)
                {
                    return;
                }
                Enemy[] targets = host.GetNearestEntities(7).OfType <Enemy>().ToArray();
                foreach (Enemy e in targets)
                {
                    var vectt  = new Vector2(e.X - host.X, e.Y - host.Y);
                    var pet    = (Pet)host;
                    var player = host.GetEntity(pet.PlayerOwner.Id) as Player;
                    var vecttt = new Vector2(player.X - host.X, player.Y - host.Y);
                    var distt  = host.GetSpeed(0.5f);

                    if (vectt.Length < 6 && vecttt.Length < 6 && vectt.Length > 1)
                    {
                        distt = host.GetSpeed(1);
                        vectt.Normalize();
                        host.Move(e.X, e.Y);
                        host.UpdateCount++;
                    }
                    else if (vecttt.Length > 5)
                    {
                        distt = host.GetSpeed(0.5f);

                        host.UpdateCount++;
                    }
                }
                cool = getCooldown(host as Pet, level);
            }
            else
            {
                cool -= time.thisTickTimes;
            }

            state = cool;
        }
Example #4
0
        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 = 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);
                        float 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;
        }
Example #5
0
        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;
            //}

            OrbitState s = (OrbitState)state;

            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffectIndex.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;
        }
Example #6
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            if (returned)
            {
                return;
            }
            if (host.HasConditionEffect(ConditionEffects.Paralyzed))
            {
                return;
            }
            var spd = host.GetSpeed(speed) * (time.thisTickTimes / 1000f);

            var 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;
                var 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)
            {
                return;
            }
            once     = true;
            returned = true;
        }
        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);

                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;
                }
            }
        }
Example #8
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            if (!(host is Enemy))
            {
                return;
            }

            if (host.HasConditionEffect(ConditionEffects.Paralyzed))
            {
                return;
            }

            var spawn = (host as Enemy).SpawnPoint;
            var vect  = new Vector2(spawn.X, spawn.Y) - new Vector2(host.X, host.Y);

            if (vect.Length() > _returnWithinRadius)
            {
                Status = CycleStatus.InProgress;
                vect.Normalize();
                vect *= host.GetSpeed(_speed) * (time.ElapsedMsDelta / 1000f);
                host.ValidateAndMove(host.X + vect.X, host.Y + vect.Y);
            }
            else
            {
                Status = CycleStatus.Completed;
            }
        }
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed))
            {
                return;
            }

            Vector2 vect = (Vector2)state;
            var     l    = (vect - new Vector2(host.X, host.Y)).Length;

            if (l > range)
            {
                vect -= new Vector2(host.X, host.Y);
                vect.Normalize();
                float dist = host.GetSpeed(speed - (speed * 2.5f / (time.TickCount / (time.TotalElapsedMs / 1000f))), time);
                host.ValidateAndMove(host.X + vect.X * dist, host.Y + vect.Y * dist);
                host.UpdateCount++;

                Status = CycleStatus.InProgress;
            }
            else
            {
                Status = CycleStatus.Completed;
            }
        }
Example #10
0
        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;
        }
        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;
                }
            }
        }
Example #12
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            if (instant)
            {
                return;
            }
            if (!returned)
            {
                var spd = host.GetSpeed(speed) * (time.ElapsedMsDelta / 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);

                    if (host.X == X && host.Y == Y && once)
                    {
                        once     = true;
                        returned = true;
                    }
                }
            }
        }
Example #13
0
        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 override void TickCore(Entity host, RealmTime time, ref object state)
        {
            if (host is Pet)
            {
                if ((host as Pet).PlayerOwner != null)
                {
                    return;
                }
            }

            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed))
            {
                return;
            }

            Vector2 vect = (Vector2)state;
            var     l    = (vect - new Vector2(host.X, host.Y)).Length;

            if (l > 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;
            }
        }
Example #15
0
        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((host as Pet)?.PlayerOwner != null) return;
            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffects.Paralyzed))
            {
                return;
            }

            if (!(state is Vector2))
            {
                state  = new Vector2(host.X, host.Y);
                Status = CycleStatus.Completed;
                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.ElaspedMsDelta / 1000f);
                host.ValidateAndMove(host.X + vect.X * dist, host.Y + vect.Y * dist);

                Status = CycleStatus.InProgress;
            }
            else
            {
                Status = CycleStatus.Completed;
            }
        }
Example #17
0
        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;
        }
Example #18
0
        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 - (speed * 2.5f / (time.TickCount / (time.TotalElapsedMs / 1000f))), time);
                host.ValidateAndMove(host.X + vect.X * (dist - (dist * 2.5f / (time.TickCount / (time.TotalElapsedMs / 1000f)))), host.Y + vect.Y * (dist - (dist * 2.5f / (time.TickCount / (time.TotalElapsedMs / 1000f)))));
                host.UpdateCount++;

                Status = CycleStatus.InProgress;
            }
            else
            {
                Status = CycleStatus.Completed;
            }
        }
Example #19
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffects.Paralyzed))
            {
                return;
            }

            var map  = host.Owner.Map;
            var 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;
            }
        }
Example #20
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            if (instant)
            {
                return;
            }
            if (returned)
            {
                return;
            }
            if (host.HasConditionEffect(ConditionEffects.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))
            {
                return;
            }
            var 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)
            {
                return;
            }
            once     = true;
            returned = true;
        }
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            float dist;

            if (state == null)
            {
                dist = distance;
            }
            else
            {
                dist = (float)state;
            }
            double effectiveSpeed = speed;

            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffects.Paralyzed))
            {
                return;
            }

            if (host.HasConditionEffect(ConditionEffects.Slowed))
            {
                effectiveSpeed = speed * 0.5;
            }
            else
            {
                effectiveSpeed = speed;
            }

            float moveDist = host.GetSpeed((float)effectiveSpeed) * (time.ElaspedMsDelta / 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;
        }
Example #22
0
        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(ConditionEffectIndex.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);

            if (avoidGround)
            {
                EmbeddedData data = host.Manager.GameData;
                float        x    = host.X + storage.Direction.X * dist;
                float        y    = host.Y + storage.Direction.Y * dist;
                WmapTile     tile = host.Owner.Map[(int)x, (int)y];
                if (tile.TileId == data.IdToTileType[ground])
                {
                    host.UpdateCount++;
                    storage.RemainingDistance -= dist;
                    state = storage;
                    return;
                }
            }
            host.ValidateAndMove(host.X + storage.Direction.X * dist, host.Y + storage.Direction.Y * dist);
            host.UpdateCount++;

            storage.RemainingDistance -= dist;

            state = storage;

            //if (debug)
            //{
            //    double TPS = time.TickCount / (time.TotalElapsedMs / 1000.0);
            //    log.Warn($"[{typeof(Wander).Name}] Speed: {speed} | Current Speed: {dist:n2} | TC: {time.TickCount:n2} | TEM: {(time.TotalElapsedMs / 1000.0):n2} | TPS: {TPS:n2}");
            //}
        }
Example #23
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            OrbitState s = (OrbitState)state;

            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed))
            {
                return;
            }

            Entity entity = host.GetNearestEntity(acquireRange, target);

            if (entity != null)
            {
                double angle;
                if (host.Y == entity.Y && host.X == entity.X)
                {
                    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, time) / s.Radius;

                angle += angularSpd;

                double x = entity.X + (_ == 0 ? Math.Cos(angle) * radius : Math.Sin(angle) * radius);
                double y = entity.Y + (_ == 0 ? Math.Sin(angle) * radius : Math.Cos(angle) * radius);

                Vector2 vect = new Vector2((float)x, (float)y) - new Vector2(host.X, host.Y);

                vect.Normalize();
                vect *= host.GetSpeed(s.Speed, time);

                host.ValidateAndMove(host.X + vect.X, host.Y + vect.Y);
                host.UpdateCount++;

                Status = CycleStatus.InProgress;
            }

            state = s;
        }
Example #24
0
        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;
        }
Example #25
0
        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;
        }
Example #26
0
        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;
            }
        }
Example #27
0
    public AnimationControl(Entity entity)
    {
        mEntity    = entity;
        gameObject = mEntity.GetGameObject();

        entityAnimator = gameObject.GetComponent <Animator>();
        SetSpeed(mEntity.GetSpeed());

        InitAnimationState();
    }
Example #28
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            double effectiveSpeed;
            int    cooldown;

            if (state == null)
            {
                cooldown = 1000;
            }
            else
            {
                cooldown = (int)state;
            }

            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffects.Paralyzed))
            {
                return;
            }

            if (host.HasConditionEffect(ConditionEffects.Slowed))
            {
                effectiveSpeed = speed * 0.5;
            }
            else
            {
                effectiveSpeed = speed;
            }

            var 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((float)effectiveSpeed) * (time.ElaspedMsDelta / 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.ElaspedMsDelta;
                }
            }

            state = cooldown;
        }
Example #29
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            OrbitState s = (OrbitState)state;

            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffects.Paralyzed))
            {
                return;
            }

            var entity = host.AttackTarget ?? 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);
                }
                var angularSpd = s.Direction * host.GetSpeed(s.Speed) / s.Radius;
                angle += angularSpd * (time.ElapsedMsDelta / 1000f);

                double  x    = entity.X + Math.Cos(angle) * s.Radius;
                double  y    = entity.Y + Math.Sin(angle) * s.Radius;
                Vector2 vect = new Vector2((float)x, (float)y) - new Vector2(host.X, host.Y);
                vect.Normalize();
                vect *= host.GetSpeed(s.Speed) * (time.ElapsedMsDelta / 1000f);

                host.ValidateAndMove(host.X + vect.X, host.Y + vect.Y);

                Status = CycleStatus.InProgress;
            }

            state = s;
        }
Example #30
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            OrbitState s = (OrbitState)state;

            if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed))
            {
                return;
            }

            Player entity = host.GetPlayerOwner();

            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++;
            }
            state = s;
        }
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            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 - (speed * 2.5f / (time.TickCount / (time.TotalElapsedMs / 1000f))), time);

            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;
        }
Example #32
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            double effectiveSpeed;
            var    storage = (BuzzStorage)state;

            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffects.Paralyzed))
            {
                return;
            }

            if (host.HasConditionEffect(ConditionEffects.Slowed))
            {
                effectiveSpeed = speed * 0.5;
            }
            else
            {
                effectiveSpeed = speed;
            }

            if (storage.RemainingTime > 0)
            {
                storage.RemainingTime -= time.ElaspedMsDelta;
                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((float)effectiveSpeed) * (time.ElaspedMsDelta / 1000f);
                host.ValidateAndMove(host.X + storage.Direction.X * dist, host.Y + storage.Direction.Y * dist);
                host.UpdateCount++;

                storage.RemainingDistance -= dist;
            }

            state = storage;
        }
Example #33
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            Status = CycleStatus.NotStarted;
            if (host.HasConditionEffect(ConditionEffects.Paralyzed))
            {
                return;
            }

            Status = CycleStatus.InProgress;
            var vect = new Vector2((float)Math.Cos(_direction), (float)Math.Sin(_direction));
            var dist = host.GetSpeed(_speed) * time.ElaspedMsDelta / 1000f;

            host.ValidateAndMove(host.X + vect.X * dist, host.Y + vect.Y * dist);

            // Varanus, is this a proper CycleBehavior? There is no CycleStatus.Completed...
        }
Example #34
0
        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;
            }

            Entity e = entity != null?
                       host.GetNearestEntityByName(distance, entity) :
                           host.GetNearestEntity(distance, null);

            if (e != null)
            {
                Vector2 vect;
                vect = new Vector2(e.X - host.X, e.Y - host.Y);
                vect.Normalize();
                float dist = host.GetSpeed(speed) * (time.ElapsedMsDelta / 1000f);
                host.ValidateAndMove(host.X + (-vect.X) * dist, host.Y + (-vect.Y) * dist);

                if (cooldown <= 0)
                {
                    Status   = CycleStatus.Completed;
                    cooldown = 1000;
                }
                else
                {
                    Status    = CycleStatus.InProgress;
                    cooldown -= time.ElapsedMsDelta;
                }
            }

            state = cooldown;
        }
        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;
            //}

            var storage = (BuzzStorage)state;

            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffectIndex.Paralyzed))
            {
                return;
            }

            if (storage.RemainingTime > 0)
            {
                storage.RemainingTime -= time.ElaspedMsDelta;
                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.ElaspedMsDelta / 1000f);
                host.ValidateAndMove(host.X + storage.Direction.X * dist, host.Y + storage.Direction.Y * dist);
                host.UpdateCount++;

                storage.RemainingDistance -= dist;
            }

            state = storage;
        }
Example #36
0
        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(ConditionEffectIndex.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;
            }

            //var en = host.GetNearestEntity(20, null);
            //var player = en as Player;

            //if(en == null)
            //{
            //    return;
            //}

            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 (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;
            }
        }
Example #38
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffects.Paralyzed)) return;

            var map = host.Owner.Map;
            var 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)
        {
            float dist;
            if (state == null) dist = distance;
            else dist = (float)state;

            Status = CycleStatus.NotStarted;

            if (host.HasConditionEffect(ConditionEffects.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)
        {
            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;
                    }
                }
            }
        }
Example #41
0
        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(ConditionEffects.Paralyzed)) return;

            var 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;
        }
Example #42
0
        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 = (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;
                    }
                    else if (s.RemainingTime > 0)
                        s.RemainingTime -= time.thisTickTimes;
                    break;
                case F.Acquired:
                    if (player == null)
                    {
                        s.State = F.DontKnowWhere;
                        s.RemainingTime = 0;
                        break;
                    }
                    else 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;
        }
        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)
        {
            FollowState s;
            if (state == null) s = new FollowState();
            else s = (FollowState)state;

            Status = CycleStatus.NotStarted;

            Player player = host.GetPlayerOwner();
            if (player.Owner == null)
            {
                host.Owner.LeaveWorld(host);
                return;
            }

            Vector2 vect;
            switch (s.State)
            {
                case F.DontKnowWhere:
                    if (s.RemainingTime > 0)
                        s.RemainingTime -= time.thisTickTimes;
                    else
                        s.State = F.Acquired;
                    break;

                case F.Acquired:
                    if (player == null)
                    {
                        s.State = F.DontKnowWhere;
                        s.RemainingTime = 0;
                        break;
                    }
                    if (s.RemainingTime > 0)
                        s.RemainingTime -= time.thisTickTimes;

                    vect = new Vector2(player.X - host.X, player.Y - host.Y);
                    if (vect.Length > 20)
                    {
                        host.Move(player.X, player.Y);
                        host.UpdateCount++;
                    }
                    else if (vect.Length > 1)
                    {
                        float dist = host.GetSpeed(1.2f) * (time.thisTickTimes / 1000f);
                        if (vect.Length > 2)
                            dist = host.GetSpeed(1.2f + ((float)player.Stats[4] / 100)) * (time.thisTickTimes / 1000f);
                        else if (vect.Length > 3.5)
                            dist = host.GetSpeed(1.2f + ((float)player.Stats[4] + (float)player.Boost[4] / 100)) * (time.thisTickTimes / 1000f);
                        else if (vect.Length > 5)
                            dist = host.GetSpeed(1.3f + ((float)player.Stats[4] + (float)player.Boost[4] / 100)) * (time.thisTickTimes / 1000f);
                        else if (vect.Length > 6)
                            dist = host.GetSpeed(1.4f + ((float)player.Stats[4] + (float)player.Boost[4] / 100)) * (time.thisTickTimes / 1000f);
                        else if (vect.Length > 7)
                            dist = host.GetSpeed(1.5f + ((float)player.Stats[4] + (float)player.Boost[4] / 100)) * (time.thisTickTimes / 1000f);

                        Status = CycleStatus.InProgress;
                        vect.X -= Random.Next(-2, 2) / 2f;
                        vect.Y -= Random.Next(-2, 2) / 2f;
                        vect.Normalize();
                        host.ValidateAndMove(host.X + vect.X * dist, host.Y + vect.Y * dist);
                        host.UpdateCount++;
                    }

                    break;
            }

            state = s;
        }