protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            int cool = (int)state;
            if (cool <= 0)
            {
                var entity = host.GetPlayerOwner();

                if (!entity.HasConditionEffect(ConditionEffectIndex.Sick))
                {
                    try
                    {
                        var distance = Vector2.Distance(new Vector2(host.X, host.Y),
                            new Vector2(entity.X, entity.Y));

                        if (distance < 10)
                        {
                            var hp = entity.HP;
                            var maxHp = entity.Stats[0] + entity.Boost[0];
                            hp = Math.Min(hp + 25, maxHp);

                            if (hp != entity.HP)
                            {
                                var n = hp - entity.HP;
                                entity.HP = hp;
                                entity.UpdateCount++;
                                entity.Owner.BroadcastPacket(new ShowEffectPacket
                                {
                                    EffectType = EffectType.Potion,
                                    TargetId = entity.Id,
                                    Color = new ARGB(0xFFFFFF)
                                }, null);
                                entity.Owner.BroadcastPacket(new ShowEffectPacket
                                {
                                    EffectType = EffectType.Trail,
                                    TargetId = host.Id,
                                    PosA = new Position { X = entity.X, Y = entity.Y },
                                    Color = new ARGB(0xFFFFFF)
                                }, null);
                                entity.Owner.BroadcastPacket(new NotificationPacket
                                {
                                    ObjectId = entity.Id,
                                    Text = "+" + n,
                                    Color = new ARGB(0xff00ff00)
                                }, null);
                            }
                        }
                    }
                    catch
                    {
                    }
                }
                cool = 500;
            }
            else
                cool -= time.thisTickTimes;

            state = cool;
        }
Beispiel #2
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            Player player = host.GetPlayerOwner();

            if (MathsUtils.GenerateProb(50))
            {
                host.Owner.LeaveWorld(host);
            }
        }
