Overwrite

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

Scripts/Services/Tomb of Kings/Chambers/Chamber.cs

@@ -0,0 +1,126 @@
+using Server;
+using System;
+using System.Collections.Generic;
+
+namespace Server.Engines.TombOfKings
+{
+	public class ChamberInfo
+	{
+		private Point3D m_BarrierLocation, m_SwitchLocation;
+		private int m_SwitchId;
+
+		public Point3D BarrierLocation { get { return m_BarrierLocation; } }
+		public Point3D SwitchLocation { get { return m_SwitchLocation; } }
+		public int SwitchId { get { return m_SwitchId; } }
+
+		public ChamberInfo( Point3D barrierLoc, Point3D switchLoc, int switchId )
+		{
+			m_BarrierLocation = barrierLoc;
+			m_SwitchLocation = switchLoc;
+			m_SwitchId = switchId;
+		}
+	}
+
+	public class Chamber
+	{
+		public static void Initialize()
+		{
+			// we should call it after deserialize the levers
+			Timer.DelayCall( TimeSpan.Zero, new TimerCallback( Generate ) );
+		}
+
+		public static void Generate()
+		{
+			if ( ChamberLever.Levers.Count == 0 )
+				return;
+
+			foreach ( ChamberInfo info in m_ChamberInfos )
+				m_Chambers.Add( new Chamber( info ) );
+
+			// randomize
+			List<ChamberLever> levers = new List<ChamberLever>( ChamberLever.Levers );
+
+			foreach ( Chamber chamber in m_Chambers )
+			{
+				int idx = Utility.Random( levers.Count );
+
+				chamber.Lever = levers[idx];
+				levers[idx].Chamber = chamber;
+				levers.RemoveAt( idx );
+			}
+		}
+
+		private static List<Chamber> m_Chambers = new List<Chamber>();
+
+		public static List<Chamber> Chambers
+		{
+			get { return m_Chambers; }
+		}
+
+		private static ChamberInfo[] m_ChamberInfos = new ChamberInfo[]
+		{
+			// left side
+			new ChamberInfo( new Point3D( 15, 200, -5 ), new Point3D( 13, 195, 7 ), 0x1091 ),
+			new ChamberInfo( new Point3D( 15, 184, -5 ), new Point3D( 13, 179, 7 ), 0x1091 ),
+			new ChamberInfo( new Point3D( 15, 168, -5 ), new Point3D( 13, 163, 7 ), 0x1091 ),
+			new ChamberInfo( new Point3D( 15, 152, -5 ), new Point3D( 13, 147, 7 ), 0x1091 ),
+			new ChamberInfo( new Point3D( 15, 136, -5 ), new Point3D( 13, 131, 7 ), 0x1091 ),
+			new ChamberInfo( new Point3D( 15, 120, -5 ), new Point3D( 13, 115, 7 ), 0x1091 ),
+
+			// right side
+			new ChamberInfo( new Point3D( 55, 200, -5 ), new Point3D( 56, 197, 7 ), 0x1090 ),
+			new ChamberInfo( new Point3D( 55, 184, -5 ), new Point3D( 56, 181, 7 ), 0x1090 ),
+			new ChamberInfo( new Point3D( 55, 168, -5 ), new Point3D( 56, 165, 7 ), 0x1090 ),
+			new ChamberInfo( new Point3D( 55, 152, -5 ), new Point3D( 56, 149, 7 ), 0x1090 ),
+			new ChamberInfo( new Point3D( 55, 136, -5 ), new Point3D( 56, 133, 7 ), 0x1090 ),
+			new ChamberInfo( new Point3D( 55, 120, -5 ), new Point3D( 56, 117, 7 ), 0x1090 ),
+		};
+
+		private ChamberSwitch m_Switch;
+		private ChamberBarrier m_Barrier;
+		private ChamberLever m_Lever;
+
+		public ChamberSwitch Switch
+		{
+			get { return m_Switch; }
+			set { m_Switch = value; }
+		}
+
+		public ChamberBarrier Barrier
+		{
+			get { return m_Barrier; }
+			set { m_Barrier = value; }
+		}
+
+		public ChamberLever Lever
+		{
+			get { return m_Lever; }
+			set { m_Lever = value; }
+		}
+
+		public bool IsOpened()
+		{
+			return !m_Barrier.Active;
+		}
+
+		public void Open()
+		{
+			m_Barrier.Active = false;
+			m_Lever.Switch();
+
+			Timer.DelayCall( TimeSpan.FromMinutes( Utility.RandomMinMax( 10, 15 ) ), RestoreBarrier );
+		}
+
+		public void RestoreBarrier()
+		{
+			m_Barrier.Active = true;
+			m_Lever.InvalidateProperties();
+		}
+
+		public Chamber( ChamberInfo info )
+		{
+			m_Switch = new ChamberSwitch( this, info.SwitchLocation, info.SwitchId );
+			m_Barrier = new ChamberBarrier( info.BarrierLocation );
+		}
+	}
+}

