Overwrite

Complete Overwrite of the Folder with the free shard. ServUO 57.3 has been added.

Scripts/Services/Tomb of Kings/Serpent's Breath/EnergyBarrier.cs

@@ -0,0 +1,75 @@
+using System;
+
+namespace Server.Items
+{
+    public class EnergyBarrier : Item
+    {
+        private Timer m_SoundTimer;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool Active
+        {
+            get { return Visible; }
+            set
+            {
+                if (Active != value)
+                {
+                    Visible = value;
+
+                    if (Active)
+                        m_SoundTimer.Start();
+                    else
+                        m_SoundTimer.Stop();
+                }
+            }
+        }
+
+        public EnergyBarrier(Point3D location, Map map)
+            : base(0x3967)
+        {
+            Movable = false;
+            Light = LightType.Circle150;
+
+            MoveToWorld(location, map);
+
+            m_SoundTimer = Timer.DelayCall(TimeSpan.Zero, TimeSpan.FromSeconds(Utility.RandomMinMax(5, 50)), new TimerCallback(PlaySound));
+            m_SoundTimer.Start();
+        }
+
+        protected void PlaySound()
+        {
+            // Randomize the Timer Interval
+            m_SoundTimer.Interval = TimeSpan.FromSeconds(Utility.RandomMinMax(5, 50));
+
+            Effects.PlaySound(Location, Map, Utility.RandomList(0x1DC, 0x210, 0x2F4));
+        }
+
+        public override void OnAfterDelete()
+        {
+            base.OnAfterDelete();
+
+            if (m_SoundTimer != null)
+                m_SoundTimer.Stop();
+        }
+
+        public EnergyBarrier(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            m_SoundTimer = Timer.DelayCall(TimeSpan.Zero, TimeSpan.FromSeconds(5.0), new TimerCallback(PlaySound));
+            m_SoundTimer.Start();
+        }
+    }
+}

Scripts/Services/Tomb of Kings/Serpent's Breath/FireBarrier.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+
+namespace Server.Items
+{
+    public class FireBarrier : Item
+    {
+        private Timer m_SoundTimer;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool Active
+        {
+            get { return Visible; }
+            set
+            {
+                if (Active != value)
+                {
+                    Visible = value;
+
+                    if (Active)
+                        m_SoundTimer.Start();
+                    else
+                        m_SoundTimer.Stop();
+                }
+            }
+        }
+
+        public FireBarrier(Point3D location, Map map)
+            : base(0x3E27)
+        {
+            Movable = false;
+            Light = LightType.Circle150;
+            Hue = 0x47E;
+
+            MoveToWorld(location, map);
+
+            m_SoundTimer = Timer.DelayCall(TimeSpan.Zero, TimeSpan.FromSeconds(Utility.RandomMinMax(5, 50)), new TimerCallback(PlaySound));
+            m_SoundTimer.Start();
+        }
+
+        protected void PlaySound()
+        {
+            // Randomize the Timer Interval
+            m_SoundTimer.Interval = TimeSpan.FromSeconds(Utility.RandomMinMax(5, 50));
+
+            //Effects.PlaySound( Location, Map, Utility.RandomList( 0x1DC, 0x210, 0x2F4 ) );
+            Effects.PlaySound(Location, Map, Utility.RandomList(0x1DD, 0x345, 0x346, 0x347, 0x348, 0x349, 0x34A));
+        }
+
+        private Dictionary<Mobile, Timer> m_DamageTable = new Dictionary<Mobile, Timer>();
+
+        public override bool HandlesOnMovement { get { return true; } }
+
+        public override void OnMovement(Mobile m, Point3D oldLocation)
+        {
+            if (!Active || !m.Alive || !m.IsPlayer())
+                return;
+
+            if (m.InRange(this, 1) && !m_DamageTable.ContainsKey(m))
+            {
+                // Should start the timer
+                m_DamageTable[m] = Timer.DelayCall(TimeSpan.Zero, TimeSpan.FromSeconds(5.0), new TimerStateCallback<Mobile>(Damage), m);
+            }
+        }
+
+        protected void Damage(Mobile m)
+        {
+            if (Active && m.IsPlayer() && m.Alive && !Deleted && m.InRange(this, 1))
+            {
+                AOS.Damage(m, Utility.RandomMinMax(5, 7), 0, 100, 0, 0, 0);
+            }
+            else
+            {
+                Timer t = m_DamageTable[m];
+                t.Stop();
+
+                m_DamageTable.Remove(m);
+            }
+        }
+
+        public override void OnAfterDelete()
+        {
+            base.OnAfterDelete();
+
+            if (m_SoundTimer != null)
+                m_SoundTimer.Stop();
+        }
+
+        public FireBarrier(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            m_SoundTimer = Timer.DelayCall(TimeSpan.Zero, TimeSpan.FromSeconds(5.0), new TimerCallback(PlaySound));
+            m_SoundTimer.Start();
+        }
+    }
+}