Beispiel #3
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            int cool = (int)state;

            if (cool <= 0)
            {
                var entities = host.GetNearestEntities(6);

                Enemy en = null;
                foreach (Entity e in entities)
                {
                    if (e is Enemy)
                    {
                        en = e as Enemy;
                        break;
                    }
                }

                if (en != null & en.ObjectDesc.Enemy)
                {
                    en.Owner.BroadcastPacket(new ShowEffect()
                    {
                        EffectType     = EffectType.AreaBlast,
                        Color          = new ARGB(0x3E3A78),
                        TargetObjectId = en.Id,
                        Pos1           = new Position {
                            X = 1,
                        }
                    }, null);
                    en.Owner.BroadcastPacket(new ShowEffect()
                    {
                        EffectType     = EffectType.Trail,
                        TargetObjectId = host.Id,
                        Pos1           = new Position {
                            X = en.X, Y = en.Y
                        },
                        Color = new ARGB(0x3E3A78)
                    }, null);
                    en.Damage(host.GetPlayerOwner(), time, _damage, true);
                    en.ApplyConditionEffect(new ConditionEffect
                    {
                        Effect     = _effect,
                        DurationMS = _duration
                    });
                }
                cool = 600;
            }
            else
            {
                cool -= time.ElapsedMsDelta;
            }

            state = cool;
        }
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            int cool = (int)state;

            if (cool <= 0)
            {
                var entities = host.GetNearestEntities(6);

                Enemy en = null;
                foreach (Entity e in entities)
                {
                    if (e is Enemy)
                    {
                        en = e as Enemy;
                        break;
                    }
                }

                if (en != null & en.ObjectDesc.Enemy)
                {
                    en.Owner.BroadcastPacket(new ShowEffectPacket
                    {
                        EffectType = EffectType.AreaBlast,
                        Color      = new ARGB(0x3E3A78),
                        TargetId   = en.Id,
                        PosA       = new Position {
                            X = 1,
                        }
                    }, null);
                    en.Owner.BroadcastPacket(new ShowEffectPacket
                    {
                        EffectType = EffectType.Trail,
                        TargetId   = host.Id,
                        PosA       = new Position {
                            X = en.X, Y = en.Y
                        },
                        Color = new ARGB(0x3E3A78)
                    }, null);
                    en.Damage(host.GetPlayerOwner(), time, 35, false, new ConditionEffect[] { });
                }
                cool = 300;
            }
            else
            {
                cool -= time.thisTickTimes;
            }

            state = cool;
        }
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            int cool = (int)state;

            if (cool <= 0)
            {
                Enemy   en      = null;
                Enemy[] targets = host.GetNearestEntities(7).OfType <Enemy>().ToArray();
                foreach (Enemy e in targets)
                {
                    if (e is Enemy)
                    {
                        en = e as Enemy;
                        break;
                    }
                }

                if (en != null & en.ObjectDesc.Enemy)
                {
                    en.Owner.BroadcastPacket(new ShowEffectPacket
                    {
                        EffectType = EffectType.AreaBlast,
                        Color      = new ARGB(color),
                        TargetId   = en.Id,
                        PosA       = new Position {
                            X = 1,
                        }
                    }, null);
                    en.Owner.BroadcastPacket(new ShowEffectPacket
                    {
                        EffectType = EffectType.Trail,
                        TargetId   = host.Id,
                        PosA       = new Position {
                            X = en.X, Y = en.Y
                        },
                        Color = new ARGB(color)
                    }, null);
                    en.Damage(host.GetPlayerOwner(), time, amount, trueDamage, new ConditionEffect[] { });
                }
                cool = 200;
            }
            else
            {
                cool -= time.thisTickTimes;
            }

            state = cool;
        }
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            int cool = (int)state;
            if (cool <= 0)
            {
                var entities = host.GetNearestEntities(6);

                Enemy en = null;
                foreach (Entity e in entities)
                    if (e is Enemy)
                    {
                        en = e as Enemy;
                        break;
                    }

                if (en != null & en.ObjectDesc.Enemy)
                {
                    en.Owner.BroadcastPacket(new ShowEffectPacket
                    {
                        EffectType = EffectType.AreaBlast,
                        Color = new ARGB(0x3E3A78),
                        TargetId = en.Id,
                        PosA = new Position { X = 1, }
                    }, null);
                    en.Owner.BroadcastPacket(new ShowEffectPacket
                    {
                        EffectType = EffectType.Trail,
                        TargetId = host.Id,
                        PosA = new Position { X = en.X, Y = en.Y },
                        Color = new ARGB(0x3E3A78)
                    }, null);
                    en.Damage(host.GetPlayerOwner(), time, 35, false, new ConditionEffect[] { });
                }
                cool = 300;
            }
            else
                cool -= time.thisTickTimes;

            state = cool;
        }
        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;
        }
