Пример #1
0
        public void FireBreath(Mobile from)
        {
            if (this == null)
            {
                return;
            }
            if (this.Deleted)
            {
                return;
            }
            if (from == null)
            {
                return;
            }

            Effects.PlaySound(Location, Map, 0x227);

            Dictionary <Point3D, double> m_BreathTiles = new Dictionary <Point3D, double>();

            double tileDelay = .10;
            int    distance  = 8;

            m_BreathTiles.Add(Location, 0);

            Direction breathDirection = Direction.South;

            Point3D previousPoint = Location;
            Point3D nextPoint;

            for (int a = 0; a < distance; a++)
            {
                nextPoint = SpecialAbilities.GetPointByDirection(previousPoint, breathDirection);

                bool canFit = SpellHelper.AdjustField(ref nextPoint, Map, 12, false);

                if (Map != null && canFit && Map.InLOS(Location, nextPoint))
                {
                    if (!m_BreathTiles.ContainsKey(nextPoint))
                    {
                        m_BreathTiles.Add(nextPoint, a * tileDelay);
                    }
                }

                List <Point3D> perpendicularPoints = SpecialAbilities.GetPerpendicularPoints(previousPoint, nextPoint, a + 1);

                foreach (Point3D point in perpendicularPoints)
                {
                    Point3D ppoint = new Point3D(point.X, point.Y, point.Z);

                    canFit = SpellHelper.AdjustField(ref ppoint, Map, 12, false);

                    if (Map != null && canFit && Map.InLOS(Location, ppoint))
                    {
                        if (!m_BreathTiles.ContainsKey(ppoint))
                        {
                            m_BreathTiles.Add(ppoint, a * tileDelay);
                        }
                    }
                }

                previousPoint = nextPoint;

                Timer.DelayCall(TimeSpan.FromSeconds(a * tileDelay), delegate
                {
                    if (this == null)
                    {
                        return;
                    }
                    if (this.Deleted)
                    {
                        return;
                    }

                    Effects.PlaySound(nextPoint, Map, 0x208);
                });
            }

            foreach (KeyValuePair <Point3D, double> pair in m_BreathTiles)
            {
                Timer.DelayCall(TimeSpan.FromSeconds(pair.Value), delegate
                {
                    if (this == null)
                    {
                        return;
                    }
                    if (this.Deleted)
                    {
                        return;
                    }

                    Point3D breathLocation = pair.Key;

                    Effects.SendLocationParticles(EffectItem.Create(breathLocation, Map, TimeSpan.FromSeconds(1.0)), 0x3709, 10, 30, 0, 0, 5052, 0);

                    Timer.DelayCall(TimeSpan.FromSeconds(.5), delegate
                    {
                        if (this == null)
                        {
                            return;
                        }
                        if (this.Deleted)
                        {
                            return;
                        }

                        //Fire Field Resolution
                        if (Utility.RandomDouble() < .25)
                        {
                            int duration = 5;

                            Effects.PlaySound(breathLocation, Map, 0x208);
                            Effects.SendLocationParticles(EffectItem.Create(breathLocation, Map, TimeSpan.FromSeconds(duration)), 0x3996, 10, 100, 5029);

                            for (int a = 1; a < (duration + 1); a++)
                            {
                                Timer.DelayCall(TimeSpan.FromSeconds(a), delegate
                                {
                                    Effects.PlaySound(breathLocation, Map, 0x208);
                                });
                            }
                        }
                    });
                });
            }

            if (m_BreathTiles.Count > 0)
            {
                m_NextUseAllowed = DateTime.UtcNow + UsageCooldown;
            }
        }