Scripts/Services/Tomb of Kings/Chambers/ChamberBarrier.cs

@@ -0,0 +1,103 @@
+using System;
+using Server;
+using Server.Items;
+
+namespace Server.Engines.TombOfKings
+{
+    public class ChamberBarrier : Item
+    {
+        private Blocker m_Blocker;
+        private LOSBlocker m_LOSBlocker;
+
+        public bool Active
+        {
+            get { return Visible; }
+            set
+            {
+                if (Visible != value)
+                {
+                    if (Visible = value)
+                    {
+                        m_Blocker = new Blocker();
+                        m_Blocker.MoveToWorld(Location, Map);
+
+                        m_LOSBlocker = new LOSBlocker();
+                        m_LOSBlocker.MoveToWorld(Location, Map);
+                    }
+                    else
+                    {
+                        m_Blocker.Delete();
+                        m_Blocker = null;
+
+                        m_LOSBlocker.Delete();
+                        m_LOSBlocker = null;
+                    }
+                }
+            }
+        }
+
+        public ChamberBarrier(Point3D loc)
+            : base(0x3979)
+        {
+            Light = LightType.Circle150;
+
+            Movable = false;
+            MoveToWorld(loc, Map.TerMur);
+
+            m_Blocker = new Blocker();
+            m_Blocker.MoveToWorld(loc, Map.TerMur);
+
+            m_LOSBlocker = new LOSBlocker();
+            m_LOSBlocker.MoveToWorld(loc, Map.TerMur);
+        }
+
+        public ChamberBarrier(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+
+            writer.Write((bool)(m_Blocker != null));
+
+            if (m_Blocker != null)
+                writer.Write((Item)m_Blocker);
+
+            writer.Write((bool)(m_LOSBlocker != null));
+
+            if (m_LOSBlocker != null)
+                writer.Write((Item)m_LOSBlocker);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (reader.ReadBool())
+            {
+                m_Blocker = reader.ReadItem() as Blocker;
+
+                if (m_Blocker != null)
+                {
+                    m_Blocker.Delete();
+                }
+            }
+
+            if (reader.ReadBool())
+            {
+                m_LOSBlocker = reader.ReadItem() as LOSBlocker;
+
+                if (m_LOSBlocker != null)
+                {
+                    m_LOSBlocker.Delete();
+                }
+            }
+
+            Delete();
+        }
+    }
+}