Beispiel #8
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            int cool = (int)state;

            if (cool <= 0)
            {
                var entity = host.GetPlayerOwner();

                if (!entity.HasConditionEffect(ConditionEffectIndex.Sick))
                {
                    try
                    {
                        var distance = Vector2.Distance(new Vector2(host.X, host.Y),
                                                        new Vector2(entity.X, entity.Y));

                        if (distance < 10)
                        {
                            var hp    = entity.HP;
                            var maxHp = entity.Stats[0] + entity.Boost[0];
                            hp = Math.Min(hp + 25, maxHp);

                            if (hp != entity.HP)
                            {
                                var n = hp - entity.HP;
                                entity.HP = hp;
                                entity.UpdateCount++;
                                entity.Owner.BroadcastPacket(new ShowEffectPacket
                                {
                                    EffectType = EffectType.Potion,
                                    TargetId   = entity.Id,
                                    Color      = new ARGB(0xFFFFFF)
                                }, null);
                                entity.Owner.BroadcastPacket(new ShowEffectPacket
                                {
                                    EffectType = EffectType.Trail,
                                    TargetId   = host.Id,
                                    PosA       = new Position {
                                        X = entity.X, Y = entity.Y
                                    },
                                    Color = new ARGB(0xFFFFFF)
                                }, null);
                                entity.Owner.BroadcastPacket(new NotificationPacket
                                {
                                    ObjectId = entity.Id,
                                    Text     = "+" + n,
                                    Color    = new ARGB(0xff00ff00)
                                }, null);
                            }
                        }
                    }
                    catch
                    {
                    }
                }
                cool = 500;
            }
            else
            {
                cool -= time.thisTickTimes;
            }

            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;

            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.ElapsedMsDelta;
                }
                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.ElapsedMsDelta;
                }

                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.EntitySpeed(player.Stats[4] / 10, time);

                    if (vect.Length > 2 && vect.Length <= 3.5)
                    {
                        dist *= 1.75f;
                    }
                    else if (vect.Length > 3.5 && vect.Length <= 5)
                    {
                        dist *= 2f;
                    }
                    else if (vect.Length > 5 && vect.Length <= 6)
                    {
                        dist *= 2.25f;
                    }
                    else if (vect.Length > 6 && vect.Length <= 7)
                    {
                        dist *= 2.75f;
                    }
                    else if (vect.Length > 7 && vect.Length <= 10)
                    {
                        dist *= 3f;
                    }
                    else if (vect.Length > 10 && vect.Length <= 20)
                    {
                        dist *= 3.25f;
                    }

                    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;
        }
Beispiel #10
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;

            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;
        }
        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;
        }
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            var player    = host.GetPlayerOwner();
            var pet       = player.Pet;
            var hatchling = player.HatchlingPet;

            if (hatchling)
            {
                return;
            }

            if (player.Owner == null || pet == null || host == null)
            {
                pet.Owner.LeaveWorld(host);
                return;
            }

            if (host.Owner.SafePlace || !player.EnablePetAttack)
            {
                return;
            }

            var cool = (int?)state ?? -1;

            Status = CycleStatus.NotStarted;

            if (cool <= 0)
            {
                if (player.HasConditionEffect(ConditionEffectIndex.Sick) || player.HasConditionEffect(ConditionEffectIndex.PetDisable))
                {
                    return;
                }

                var stars = player.Stars;

                if (pet.GetNearestEntity(12, false, enemy => enemy is Enemy && pet.Dist(enemy) <= 12) is Enemy target && target.ObjectDesc.Enemy)
                {
                    var desc = pet.ObjectDesc.Projectiles[projectileIndex];
                    var a    = fixedAngle ?? (target == null ? defaultAngle.Value : Math.Atan2(target.Y - pet.Y, target.X - pet.X));
                    a += angleOffset;

                    var variance = 0;

                    if (stars == 70)
                    {
                        variance = 7000;
                    }
                    else
                    {
                        variance = player.Stars * 100;
                    }

                    cool = special ? cool = coolDown.Next(Random) : (7750 - variance); // max 750ms cooldown if not special

                    var rnd     = new Random();
                    var min     = 0;
                    var max     = 100;
                    var success = stars + 30;
                    var rng     = rnd.Next(min, max);

                    if (rng > success)
                    {
                        var _outgoing     = new List <Message>();
                        var _effect       = new SHOWEFFECT();
                        var _position     = new Position();
                        var _notification = new NOTIFICATION();

                        _position.X = .25f;
                        _position.Y = 2 / _position.X;

                        _effect.Color      = new ARGB(0xFF0000);
                        _effect.EffectType = EffectType.Flash;
                        _effect.PosA       = _position;
                        _effect.TargetId   = pet.Id;

                        _outgoing.Add(_effect);

                        _notification.Color    = new ARGB(0xFFFFFF);
                        _notification.ObjectId = pet.Id;
                        _notification.Text     = "{\"key\":\"blank\",\"tokens\":{\"data\":\"Miss!\"}}";

                        _outgoing.Add(_notification);

                        pet.Owner.BroadcastMessage(_outgoing, null);

                        state = cool;
                        return;
                    }

                    var dmg        = rnd.Next(desc.MinDamage, desc.MaxDamage);
                    var startAngle = a - shootAngle * (count - 1) / 2;
                    var prjPos     = new Position()
                    {
                        X = pet.X, Y = pet.Y
                    };
                    var prj = player.CreateProjectile(desc, pet.ObjectType, dmg, time.TotalElapsedMs, prjPos, (float)startAngle);

                    player.Owner.Projectiles.TryAdd(prj, null);

                    player.Owner.EnterWorld(prj);

                    var _outgoingMessages = new List <Message>();
                    var _shoot            = new ENEMYSHOOT
                    {
                        BulletId   = 0,
                        OwnerId    = pet.Id,
                        Position   = prjPos,
                        Angle      = prj.Angle,
                        Damage     = 0,
                        BulletType = 0,
                        AngleInc   = (float)shootAngle,
                        NumShots   = 0
                    };
                    var _shoot2 = new SERVERPLAYERSHOOT
                    {
                        BulletId      = prj.ProjectileId,
                        OwnerId       = player.Id,
                        ContainerType = pet.ObjectType,
                        StartingPos   = prj.BeginPos,
                        Angle         = prj.Angle,
                        Damage        = (short)prj.Damage
                    };

                    _outgoingMessages.Add(_shoot); // visual, display no animation only activate pet set alt index
                    _outgoingMessages.Add(_shoot2);

                    player.Owner.BroadcastMessage(_outgoingMessages, null);

                    player.FameCounter.Shoot(prj);

                    Status = CycleStatus.Completed;
                }
                else
                {
                    return;
                }
            }