Пример #2
0
            protected override void OnTick()
            {
                if (m_ForebiddenLoreStatue == null)
                {
                    Stop();
                    return;
                }

                if (m_ForebiddenLoreStatue.Deleted)
                {
                    Stop();
                    return;
                }

                if (m_ForebiddenLoreStatue.EffectCount >= m_ForebiddenLoreStatue.EffectMaxCount)
                {
                    m_ForebiddenLoreStatue.Delete();
                    Stop();

                    return;
                }

                m_ForebiddenLoreStatue.EffectCount++;

                Point3D location = m_ForebiddenLoreStatue.Location;
                Map     map      = m_ForebiddenLoreStatue.Map;

                int effectHue = m_ForebiddenLoreStatue.Hue - 1;

                int minDamage = m_ForebiddenLoreStatue.MinDamage;
                int maxDamage = m_ForebiddenLoreStatue.MaxDamage;

                List <Mobile> m_ValidMobiles = new List <Mobile>();

                IPooledEnumerable mobileInRange = m_ForebiddenLoreStatue.Map.GetMobilesInRange(location, m_ForebiddenLoreStatue.Range);

                foreach (Mobile mobile in mobileInRange)
                {
                    if (UOACZRegion.ContainsItem(m_ForebiddenLoreStatue))
                    {
                        if (!UOACZSystem.IsUOACZValidMobile(mobile))
                        {
                            continue;
                        }
                        if (!map.InLOS(location, mobile.Location))
                        {
                            continue;
                        }
                        if (mobile.Hidden)
                        {
                            continue;
                        }
                        if (mobile is UOACZBaseUndead)
                        {
                            continue;
                        }
                        if (mobile is PlayerMobile)
                        {
                            PlayerMobile player = mobile as PlayerMobile;

                            if (player.IsUOACZUndead)
                            {
                                continue;
                            }
                        }

                        m_ValidMobiles.Add(mobile);
                    }

                    else
                    {
                        if (!SpecialAbilities.MonsterCanDamage(null, mobile))
                        {
                            continue;
                        }
                    }
                }

                mobileInRange.Free();

                if (m_ValidMobiles.Count == 0)
                {
                    return;
                }

                Mobile  target         = m_ValidMobiles[Utility.RandomMinMax(0, m_ValidMobiles.Count - 1)];
                Point3D targetLocation = target.Location;

                IEntity startLocation = new Entity(Serial.Zero, new Point3D(location.X, location.Y, location.Z + 14), map);
                IEntity endLocation   = new Entity(Serial.Zero, new Point3D(targetLocation.X, targetLocation.Y, targetLocation.Z + 5), map);

                int particleSpeed = 5;

                Effects.PlaySound(location, map, 0x227);
                Effects.SendMovingParticles(startLocation, endLocation, 0x36D4, particleSpeed, 0, false, false, effectHue, 0, 9501, 0, 0, 0x100);

                Point3D newLocation = new Point3D(location.X, location.Y, location.Z + 14);

                TimedStatic timedStatic = new TimedStatic(0x3779, .5);

                timedStatic.Hue  = effectHue;
                timedStatic.Name = "dissipated energy";
                timedStatic.MoveToWorld(newLocation, map);

                double distance         = Utility.GetDistanceToSqrt(location, targetLocation);
                double destinationDelay = (double)distance * .08;

                Timer.DelayCall(TimeSpan.FromSeconds(destinationDelay), delegate
                {
                    if (m_ForebiddenLoreStatue.Deleted)
                    {
                        return;
                    }
                    if (target == null)
                    {
                        return;
                    }
                    if (target.Deleted || !target.Alive)
                    {
                        return;
                    }
                    if (Utility.GetDistanceToSqrt(m_ForebiddenLoreStatue.Location, targetLocation) >= 30)
                    {
                        return;
                    }

                    int damage = Utility.RandomMinMax(minDamage, maxDamage);

                    if (target is BaseCreature)
                    {
                        damage *= 2;
                    }

                    Effects.PlaySound(location, map, 0x208);

                    target.FixedParticles(0x36BD, 20, 20, 5044, effectHue, 0, EffectLayer.Head);
                    //Effects.SendLocationParticles(EffectItem.Create(target.Location, target.Map, TimeSpan.FromSeconds(0.5)), 0x3996, 10, 20, effectHue, 0, 5029, 0);

                    new Blood().MoveToWorld(targetLocation, map);
                    AOS.Damage(target, damage, 0, 100, 0, 0, 0);
                });
            }