Scripts/Services/Tomb of Kings/Chambers/ChamberLever.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Collections.Generic;
+using Server;
+
+namespace Server.Engines.TombOfKings
+{
+    public class ChamberLever : Item
+    {
+        public static void Generate()
+        {
+            foreach (Point3D loc in m_LeverLocations)
+            {
+                var item = new ChamberLever(loc);
+                WeakEntityCollection.Add("sa", item);
+
+                m_Levers.Add(item);
+            }
+        }
+
+        private static Point3D[] m_LeverLocations = new Point3D[]
+        {
+            new Point3D( 25, 229, 2 ),
+            new Point3D( 25, 227, 2 ),
+            new Point3D( 25, 225, 2 ),
+
+            new Point3D( 25, 221, 2 ),
+            new Point3D( 25, 219, 2 ),
+            new Point3D( 25, 217, 2 ),
+
+            new Point3D( 45, 229, 2 ),
+            new Point3D( 45, 227, 2 ),
+            new Point3D( 45, 225, 2 ),
+
+            new Point3D( 45, 221, 2 ),
+            new Point3D( 45, 219, 2 ),
+            new Point3D( 45, 217, 2 ),
+        };
+
+        private static List<ChamberLever> m_Levers = new List<ChamberLever>();
+
+        public static List<ChamberLever> Levers
+        {
+            get { return m_Levers; }
+        }
+
+        private Chamber m_Chamber;
+
+        public Chamber Chamber
+        {
+            get { return m_Chamber; }
+            set
+            {
+                m_Chamber = value;
+                InvalidateProperties();
+            }
+        }
+
+        public bool IsUsable()
+        {
+            if (m_Chamber == null)
+                return false;
+
+            return !m_Chamber.IsOpened();
+        }
+
+        public ChamberLever(Point3D loc)
+            : base(Utility.RandomBool() ? 0x108C : 0x108E)
+        {
+            Movable = false;
+            MoveToWorld(loc, Map.TerMur);
+        }
+
+        public ChamberLever(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void AddNameProperties(ObjectPropertyList list)
+        {
+            if (IsUsable())
+                list.Add(1112130); // a lever
+            else
+                list.Add(1112129); // a lever (unusable)
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsUsable() && from.InRange(this, 1))
+                m_Chamber.Open();
+        }
+
+        public void Switch()
+        {
+            if (ItemID == 0x108C)
+                ItemID = 0x108E;
+            else
+                ItemID = 0x108C;
+
+            Effects.PlaySound(Location, Map, 0x3E8);
+
+            InvalidateProperties();
+        }
+
+        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_Levers.Add(this);
+        }
+    }
+}

Scripts/Services/Tomb of Kings/Chambers/ChamberSpawner.cs