Scripts/Services/Tomb of Kings/Serpent's Breath/FlameOfChaos.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Generic;
+
+namespace Server.Items
+{
+    public class FlameOfChaos : Item
+    {
+        public override int LabelNumber { get { return 1112128; } } // Flame of Chaos
+
+        private List<FireBarrier> m_Barriers;
+
+        [Constructable]
+        public FlameOfChaos(Point3D location, Map map)
+            : base(0x19AB)
+        {
+            Movable = false;
+            Light = LightType.Circle225;
+
+            MoveToWorld(location, map);
+
+            m_Barriers = new List<FireBarrier>(m_BarrierLocations.Length);
+
+            for (int i = 0; i < m_BarrierLocations.Length; i++)
+            {
+                m_Barriers.Add(new FireBarrier(m_BarrierLocations[i], map));
+            }
+        }
+
+        public override bool HandlesOnSpeech { get { return true; } }
+
+        public override void OnSpeech(SpeechEventArgs e)
+        {
+            string mantra = e.Speech.ToLower();
+
+            if (Visible && e.Mobile.InRange(this, 2) && (mantra == "an-ord" || mantra == "anord"))
+            {
+                Visible = false;
+
+                foreach (FireBarrier barrier in m_Barriers)
+                {
+                    barrier.Active = false;
+                }
+
+                Timer.DelayCall(TimeSpan.FromMinutes(2.0), new TimerCallback(RestoreBarrier));
+            }
+        }
+
+        protected void RestoreBarrier()
+        {
+            foreach (FireBarrier barrier in m_Barriers)
+            {
+                barrier.Active = true;
+            }
+
+            Visible = true;
+        }
+
+        public override void OnAfterDelete()
+        {
+            base.OnAfterDelete();
+
+            foreach (FireBarrier barrier in m_Barriers)
+            {
+                barrier.Delete();
+            }
+        }
+
+        private static Point3D[] m_BarrierLocations = new Point3D[]
+        {
+            new Point3D( 33, 207, 0 ),
+            new Point3D( 34, 207, 0 ),
+            new Point3D( 35, 207, 0 ),
+            new Point3D( 36, 207, 0 ),
+            new Point3D( 37, 207, 0 ),
+
+            new Point3D( 33, 206, 0 ),
+            new Point3D( 34, 206, 0 ),
+            new Point3D( 35, 206, 0 ),
+            new Point3D( 36, 206, 0 ),
+            new Point3D( 37, 206, 0 ),
+
+            new Point3D( 33, 204, 0 ),
+            new Point3D( 34, 204, 0 ),
+            new Point3D( 35, 204, 0 ),
+            new Point3D( 36, 204, 0 ),
+            new Point3D( 37, 204, 0 ),
+
+            new Point3D( 33, 203, 0 ),
+            new Point3D( 34, 203, 0 ),
+            new Point3D( 35, 203, 0 ),
+            new Point3D( 36, 203, 0 ),
+            new Point3D( 37, 203, 0 )
+        };
+
+        public FlameOfChaos(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+
+            writer.Write((int)m_Barriers.Count);
+
+            for (int i = 0; i < m_Barriers.Count; i++)
+                writer.Write((Item)m_Barriers[i]);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            int amount = reader.ReadInt();
+
+            m_Barriers = new List<FireBarrier>(amount);
+
+            for (int i = 0; i < amount; i++)
+                m_Barriers.Add(reader.ReadItem() as FireBarrier);
+
+            if (!Visible)
+                Timer.DelayCall(TimeSpan.Zero, new TimerCallback(RestoreBarrier));
+        }
+    }
+}