Пример #3
0
        public void WaveBlast(Mobile from)
        {
            if (this == null)
            {
                return;
            }
            if (Deleted)
            {
                return;
            }
            if (from == null)
            {
                return;
            }

            Effects.PlaySound(Location, Map, 0x656);

            int radius = 10;

            int minRange = -1 * radius;
            int maxRange = radius + 1;

            for (int a = minRange; a < maxRange; a++)
            {
                for (int b = minRange; b < maxRange; b++)
                {
                    Point3D location = Location;
                    Map     map      = Map;

                    Point3D newLocation = new Point3D(location.X + a, location.Y + b, location.Z);
                    SpellHelper.AdjustField(ref newLocation, map, 12, false);

                    if (!map.InLOS(location, newLocation))
                    {
                        continue;
                    }

                    double distance      = Utility.GetDistanceToSqrt(location, newLocation);
                    double distanceDelay = (distance * .125);

                    Timer.DelayCall(TimeSpan.FromSeconds(distanceDelay), delegate
                    {
                        if (Utility.RandomDouble() <= .66)
                        {
                            Effects.SendLocationParticles(EffectItem.Create(newLocation, map, TimeSpan.FromSeconds(0.25)), 0x3709, 10, 30, 2121, 0, 5029, 0);
                        }
                    });

                    Timer.DelayCall(TimeSpan.FromSeconds(distanceDelay + 1.25), delegate
                    {
                        if (Utility.RandomDouble() <= .25)
                        {
                            return;
                        }

                        TimedStatic water = new TimedStatic(Utility.RandomList(4650, 4651, 4653, 4654, 4655), 10);
                        water.Name        = "water";
                        water.Hue         = 2120;

                        SpellHelper.AdjustField(ref newLocation, map, 12, false);

                        Effects.PlaySound(newLocation, map, 0x027);
                        water.MoveToWorld(newLocation, map);
                    });
                }
            }

            m_NextUseAllowed = DateTime.UtcNow + UsageCooldown;
        }