Beispiel #13
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;

            Player player = host.GetPlayerOwner();

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

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

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

                var vect = new Vector2(player.X - host.X, player.Y - host.Y);
                if (vect.Length() > 20)
                {
                    host.Move(player.X, player.Y);
                }
                else if (vect.Length() > 1)
                {
                    var dist = host.GetSpeed(0.5f) * (time.ElapsedMsDelta / 1000f);
                    if (vect.Length() > 2)
                    {
                        dist = host.GetSpeed(0.7f + ((float)player.Stats[4] / 100)) * (time.ElapsedMsDelta / 1000f);
                    }

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

                break;
            }

            state = s;
        }
Beispiel #14
0
        protected override void TickCore(Entity host, RealmTime time, ref object state)
        {
            Player player    = host.GetPlayerOwner();
            Entity pet       = player.Pet;
            bool   hatchling = player.HatchlingPet;

            if (hatchling)
            {
                return;
            }

            if (player.Owner == null || pet == null || host == null)
            {
                pet.Owner.LeaveWorld(host);
                return;
            }

            int cool = (int)state;

            if (cool <= 0)
            {
                if (!player.HasConditionEffect(ConditionEffectIndex.Sick) && !player.HasConditionEffect(ConditionEffectIndex.PetDisable))
                {
                    float distance = Vector2.Distance(new Vector2(pet.X, pet.Y), new Vector2(player.X, player.Y));

                    if (distance < 20)
                    {
                        int maxmp      = player.Stats[1] + player.Boost[1];
                        int stars      = player.Stars;
                        int mpVariance = GetMP(pet.ObjectDesc.MPTier, stars);

                        cool = 8000 - (player.Stars * 100);

                        int newmp = Math.Min(maxmp, player.MP + mpVariance);

                        if (newmp != player.MP)
                        {
                            if (player.HasConditionEffect(ConditionEffectIndex.Sick) || player.HasConditionEffect(ConditionEffectIndex.PetDisable))
                            {
                                player.Owner.BroadcastMessage(new SHOWEFFECT
                                {
                                    EffectType = EffectType.Line,
                                    TargetId   = host.Id,
                                    PosA       = new Position {
                                        X = player.X, Y = player.Y
                                    },
                                    Color = new ARGB(0xffffffff)
                                }, null);
                                player.Owner.BroadcastMessage(new NOTIFICATION
                                {
                                    ObjectId = player.Id,
                                    Text     = "{\"key\":\"blank\",\"tokens\":{\"data\":\"No Effect\"}}",
                                    Color    = new ARGB(0xFF0000)
                                }, null);
                                state = cool;
                                return;
                            }

                            int n = newmp - player.MP;
                            player.MP = newmp;
                            player.UpdateCount++;
                            player.Owner.BroadcastMessage(new SHOWEFFECT
                            {
                                EffectType = EffectType.Heal,
                                TargetId   = player.Id,
                                Color      = new ARGB(0x6084e0)
                            }, null);
                            player.Owner.BroadcastMessage(new SHOWEFFECT
                            {
                                EffectType = EffectType.Line,
                                TargetId   = host.Id,
                                PosA       = new Position {
                                    X = player.X, Y = player.Y
                                },
                                Color = new ARGB(0xffffffff)
                            }, null);
                            player.Owner.BroadcastMessage(new NOTIFICATION
                            {
                                ObjectId = player.Id,
                                Text     = "{\"key\":\"blank\",\"tokens\":{\"data\":\"+" + n + "\"}}",
                                Color    = new ARGB(0x6084e0)
                            }, null);
                        }
                    }
                }
            }
            else
            {
                //Log.Write(nameof(PetMPHealing), $"{cool} ms", ConsoleColor.DarkCyan);
                cool -= time.ElapsedMsDelta;
            }

            state = cool;
        }