Scripts/Services/Tomb of Kings/Serpent's Breath/FlameOfOrder.cs

@@ -0,0 +1,209 @@
+using System;
+using System.Collections.Generic;
+
+namespace Server.Items
+{
+    public class FlameOfOrder : Item
+    {
+        public override int LabelNumber { get { return 1112127; } } // Flame of Order
+
+        private List<EnergyBarrier> m_Barriers;
+        private List<Blocker> m_Blockers;
+        private List<LOSBlocker> m_LOSBlockers;
+        private List<SBMessageTrigger> m_MsgTriggers;
+
+        [Constructable]
+        public FlameOfOrder(Point3D location, Map map)
+            : base(0x19AB)
+        {
+            Movable = false;
+            Light = LightType.Circle225;
+
+            MoveToWorld(location, map);
+
+            m_Barriers = new List<EnergyBarrier>(m_BarrierLocations.Length);
+            m_Blockers = new List<Blocker>(m_BarrierLocations.Length);
+            m_LOSBlockers = new List<LOSBlocker>(m_BarrierLocations.Length);
+            m_MsgTriggers = new List<SBMessageTrigger>(m_MsgTriggerLocations.Length);
+
+            foreach (Point3D loc in m_BarrierLocations)
+            {
+                m_Barriers.Add(new EnergyBarrier(loc, map));
+
+                Blocker blocker = new Blocker();
+                blocker.MoveToWorld(loc, map);
+                m_Blockers.Add(blocker);
+
+                LOSBlocker losblocker = new LOSBlocker();
+                losblocker.MoveToWorld(loc, map);
+                m_LOSBlockers.Add(losblocker);
+            }
+
+            foreach (Point3D loc in m_MsgTriggerLocations)
+            {
+                SBMessageTrigger trigger = new SBMessageTrigger(this);
+                trigger.MoveToWorld(loc, map);
+                m_MsgTriggers.Add(trigger);
+            }
+        }
+
+        public override bool HandlesOnSpeech { get { return true; } }
+
+        public override void OnSpeech(SpeechEventArgs e)
+        {
+            string mantra = e.Speech.ToLower();
+
+            if (Visible && e.Mobile.InRange(this, 2) && mantra == "ord")
+            {
+                Visible = false;
+
+                foreach (EnergyBarrier barrier in m_Barriers)
+                    barrier.Active = false;
+
+                foreach (Blocker blocker in m_Blockers)
+                    blocker.Delete();
+
+                foreach (LOSBlocker losblocker in m_LOSBlockers)
+                    losblocker.Delete();
+
+                m_Blockers.Clear();
+                m_LOSBlockers.Clear();
+
+                Timer.DelayCall(TimeSpan.FromMinutes(2.0), new TimerCallback(RestoreBarrier));
+            }
+        }
+
+        protected void RestoreBarrier()
+        {
+            foreach (EnergyBarrier barrier in m_Barriers)
+                barrier.Active = true;
+
+            foreach (Point3D loc in m_BarrierLocations)
+            {
+                Blocker blocker = new Blocker();
+                blocker.MoveToWorld(loc, Map);
+                m_Blockers.Add(blocker);
+
+                LOSBlocker losblocker = new LOSBlocker();
+                losblocker.MoveToWorld(loc, Map);
+                m_LOSBlockers.Add(losblocker);
+            }
+
+            Visible = true;
+        }
+
+        public override void OnAfterDelete()
+        {
+            base.OnAfterDelete();
+
+            foreach (Blocker blocker in m_Blockers)
+            {
+                blocker.Delete();
+            }
+
+            foreach (LOSBlocker losblocker in m_LOSBlockers)
+            {
+                losblocker.Delete();
+            }
+
+            foreach (SBMessageTrigger trigger in m_MsgTriggers)
+            {
+                trigger.Delete();
+            }
+
+            foreach (EnergyBarrier barrier in m_Barriers)
+            {
+                barrier.Delete();
+            }
+        }
+
+        private static Point3D[] m_BarrierLocations = new Point3D[]
+        {
+            new Point3D( 33, 205, 0 ),
+            new Point3D( 34, 205, 0 ),
+            new Point3D( 35, 205, 0 ),
+            new Point3D( 36, 205, 0 ),
+            new Point3D( 37, 205, 0 ),
+        };
+
+        private static Point3D[] m_MsgTriggerLocations = new Point3D[]
+        {
+            new Point3D( 33, 203, 0 ),
+            new Point3D( 34, 203, 0 ),
+            new Point3D( 35, 203, 0 ),
+            new Point3D( 36, 203, 0 ),
+            new Point3D( 37, 203, 0 ),
+        };
+
+        public FlameOfOrder(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+
+            writer.Write((int)m_Barriers.Count);
+
+            for (int i = 0; i < m_Barriers.Count; i++)
+                writer.Write((Item)m_Barriers[i]);
+
+            writer.Write((int)m_Blockers.Count);
+
+            for (int i = 0; i < m_Blockers.Count; i++)
+                writer.Write((Item)m_Blockers[i]);
+
+            writer.Write((int)m_LOSBlockers.Count);
+
+            for (int i = 0; i < m_LOSBlockers.Count; i++)
+                writer.Write((Item)m_LOSBlockers[i]);
+
+            writer.Write((int)m_MsgTriggers.Count);
+
+            for (int i = 0; i < m_MsgTriggers.Count; i++)
+                writer.Write((Item)m_MsgTriggers[i]);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            // barrier
+            int amount = reader.ReadInt();
+
+            m_Barriers = new List<EnergyBarrier>(amount);
+
+            for (int i = 0; i < amount; i++)
+                m_Barriers.Add(reader.ReadItem() as EnergyBarrier);
+
+            // blockers
+            amount = reader.ReadInt();
+
+            m_Blockers = new List<Blocker>(amount);
+
+            for (int i = 0; i < amount; i++)
+                m_Blockers.Add(reader.ReadItem() as Blocker);
+
+            amount = reader.ReadInt();
+
+            m_LOSBlockers = new List<LOSBlocker>(amount);
+
+            for (int i = 0; i < amount; i++)
+                m_LOSBlockers.Add(reader.ReadItem() as LOSBlocker);
+
+            // msg triggers
+            amount = reader.ReadInt();
+
+            m_MsgTriggers = new List<SBMessageTrigger>(amount);
+
+            for (int i = 0; i < amount; i++)
+                m_MsgTriggers.Add(reader.ReadItem() as SBMessageTrigger);
+
+            if (!Visible)
+                Timer.DelayCall(TimeSpan.Zero, new TimerCallback(RestoreBarrier));
+        }
+    }
+}

Scripts/Services/Tomb of Kings/Serpent's Breath/SBMessageTrigger.cs

@@ -0,0 +1,53 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class SBMessageTrigger : Item
+    {
+        private FlameOfOrder m_Flame;
+
+        [Constructable]
+        public SBMessageTrigger(FlameOfOrder flame)
+            : base(0x1BC3)
+        {
+            m_Flame = flame;
+
+            Name = "Serpent's Breath Message Trigger";
+
+            Movable = false;
+            Visible = false;
+        }
+
+        public SBMessageTrigger(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool OnMoveOver(Mobile m)
+        {
+            if (m.Location.Y < Location.Y && !m_Flame.Deleted && m_Flame.Visible)
+            {
+                m.SendLocalizedMessage(1112225); // The Serpent's Breath burns brighter than ever, blocking your escape! You shall have to venture further into the tomb in search of an exit.
+            }
+
+            return base.OnMoveOver(m);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+
+            writer.Write((Item)m_Flame);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            m_Flame = reader.ReadItem() as FlameOfOrder;
+        }
+    }
+}