Пример #4
0
        public static void PlayerDeathExplosion(Point3D location, Map map, bool carnage, bool violentDeath)
        {
            List <int> m_MandatoryParts = new List <int>();
            List <int> m_ExtraParts     = new List <int>();

            #region CorpseItems

            switch (Utility.RandomMinMax(1, 2))
            {
            case 1:
                m_MandatoryParts.Add(Utility.RandomList(7393, 7401, 7584, 7598)); //Head
                m_MandatoryParts.Add(Utility.RandomList(7583, 7597));             //Torso
                break;

            case 2:
                m_MandatoryParts.Add(Utility.RandomList(7398, 7392, 7392, 7390));      //Torso With Head
                break;
            }

            switch (Utility.RandomMinMax(1, 2))
            {
            case 1:
                m_MandatoryParts.Add(Utility.RandomList(7587, 7602, 7394, 7395));     //Left Leg
                m_MandatoryParts.Add(Utility.RandomList(7588, 7601, 7394, 7395));     //Right Leg
                break;

            case 2:
                m_MandatoryParts.Add(Utility.RandomList(7391, 7396, 7399, 7403));     //Legs
                break;
            }

            m_MandatoryParts.Add(Utility.RandomList(7585, 7602, 7389, 7397)); //Left Arm
            m_MandatoryParts.Add(Utility.RandomList(7600, 7601, 7389, 7397)); //Right Arm

            m_MandatoryParts.Add(Utility.RandomList(7408));                   //Brain
            m_MandatoryParts.Add(Utility.RandomList(7405));                   //Heart
            m_MandatoryParts.Add(Utility.RandomList(7406));                   //Heart
            m_MandatoryParts.Add(Utility.RandomList(6933, 6934));             //Pelvis
            m_MandatoryParts.Add(Utility.RandomList(6935, 6936));             //Ribcage
            m_MandatoryParts.Add(Utility.RandomList(6939, 6940));             //Spine

            m_ExtraParts.Add(Utility.RandomList(7407));                       //Entrail
            m_ExtraParts.Add(Utility.RandomList(6929));                       //Bones
            m_ExtraParts.Add(Utility.RandomList(6930));                       //Bones
            m_ExtraParts.Add(Utility.RandomList(6937));                       //Bones
            m_ExtraParts.Add(Utility.RandomList(6938));                       //Bones
            m_ExtraParts.Add(Utility.RandomList(6931));                       //Bones
            m_ExtraParts.Add(Utility.RandomList(6932));                       //Bones

            m_ExtraParts.Add(Utility.RandomList(4650));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(4651));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(4652));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(4653));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(4654));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(5701));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(4655));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7439));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7438));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7436));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7433));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7431));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7428));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7425));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7410));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7415));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7416));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7418));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7420));                       //Blood
            m_ExtraParts.Add(Utility.RandomList(7425));                       //Blood

            #endregion

            double mandatoryPartChance = .33;
            double extraPartChance     = .5;

            int radius         = 2;
            int explosionSound = Utility.RandomList(0x4F1, 0x5D8, 0x5DA, 0x580);

            if (carnage && violentDeath)
            {
                mandatoryPartChance = .5;
                extraPartChance     = .66;
                radius = 3;
            }

            Effects.PlaySound(location, map, explosionSound);

            int minRange = radius * -1;
            int maxRange = radius;

            List <Point3D> m_ExplosionPoints = new List <Point3D>();

            //Mandatory Parts
            for (int a = minRange; a < maxRange + 1; a++)
            {
                for (int b = minRange; b < maxRange + 1; b++)
                {
                    Point3D newPoint = new Point3D(location.X + a, location.Y + b, location.Z);
                    SpellHelper.AdjustField(ref newPoint, map, 12, false);

                    if (map.InLOS(location, newPoint))
                    {
                        m_ExplosionPoints.Add(newPoint);
                    }
                }
            }

            //Mandatory Parts
            for (int a = 0; a < m_ExplosionPoints.Count; a++)
            {
                if (Utility.RandomDouble() <= mandatoryPartChance)
                {
                    Point3D explosionPoint = m_ExplosionPoints[a];

                    int itemId = 0;

                    int distance = Utility.GetDistance(location, explosionPoint);

                    if (m_MandatoryParts.Count > 0)
                    {
                        int index = Utility.RandomMinMax(0, m_MandatoryParts.Count - 1);

                        itemId = m_MandatoryParts[index];

                        m_MandatoryParts.RemoveAt(index);
                    }

                    else
                    {
                        itemId = m_ExtraParts[Utility.RandomMinMax(0, m_ExtraParts.Count - 1)];
                    }

                    Timer.DelayCall(TimeSpan.FromSeconds(distance * .15), delegate
                    {
                        TimedStatic gore = new TimedStatic(itemId, 10);
                        gore.Name        = "gore";
                        gore.MoveToWorld(explosionPoint, map);
                    });
                }
            }

            //Extra Parts
            for (int a = 0; a < m_ExplosionPoints.Count; a++)
            {
                if (Utility.RandomDouble() <= extraPartChance)
                {
                    Point3D explosionPoint = m_ExplosionPoints[a];

                    int itemId = m_ExtraParts[Utility.RandomMinMax(0, m_ExtraParts.Count - 1)];

                    int distance = Utility.GetDistance(location, explosionPoint);

                    Timer.DelayCall(TimeSpan.FromSeconds(distance * .15), delegate
                    {
                        TimedStatic gore = new TimedStatic(itemId, 10);
                        gore.Name        = "gore";
                        gore.MoveToWorld(explosionPoint, map);
                    });
                }
            }
        }