@@ -0,0 +1,149 @@
+using System;
+using System.Collections.Generic;
+using Server.Mobiles;
+
+namespace Server.Engines.TombOfKings
+{
+    public class ChamberSpawner : Item
+    {
+        public static void Generate()
+        {
+            for (int i = 0; i < m_Positions.Length; i++)
+            {
+                WeakEntityCollection.Add("sa", new ChamberSpawner(m_Positions[i], Map.TerMur));
+            }
+        }
+
+        private static Point3D[] m_Positions = new Point3D[]
+        {
+            new Point3D( 9, 199, -9 ),
+            new Point3D( 9, 183, -9 ),
+            new Point3D( 9, 167, -9 ),
+            new Point3D( 9, 151, -9 ),
+            new Point3D( 9, 135, -9 ),
+            new Point3D( 9, 119, -9 ),
+
+            new Point3D( 60, 199, -9 ),
+            new Point3D( 60, 183, -9 ),
+            new Point3D( 60, 167, -9 ),
+            new Point3D( 60, 151, -9 ),
+            new Point3D( 60, 135, -9 ),
+            new Point3D( 60, 119, -9 ),
+        };
+
+        private static Type[] m_CreatureTypes = new Type[]
+        {
+            typeof( SilverSerpent ),
+            typeof( UndeadGuardian ),
+            typeof( PutridUndeadGuardian )
+        };
+
+        private List<Mobile> m_Creatures;
+        private Timer m_RespawnTimer;
+
+        public ChamberSpawner(Point3D loc, Map map)
+            : base(0x2006)
+        {
+            Stackable = true;
+            Amount = loc.Y <= 152 ? 754 : 753;
+
+            Movable = false;
+
+            m_Creatures = new List<Mobile>();
+
+            MoveToWorld(loc, map);
+            Respawn();
+            m_RespawnTimer = Timer.DelayCall(TimeSpan.FromMinutes(15.0), TimeSpan.FromMinutes(15.0), new TimerCallback(CheckSpawn));
+        }
+
+        public override void AddNameProperties(ObjectPropertyList list)
+        {
+            list.Add(1070701, "gargoyle"); // a ~1_CORPSENAME~ corpse
+        }
+
+        public bool IsEmpty()
+        {
+            for (int i = 0; i < m_Creatures.Count; i++)
+                if (m_Creatures[i].Alive)
+                    return false;
+
+            return true;
+        }
+
+        public void CheckSpawn()
+        {
+            if (Utility.RandomBool() && IsEmpty())
+                Respawn();
+        }
+
+        public void Respawn()
+        {
+            m_Creatures.Clear();
+
+            int total = Utility.RandomMinMax(3, 8);
+            Type creatureType = m_CreatureTypes[Utility.Random(m_CreatureTypes.Length)];
+
+            for (int i = 0; i < total; i++)
+            {
+                Mobile m = (Mobile)Activator.CreateInstance(creatureType);
+                m.MoveToWorld(Map.GetSpawnPosition(Location, 4), Map);
+
+                BaseCreature bc = m as BaseCreature;
+
+                if (bc != null)
+                {
+                    bc.RangeHome = 5;
+                    bc.Home = Location;
+                }
+
+                m_Creatures.Add(m);
+            }
+        }
+
+        public override void OnAfterDelete()
+        {
+            base.OnAfterDelete();
+
+            for (int i = 0; i < m_Creatures.Count; i++)
+                m_Creatures[i].Delete();
+
+            if (m_RespawnTimer != null)
+                m_RespawnTimer.Stop();
+        }
+
+        public ChamberSpawner(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+
+            writer.Write((int)m_Creatures.Count);
+
+            for (int i = 0; i < m_Creatures.Count; i++)
+                writer.Write((Mobile)m_Creatures[i]);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            m_Creatures = new List<Mobile>();
+            int count = reader.ReadInt();
+
+            for (int i = 0; i < count; i++)
+            {
+                Mobile m = reader.ReadMobile();
+
+                if (m != null)
+                    m_Creatures.Add(m);
+            }
+
+            m_RespawnTimer = Timer.DelayCall(TimeSpan.Zero, TimeSpan.FromMinutes(15.0), new TimerCallback(CheckSpawn));
+        }
+    }
+}

Scripts/Services/Tomb of Kings/Chambers/ChamberSwitch.cs

@@ -0,0 +1,56 @@
+using System;
+using Server;
+
+namespace Server.Engines.TombOfKings
+{
+    public class ChamberSwitch : Item
+    {
+        private Chamber m_Chamber;
+
+        public ChamberSwitch(Chamber chamber, Point3D loc, int itemId)
+            : base(itemId)
+        {
+            m_Chamber = chamber;
+
+            Movable = false;
+            MoveToWorld(loc, Map.TerMur);
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (!m_Chamber.IsOpened() && from.InRange(this, 1))
+            {
+                Effects.PlaySound(Location, Map, 0x3E8);
+
+                switch (ItemID)
+                {
+                    case 0x108F: ItemID = 0x1090; break;
+                    case 0x1090: ItemID = 0x108F; break;
+                    case 0x1091: ItemID = 0x1092; break;
+                    case 0x1092: ItemID = 0x1091; break;
+                }
+
+                m_Chamber.Open();
+            }
+        }
+
+        public ChamberSwitch(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();
+
+            Delete();
+        }
+    }
+}