Beispiel #15
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;

            Player player                = host.GetPlayerOwner();
            Entity pet                   = player.Pet;
            bool   hatchling             = player.HatchlingPet;
            bool   hatchlingNotification = player.HatchlingNotification;

            if (hatchling && !hatchlingNotification)
            {
                NOTIFICATION _notification = new NOTIFICATION
                {
                    Color    = new ARGB(0xFFFFFF),
                    ObjectId = host.Id,
                    Text     = "{\"key\":\"blank\",\"tokens\":{\"data\":\"New Pet!\"}}"
                };

                host.Owner.BroadcastMessage(_notification, null);

                player.HatchlingNotification = true;

                player.SendInfo("Please, leave vault to activate your pet (HP healing, MP healing, follow and shoot behaviors).");
                return;
            }

            if (player.Owner == null || pet == null || host == null)
            {
                pet.Owner.LeaveWorld(host);
                return;
            }

            Vector2 vect = new Vector2(player.X - pet.X, player.Y - pet.Y);

            switch (s.State)
            {
            case F.DontKnowWhere:
                if (s.RemainingTime > 0)
                {
                    s.RemainingTime -= time.ElapsedMsDelta;
                }
                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.ElapsedMsDelta;
                }

                vect = new Vector2(player.X - pet.X, player.Y - pet.Y);

                if (vect.Length > 1 && vect.Length <= 20)
                {
                    float dist = host.EntitySpeed(player.Stats[4] / 10, time);

                    if (vect.Length > 2 && vect.Length <= 3.5)
                    {
                        dist *= 1.75f;
                    }
                    else if (vect.Length > 3.5 && vect.Length <= 5)
                    {
                        dist *= 2f;
                    }
                    else if (vect.Length > 5 && vect.Length <= 6)
                    {
                        dist *= 2.25f;
                    }
                    else if (vect.Length > 6 && vect.Length <= 7)
                    {
                        dist *= 2.75f;
                    }
                    else if (vect.Length > 7 && vect.Length <= 10)
                    {
                        dist *= 3f;
                    }
                    else if (vect.Length > 10 && vect.Length <= 20)
                    {
                        dist *= 3.25f;
                    }

                    Status = CycleStatus.InProgress;
                    vect.Normalize();
                    pet.ValidateAndMove(pet.X + vect.X * dist, pet.Y + vect.Y * dist);
                    pet.UpdateCount++;
                }

                break;
            }

            state = s;
        }
Beispiel #16
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;
            }

            if (playerCircle == 1)
            {
                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++;

                    Status = CycleStatus.InProgress;
                }
            }



            else
            {
                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;
        }