Overwrite

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

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/CompassionBanner.cs

@@ -0,0 +1,59 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39351, 39352)]
+    public class CompassionBanner : Item
+	{
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123375;
+            }
+        }
+
+        [Constructable]
+        public CompassionBanner() : base(39351)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30575);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public CompassionBanner(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/CovetousBanner.cs

@@ -0,0 +1,59 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39335, 39336)]
+    public class CovetousBanner : Item
+	{
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123359;
+            }
+        }
+
+        [Constructable]
+        public CovetousBanner() : base(39335)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30567);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public CovetousBanner(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/DeceitBanner.cs

@@ -0,0 +1,60 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39337, 39338)]
+    public class DeceitBanner : Item
+    {
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123361;
+            }
+        }
+
+        [Constructable]
+        public DeceitBanner()
+            : base(39337)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30568);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public DeceitBanner(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/DespiseBanner.cs

@@ -0,0 +1,60 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39339, 39340)]
+    public class DespiseBanner : Item
+    {
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123363;
+            }
+        }
+
+        [Constructable]
+        public DespiseBanner()
+            : base(39339)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30569);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public DespiseBanner(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/DestardBanner.cs

@@ -0,0 +1,60 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39341, 39342)]
+    public class DestardBanner : Item
+    {
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123365;
+            }
+        }
+
+        [Constructable]
+        public DestardBanner()
+            : base(39341)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30570);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public DestardBanner(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/HonestyBanner.cs

@@ -0,0 +1,59 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39353, 39354)]
+    public class HonestyBanner : Item
+	{
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123377;
+            }
+        }
+
+        [Constructable]
+        public HonestyBanner() : base(39353)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30576);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public HonestyBanner(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/HonorBanner.cs

@@ -0,0 +1,59 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39355, 39356)]
+    public class HonorBanner : Item
+	{
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123379;
+            }
+        }
+
+        [Constructable]
+        public HonorBanner() : base(39355)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30577);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public HonorBanner(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/HumilityBanner.cs

@@ -0,0 +1,59 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39357, 39358)]
+    public class HumilityBanner : Item
+	{
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123381;
+            }
+        }
+
+        [Constructable]
+        public HumilityBanner() : base(39357)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30578);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public HumilityBanner(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/HythlothBanner.cs

@@ -0,0 +1,60 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39343, 39344)]
+    public class HythlothBanner : Item
+    {
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123367;
+            }
+        }
+
+        [Constructable]
+        public HythlothBanner()
+            : base(39343)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30571);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public HythlothBanner(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/JusticeBanner.cs

@@ -0,0 +1,59 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39359, 39360)]
+    public class JusticeBanner : Item
+	{
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123383;
+            }
+        }
+
+        [Constructable]
+        public JusticeBanner() : base(39359)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30579);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public JusticeBanner(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/PrideBanner.cs

@@ -0,0 +1,60 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39345, 39346)]
+    public class PrideBanner : Item
+    {
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123369;
+            }
+        }
+
+        [Constructable]
+        public PrideBanner()
+            : base(39345)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30572);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public PrideBanner(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/SacraficeBanner.cs

@@ -0,0 +1,59 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39361, 39362)]
+    public class SacraficeBanner : Item
+	{
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123385;
+            }
+        }
+
+        [Constructable]
+        public SacraficeBanner() : base(39361)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30580);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public SacraficeBanner(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/ShameBanner.cs

@@ -0,0 +1,60 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39347, 39348)]
+    public class ShameBanner : Item
+    {
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123371;
+            }
+        }
+
+        [Constructable]
+        public ShameBanner()
+            : base(39347)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30573);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public ShameBanner(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/SpiritualityBanner.cs

@@ -0,0 +1,59 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39363, 39364)]
+    public class SpiritualityBanner : Item
+	{
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123387;
+            }
+        }
+
+        [Constructable]
+        public SpiritualityBanner() : base(39363)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30581);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public SpiritualityBanner(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/ValorBanner.cs

@@ -0,0 +1,59 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39365, 39366)]
+    public class ValorBanner : Item
+	{
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123389;
+            }
+        }
+
+        [Constructable]
+        public ValorBanner() : base(39365)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30582);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public ValorBanner(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Banners/WrongBanner.cs

@@ -0,0 +1,60 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    [FlipableAttribute(39349, 39350)]
+    public class WrongBanner : Item
+    {
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1123373;
+            }
+        }
+
+        [Constructable]
+        public WrongBanner()
+            : base(39349)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (m.InRange(this.GetWorldLocation(), 2))
+            {
+                Gump g = new Gump(50, 50);
+                g.AddImage(0, 0, 30574);
+                m.SendGump(g);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public WrongBanner(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/CannonTurret.cs

@@ -0,0 +1,331 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using System.Linq;
+
+namespace Server.Engines.VvV
+{
+    public class CannonTurret : BaseAddon
+    {
+        public const int ScanRange = 8;
+        public const int ReloadDelay = 10;
+
+        private bool _NoShoot;
+        private int _ShotsRemaining;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Mobile Owner { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int ShotsRemaining
+        {
+            get { return _ShotsRemaining; }
+            set
+            {
+                _ShotsRemaining = value;
+
+                if (_ShotsRemaining <= 0)
+                    Delete();
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public CannonBase Base { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Item Turret { get; set; }
+
+        private DateTime _NextShot;
+
+        public override BaseAddonDeed Deed { get { return null; } }
+
+        [Constructable]
+        public CannonTurret()
+            : this(null)
+        {
+        }
+
+        public CannonTurret(Mobile m)
+        {
+            Owner = m;
+
+            ShotsRemaining = 20;
+
+            Base = new CannonBase(this);
+            Base.MoveToWorld(this.Location, this.Map);
+
+            AddonComponent c = new LocalizedAddonComponent(16918, 1155505);
+            AddComponent(c, 0, 0, 3);
+            Turret = c;
+
+            _NextShot = DateTime.UtcNow;
+        }
+
+        public override void OnLocationChange(Point3D oldLocation)
+        {
+            base.OnLocationChange(oldLocation);
+
+            if (Base != null && !Base.Deleted)
+                Base.Location = this.Location;
+        }
+
+        public override void OnMapChange()
+        {
+            base.OnMapChange();
+
+            if (Base != null && !Base.Deleted)
+                Base.Map = this.Map;
+        }
+
+        public override void Delete()
+        {
+            base.Delete();
+
+            if (Base != null && !Base.Deleted)
+                Base.Delete();
+        }
+
+        public void Scan()
+        {
+            if (Deleted || this.Map == null || _ShotsRemaining <= 0 || _NoShoot)
+                return;
+
+            IPooledEnumerable eable = this.Map.GetMobilesInRange(this.Location, ScanRange);
+            List<Mobile> list = new List<Mobile>();
+
+            foreach (Mobile m in eable)
+            {
+                if (Owner == null || (ViceVsVirtueSystem.IsEnemy(Owner, m) && m.InLOS(this.Location)
+                                                                           && m is PlayerMobile 
+                                                                           && m.AccessLevel == AccessLevel.Player))
+                {
+                    list.Add(m);
+                }
+            }
+
+            eable.Free();
+            Mobile target = null;
+            double closest = ScanRange;
+
+            if (list.Count > 0)
+            {
+                foreach (Mobile m in list.Where(mob => target == null || mob.GetDistanceToSqrt(target) < closest))
+                {
+                    target = m;
+                    closest = m.GetDistanceToSqrt(target);
+                }
+            }
+
+            if (target != null)
+            {
+                AimAndShoot(target, (int)Math.Ceiling(closest));
+            }
+
+            list.Clear();
+            list.TrimExcess();
+        }
+
+        public void AimAndShoot(Mobile target, int range)
+        {
+            Direction d = Utility.GetDirection(this, target);
+
+            switch (d)
+            {
+                default:
+                case Direction.North:
+                case Direction.Right: Turret.ItemID = 16920; break;
+                case Direction.East:
+                case Direction.Down: Turret.ItemID = 16921; break;
+                case Direction.South:
+                case Direction.Left: Turret.ItemID = 16918; break;
+                case Direction.West:
+                case Direction.Up: Turret.ItemID = 16919; break;
+            }
+
+            if (_NextShot > DateTime.UtcNow)
+                return;
+
+            Timer.DelayCall(TimeSpan.FromMilliseconds(250), () =>
+            {
+                Point3D p = new Point3D(this.X, this.Y, this.Z + 2);
+                Map map = this.Map;
+
+                switch (Turret.ItemID)
+                {
+                    case 16920: p.Y--; break;
+                    case 16921: p.X++; break;
+                    case 16918: p.Y++; break;
+                    case 16919: p.X--; break;
+                }
+
+                Effects.SendLocationEffect(p, map, 14120, 15, 10);
+                Effects.PlaySound(p, map, 0x664);
+            });
+
+            Timer.DelayCall(TimeSpan.FromMilliseconds(250 + (150 * (range))), () =>
+            {
+                if (Owner != null)
+                    Owner.DoHarmful(target);
+
+                AOS.Damage(target, Owner, Utility.RandomMinMax(75, 100), 100, 0, 0, 0, 0);
+
+                Effects.SendLocationEffect(target.Location, target.Map, Utility.RandomBool() ? 14000 : 14013, 15, 10);
+                Effects.PlaySound(target.Location, target.Map, 0x207);
+
+                ShotsRemaining--;
+            });
+
+            _NextShot = DateTime.UtcNow + TimeSpan.FromSeconds(ReloadDelay);
+        }
+
+        public class CannonBase : DamageableItem
+        {
+            public override int LabelNumber { get { return 1155505; } }
+
+            public CannonTurret Turret { get; set; }
+
+            public CannonBase(CannonTurret turret)
+                : base(1822, 1822)
+            {
+                Level = ItemLevel.Hard;
+                Turret = turret;
+
+                Name = "a cannon turret";
+            }
+
+            public override void Delete()
+            {
+                base.Delete();
+
+                if (Turret != null)
+                    Turret.Delete();
+            }
+
+            public CannonBase(Serial serial)
+                : base(serial)
+            {
+            }
+
+            public override void Serialize(GenericWriter writer)
+            {
+                base.Serialize(writer);
+                writer.Write(0);
+            }
+
+            public override void Deserialize(GenericReader reader)
+            {
+                base.Deserialize(reader);
+                int version = reader.ReadInt();
+            }
+        }
+
+        public CannonTurret(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write(Owner);
+            writer.Write(Base);
+            writer.Write(Turret);
+            writer.Write(ShotsRemaining);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            Owner = reader.ReadMobile();
+            Base = reader.ReadItem() as CannonBase;
+            Turret = reader.ReadItem();
+            ShotsRemaining = reader.ReadInt();
+
+            _NoShoot = true;
+            Timer.DelayCall(TimeSpan.FromSeconds(10), () =>
+            {
+                if (Base != null)
+                {
+                    if (ViceVsVirtueSystem.Instance.Battle.OnGoing)
+                    {
+                        Base.Turret = this;
+                        ViceVsVirtueSystem.Instance.Battle.Turrets.Add(this);
+                        _NoShoot = false;
+                        return;
+                    }
+                }
+
+                Delete();
+            });
+        }
+    }
+
+    public class CannonTurretPlans : Item
+    {
+        public override int LabelNumber { get { return 1155503; } } // Plans for a Cannon Turret
+
+        [Constructable]
+        public CannonTurretPlans() : base(5630)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (IsChildOf(m.Backpack))
+            {
+                VvVBattle battle = ViceVsVirtueSystem.Instance.Battle;
+
+                if (!ViceVsVirtueSystem.IsVvV(m))
+                {
+                    m.SendLocalizedMessage(1155496); // This item can only be used by VvV participants!
+                }
+                else if (battle == null || !battle.OnGoing || !battle.IsInActiveBattle(m))
+                {
+                    m.SendLocalizedMessage(1155406); // This item can only be used in an active VvV battle region!
+                }
+                else if (battle.TurretCount > VvVBattle.MaxTurrets)
+                {
+                    m.SendLocalizedMessage(1155502); // The turret limit for this battle has been reached!
+                }
+                else
+                {
+                    CannonTurret t = new CannonTurret(m);
+                    t.MoveToWorld(m.Location, m.Map);
+
+                    battle.Turrets.Add(t);
+
+                    Delete();
+                }
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public CannonTurretPlans(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/EssenceOfCourage.cs

@@ -0,0 +1,46 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+
+namespace Server.Engines.VvV
+{
+    public class EssenceOfCourage : Item
+    {
+        public override int LabelNumber { get { return 1155554; } } // Essence of Courage
+
+        [Constructable]
+        public EssenceOfCourage()
+            : base(3838)
+        {
+            Hue = 2718;
+            //TODO: ID and Stackable?
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (IsChildOf(m.Backpack))
+            {
+                m.SendLocalizedMessage(1155555); // Feed this to VvV War Steeds to maintain their battle readiness!
+            }
+        }
+
+        public EssenceOfCourage(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/ForgedRoyalPardon.cs

@@ -0,0 +1,84 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+	public class ForgedRoyalPardon : Item
+	{
+        public override int LabelNumber { get { return 1155524; } } // Forged Royal Pardon
+
+        [Constructable]
+        public ForgedRoyalPardon()
+            : base(18098)
+        {
+            Hue = 0x21;
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (IsChildOf(m.Backpack))
+            {
+                if (m is PlayerMobile && ViceVsVirtueSystem.IsVvV(m))
+                {
+                    if (m.Kills <= 0)
+                    {
+                        m.SendMessage("You have no use for this item.");
+                    }
+                    else if (Server.Spells.SpellHelper.CheckCombat(m))
+                    {
+                        m.SendLocalizedMessage(1116588); //You cannot use a forged pardon while in combat.
+                    }
+                    else
+                    {
+                        m.SendGump(new ConfirmCallbackGump((PlayerMobile)m, 1155524, 1155525, null, null, (mobile, obj) =>
+                            {
+                                mobile.Kills = 0;
+
+                                mobile.Delta(MobileDelta.Noto);
+
+                                mobile.SendMessage("You have been pardoned from all murder counts.");
+                                Delete();
+
+                                //TODO: Effects? Message?
+                            }));
+                    }
+                }
+                else
+                {
+                    m.SendLocalizedMessage(1155496); // This item can only be used by VvV participants!
+                }
+            }
+            else
+            {
+                m.SendLocalizedMessage(1042004); //That must be in your pack for you to use it.
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public ForgedRoyalPardon(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/ManaSpike.cs

@@ -0,0 +1,118 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+
+namespace Server.Engines.VvV
+{
+	public class ManaSpike : Item
+	{
+        public override int LabelNumber { get { return 1155508; } }
+
+        [Constructable]
+		public ManaSpike() : base(2308)
+		{
+		}
+		
+		public override void OnDoubleClick(Mobile m)
+		{
+			if(IsChildOf(m.Backpack))
+			{
+				VvVBattle battle = ViceVsVirtueSystem.Instance.Battle;
+				
+				if(!ViceVsVirtueSystem.IsVvV(m))
+				{
+					m.SendLocalizedMessage(1155496); // This item can only be used by VvV participants!
+				}
+                else if (battle == null || battle.Region == null || !battle.OnGoing || !battle.IsInActiveBattle(m))
+				{
+					m.SendLocalizedMessage(1155406); // This item can only be used in an active VvV battle region!
+				}
+				else if(battle.NextManaSpike > DateTime.UtcNow)
+				{
+					m.SendLocalizedMessage(1155497); // The ground is too charged to use a mana spike!
+				}
+				else if (m.Mana < 50)
+				{
+                    m.SendLocalizedMessage(1155509); // You lack the mana required to use this.
+				}
+				else
+				{
+                    m.FixedParticles(0x37C4, 1, 8, 9916, 39, 3, EffectLayer.CenterFeet);
+                    m.FixedParticles(0x37C4, 1, 8, 9502, 39, 4, EffectLayer.CenterFeet);
+                    m.PlaySound(0x210);
+					m.PrivateOverheadMessage(Network.MessageType.Regular, 1154, 1155499, m.NetState); // *You drive the spike into the ground!*
+					
+					Timer.DelayCall(TimeSpan.FromMilliseconds(250), () =>
+					{
+						if (m.Mana < 50) // Another mana check!
+						{
+                            m.SendLocalizedMessage(1155509); // You lack the mana required to use this.
+							return;
+						}
+
+                        m.Mana = 0;
+
+						battle.NextManaSpike = DateTime.UtcNow + TimeSpan.FromMinutes(5);
+						battle.ManaSpikeEndEffects = DateTime.UtcNow + TimeSpan.FromMinutes(2); // TODO: Duration?
+
+                        foreach (Mobile mobile in battle.Region.GetEnumeratedMobiles())
+						{
+                            if (ViceVsVirtueSystem.IsEnemy(mobile, m))
+                            {
+                                mobile.RevealingAction();
+
+                                mobile.BoltEffect(0);
+                                AOS.Damage(mobile, m, Utility.RandomMinMax(50, 75), 0, 0, 0, 0, 100);
+
+                                mobile.PrivateOverheadMessage(Network.MessageType.Regular, 1154, 1155498, mobile.NetState); // *Your body convulses as energy surges through it!*
+                            }
+						}
+
+                        Delete();
+					});
+				}
+			}
+			else
+			{
+				m.SendLocalizedMessage(1042004); // That must be in your pack for you to use it.
+			}
+		}
+
+        public static bool UnderEffects(Mobile m)
+        {
+            VvVBattle battle = ViceVsVirtueSystem.Instance.Battle;
+
+            if (battle != null && battle.OnGoing && battle.ManaSpikeEndEffects != DateTime.MinValue && battle.ManaSpikeEndEffects > DateTime.UtcNow)
+            {
+                m.PrivateOverheadMessage(Network.MessageType.Regular, 1154, 1155500, m.NetState); // *Your body is too charged with electrical energy to hide!*
+                return true;
+            }
+
+            return false;
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+		public ManaSpike(Serial serial) : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/MorphEarrings.cs

@@ -0,0 +1,98 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Factions;
+using Server.Engines.VvV;
+
+namespace Server.Items
+{
+    [TypeAlias("Server.Engines.VvV.MorphEarrings")]
+    public class MorphEarrings : GoldEarrings
+	{
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1094746; // Morph Earrings
+            }
+        }
+
+        [Constructable]
+        public MorphEarrings()
+        {
+        }
+
+        public override void OnRemoved(object parent)
+        {
+            base.OnRemoved(parent);
+
+            if (parent is Mobile)
+            {
+                ValidateEquipment((Mobile)parent);
+            }
+        }
+
+        private void ValidateEquipment(Mobile m)
+        {
+            if (m == null)
+                return;
+
+            Race race = m.Race;
+            bool didDrop = false;
+
+            List<Item> list = new List<Item>(m.Items);
+
+            foreach (Item item in list)
+            {
+                bool drop = false;
+
+                if (item is BaseArmor && ((BaseArmor)item).RequiredRace != null && ((BaseArmor)item).RequiredRace != race)
+                    drop = true;
+                else if (item is BaseWeapon && ((BaseWeapon)item).RequiredRace != null && ((BaseWeapon)item).RequiredRace != race)
+                    drop = true;
+                else if (item is BaseJewel && ((BaseJewel)item).RequiredRace != null && ((BaseJewel)item).RequiredRace != race)
+                    drop = true;
+                else if (item is BaseClothing && ((BaseClothing)item).RequiredRace != null && ((BaseClothing)item).RequiredRace != race)
+                    drop = true;
+
+                if (drop)
+                {
+                    if (!didDrop)
+                        didDrop = true;
+
+                    if (m.Backpack == null || !m.Backpack.TryDropItem(m, item, false))
+                    {
+                        m.BankBox.DropItem(item);
+                    }
+                }
+            }
+
+            ColUtility.Free(list);
+
+            if (didDrop)
+                m.SendLocalizedMessage(500647); // Some equipment has been moved to your backpack.
+        }
+
+        public MorphEarrings(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(1);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+
+            if (version == 0 && ViceVsVirtueSystem.Enabled)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Tiles/CovetousTile.cs

@@ -0,0 +1,114 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    public class CovetousTileAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new CovetousTileDeed(); } }
+
+        public TileType TileType { get; set; }
+
+        private int offset;
+
+        [Constructable]
+        public CovetousTileAddon(TileType type)
+        {
+            TileType = type;
+
+            offset = 0;
+
+            if (type != TileType.North)
+            {
+                offset = 4;
+            }
+
+            AddComponent(new AddonComponent(39372 + offset), 0, 0, 0);
+            AddComponent(new AddonComponent(39373 + offset), 1, 0, 0);
+            AddComponent(new AddonComponent(39374 + offset), 0, 1, 0);
+            AddComponent(new AddonComponent(39375 + offset), 1, 1, 0);
+        }
+
+        public CovetousTileAddon(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();
+        }
+    }
+
+    public class CovetousTileDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new CovetousTileAddon(TileType); } }
+        public override int LabelNumber { get { return 1155516; } } // Covetous Tile
+
+        public TileType TileType { get; set; }
+
+        [Constructable]
+        public CovetousTileDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public CovetousTileDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)TileType.North, "Covetous (North)");
+            list.Add((int)TileType.West, "Covetous (East)");
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            TileType = (TileType)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Tiles/DeceitTIle.cs

@@ -0,0 +1,114 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    public class DeceitTileAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new DeceitTileDeed(); } }
+
+        public TileType TileType { get; set; }
+
+        private int offset;
+
+        [Constructable]
+        public DeceitTileAddon(TileType type)
+        {
+            TileType = type;
+
+            offset = 0;
+
+            if (type != TileType.North)
+            {
+                offset = 4;
+            }
+
+            AddComponent(new AddonComponent(39380 + offset), 0, 0, 0);
+            AddComponent(new AddonComponent(39381 + offset), 1, 0, 0);
+            AddComponent(new AddonComponent(39382 + offset), 0, 1, 0);
+            AddComponent(new AddonComponent(39383 + offset), 1, 1, 0);
+        }
+
+        public DeceitTileAddon(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();
+        }
+    }
+
+    public class DeceitTileDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new DeceitTileAddon(TileType); } }
+        public override int LabelNumber { get { return 1155517; } } // Deceit Tile
+
+        public TileType TileType { get; set; }
+
+        [Constructable]
+        public DeceitTileDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public DeceitTileDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)TileType.North, "Deceit (North)");
+            list.Add((int)TileType.West, "Deceit (East)");
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            TileType = (TileType)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Tiles/DespiseTile.cs

@@ -0,0 +1,114 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    public class DespiseTileAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new DespiseTileDeed(); } }
+
+        public TileType TileType { get; set; }
+
+        private int offset;
+
+        [Constructable]
+        public DespiseTileAddon(TileType type)
+        {
+            TileType = type;
+
+            offset = 0;
+
+            if (type != TileType.North)
+            {
+                offset = 4;
+            }
+
+            AddComponent(new AddonComponent(39388 + offset), 0, 0, 0);
+            AddComponent(new AddonComponent(39389 + offset), 1, 0, 0);
+            AddComponent(new AddonComponent(39390 + offset), 0, 1, 0);
+            AddComponent(new AddonComponent(39391 + offset), 1, 1, 0);
+        }
+
+        public DespiseTileAddon(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();
+        }
+    }
+
+    public class DespiseTileDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new DespiseTileAddon(TileType); } }
+        public override int LabelNumber { get { return 1155518; } } // Despise Tile
+
+        public TileType TileType { get; set; }
+
+        [Constructable]
+        public DespiseTileDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public DespiseTileDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)TileType.North, "Despise (North)");
+            list.Add((int)TileType.West, "Despise (East)");
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            TileType = (TileType)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Tiles/DestardTile.cs

@@ -0,0 +1,114 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    public class DestardTileAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new DestardTileDeed(); } }
+
+        public TileType TileType { get; set; }
+
+        private int offset;
+
+        [Constructable]
+        public DestardTileAddon(TileType type)
+        {
+            TileType = type;
+
+            offset = 0;
+
+            if (type != TileType.North)
+            {
+                offset = 4;
+            }
+
+            AddComponent(new AddonComponent(39396 + offset), 0, 0, 0);
+            AddComponent(new AddonComponent(39397 + offset), 1, 0, 0);
+            AddComponent(new AddonComponent(39398 + offset), 0, 1, 0);
+            AddComponent(new AddonComponent(39399 + offset), 1, 1, 0);
+        }
+
+        public DestardTileAddon(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();
+        }
+    }
+
+    public class DestardTileDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new DestardTileAddon(TileType); } }
+        public override int LabelNumber { get { return 1155519; } } // Destard Tile
+
+        public TileType TileType { get; set; }
+
+        [Constructable]
+        public DestardTileDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public DestardTileDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)TileType.North, "Destard (North)");
+            list.Add((int)TileType.West, "Destard (East)");
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            TileType = (TileType)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Tiles/HythlothTIle.cs

@@ -0,0 +1,114 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    public class HythlothTileAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new HythlothTileDeed(); } }
+
+        public TileType TileType { get; set; }
+
+        private int offset;
+
+        [Constructable]
+        public HythlothTileAddon(TileType type)
+        {
+            TileType = type;
+
+            offset = 0;
+
+            if (type != TileType.North)
+            {
+                offset = 4;
+            }
+
+            AddComponent(new AddonComponent(39404 + offset), 0, 0, 0);
+            AddComponent(new AddonComponent(39405 + offset), 1, 0, 0);
+            AddComponent(new AddonComponent(39406 + offset), 0, 1, 0);
+            AddComponent(new AddonComponent(39407 + offset), 1, 1, 0);
+        }
+
+        public HythlothTileAddon(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();
+        }
+    }
+
+    public class HythlothTileDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new HythlothTileAddon(TileType); } }
+        public override int LabelNumber { get { return 1155520; } } // Hythloth Tile
+
+        public TileType TileType { get; set; }
+
+        [Constructable]
+        public HythlothTileDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public HythlothTileDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)TileType.North, "Hythloth (North)");
+            list.Add((int)TileType.West, "Hythloth (East)");
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            TileType = (TileType)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Tiles/PrideTile.cs

@@ -0,0 +1,114 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    public class PrideTileAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new PrideTileDeed(); } }
+
+        public TileType TileType { get; set; }
+
+        private int offset;
+
+        [Constructable]
+        public PrideTileAddon(TileType type)
+        {
+            TileType = type;
+
+            offset = 0;
+
+            if (type != TileType.North)
+            {
+                offset = 4;
+            }
+
+            AddComponent(new AddonComponent(39412 + offset), 0, 0, 0);
+            AddComponent(new AddonComponent(39413 + offset), 1, 0, 0);
+            AddComponent(new AddonComponent(39414 + offset), 0, 1, 0);
+            AddComponent(new AddonComponent(39415 + offset), 1, 1, 0);
+        }
+
+        public PrideTileAddon(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();
+        }
+    }
+
+    public class PrideTileDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new PrideTileAddon(TileType); } }
+        public override int LabelNumber { get { return 1155521; } } // Pride Tile
+
+        public TileType TileType { get; set; }
+
+        [Constructable]
+        public PrideTileDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public PrideTileDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)TileType.North, "Pride (North)");
+            list.Add((int)TileType.West, "Pride (East)");
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            TileType = (TileType)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Tiles/ShameTile.cs

@@ -0,0 +1,114 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    public class ShameTileAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new ShameTileDeed(); } }
+
+        public TileType TileType { get; set; }
+
+        private int offset;
+
+        [Constructable]
+        public ShameTileAddon(TileType type)
+        {
+            TileType = type;
+
+            offset = 0;
+
+            if (type != TileType.North)
+            {
+                offset = 4;
+            }
+
+            AddComponent(new AddonComponent(39420 + offset), 0, 0, 0);
+            AddComponent(new AddonComponent(39421 + offset), 1, 0, 0);
+            AddComponent(new AddonComponent(39422 + offset), 0, 1, 0);
+            AddComponent(new AddonComponent(39423 + offset), 1, 1, 0);
+        }
+
+        public ShameTileAddon(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();
+        }
+    }
+
+    public class ShameTileDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new ShameTileAddon(TileType); } }
+        public override int LabelNumber { get { return 1155522; } } // Shame Tile
+
+        public TileType TileType { get; set; }
+
+        [Constructable]
+        public ShameTileDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public ShameTileDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)TileType.North, "Shame (North)");
+            list.Add((int)TileType.West, "Shame (East)");
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            TileType = (TileType)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/Tiles/WrongTile.cs

@@ -0,0 +1,114 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+using Server.Gumps;
+
+namespace Server.Engines.VvV
+{
+    public class WrongTileAddon : BaseAddon
+    {
+        public override BaseAddonDeed Deed { get { return new WrongTileDeed(); } }
+
+        public TileType TileType { get; set; }
+
+        private int offset;
+
+        [Constructable]
+        public WrongTileAddon(TileType type)
+        {
+            TileType = type;
+
+            offset = 0;
+
+            if (type != TileType.North)
+            {
+                offset = 4;
+            }
+
+            AddComponent(new AddonComponent(39428 + offset), 0, 0, 0);
+            AddComponent(new AddonComponent(39428 + offset), 1, 0, 0);
+            AddComponent(new AddonComponent(39428 + offset), 0, 1, 0);
+            AddComponent(new AddonComponent(39428 + offset), 1, 1, 0);
+        }
+
+        public WrongTileAddon(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();
+        }
+    }
+
+    public class WrongTileDeed : BaseAddonDeed, IRewardOption
+    {
+        public override BaseAddon Addon { get { return new WrongTileAddon(TileType); } }
+        public override int LabelNumber { get { return 1155523; } } // Wrong Tile
+
+        public TileType TileType { get; set; }
+
+        [Constructable]
+        public WrongTileDeed()
+        {
+            LootType = LootType.Blessed;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.CloseGump(typeof(RewardOptionGump));
+                from.SendGump(new RewardOptionGump(this));
+            }
+            else
+                from.SendLocalizedMessage(1062334); // This item must be in your backpack to be used.       	
+        }
+
+        public WrongTileDeed(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();
+        }
+
+        public void GetOptions(RewardOptionList list)
+        {
+            list.Add((int)TileType.North, "Wrong (North)");
+            list.Add((int)TileType.West, "Wrong (East)");
+        }
+
+
+        public void OnOptionSelected(Mobile from, int choice)
+        {
+            TileType = (TileType)choice;
+
+            if (!Deleted)
+                base.OnDoubleClick(from);
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/VvVArms.cs

@@ -0,0 +1,171 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+
+namespace Server.Engines.VvV
+{
+    public class VvVWoodlandArms : WoodlandArms
+	{
+        public override int BasePhysicalResistance { get { return 15; } }
+        public override int BaseFireResistance { get { return 6; } }
+        public override int BaseColdResistance { get { return 17; } }
+        public override int BasePoisonResistance { get { return 18; } }
+        public override int BaseEnergyResistance { get { return 18; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        public VvVWoodlandArms()
+        {
+            Attributes.BonusDex = 4;
+            Attributes.BonusHits = 5;
+            Attributes.BonusStam = 10;
+            Attributes.RegenStam = 3;
+        }
+
+        public VvVWoodlandArms(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(1);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+		}
+	}
+
+    public class VvVDragonArms : DragonArms
+    {
+        public override int BasePhysicalResistance { get { return 15; } }
+        public override int BaseFireResistance { get { return 6; } }
+        public override int BaseColdResistance { get { return 17; } }
+        public override int BasePoisonResistance { get { return 18; } }
+        public override int BaseEnergyResistance { get { return 18; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        public VvVDragonArms()
+        {
+            Attributes.BonusDex = 4;
+            Attributes.BonusHits = 5;
+            Attributes.BonusStam = 10;
+            Attributes.RegenStam = 3;
+        }
+
+        public VvVDragonArms(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+        }
+    }
+
+    public class VvVGargishPlateArms : GargishPlateArms
+    {
+        public override int BasePhysicalResistance { get { return 15; } }
+        public override int BaseFireResistance { get { return 6; } }
+        public override int BaseColdResistance { get { return 17; } }
+        public override int BasePoisonResistance { get { return 18; } }
+        public override int BaseEnergyResistance { get { return 18; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        public VvVGargishPlateArms()
+        {
+            Attributes.BonusDex = 4;
+            Attributes.BonusHits = 5;
+            Attributes.BonusStam = 10;
+            Attributes.RegenStam = 3;
+        }
+
+        public VvVGargishPlateArms(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+        }
+    }
+
+    public class VvVPlateArms : PlateArms
+    {
+        public override int BasePhysicalResistance { get { return 15; } }
+        public override int BaseFireResistance { get { return 6; } }
+        public override int BaseColdResistance { get { return 17; } }
+        public override int BasePoisonResistance { get { return 18; } }
+        public override int BaseEnergyResistance { get { return 18; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        public VvVPlateArms()
+        {
+            Resource = CraftResource.None;
+
+            Attributes.BonusDex = 4;
+            Attributes.BonusHits = 5;
+            Attributes.BonusStam = 10;
+            Attributes.RegenStam = 3;
+        }
+
+        public VvVPlateArms(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/VvVChests.cs

@@ -0,0 +1,90 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+
+namespace Server.Engines.VvV
+{
+    public class VvVGargishStoneChest : GargishStoneChest
+    {
+        public override int BasePhysicalResistance { get { return 17; } }
+        public override int BaseFireResistance { get { return 19; } }
+        public override int BaseColdResistance { get { return 18; } }
+        public override int BasePoisonResistance { get { return 3; } }
+        public override int BaseEnergyResistance { get { return 6; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        public VvVGargishStoneChest()
+        {
+            AbsorptionAttributes.EaterEnergy = 15;
+            Attributes.BonusStr = 3;
+            Attributes.BonusStam = 10;
+            Attributes.RegenStam = 3;
+        }
+
+        public VvVGargishStoneChest(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+        }
+    }
+
+    public class VvVStuddedChest : StuddedChest
+    {
+        public override int BasePhysicalResistance { get { return 17; } }
+        public override int BaseFireResistance { get { return 19; } }
+        public override int BaseColdResistance { get { return 18; } }
+        public override int BasePoisonResistance { get { return 3; } }
+        public override int BaseEnergyResistance { get { return 6; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        public VvVStuddedChest()
+        {
+            AbsorptionAttributes.EaterEnergy = 15;
+            Attributes.BonusStr = 3;
+            Attributes.BonusStam = 10;
+            Attributes.RegenStam = 3;
+        }
+
+        public VvVStuddedChest(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/VvVEpaulettes.cs

@@ -0,0 +1,72 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+
+namespace Server.Engines.VvV
+{
+    public class VvVEpaulette : Epaulette
+	{
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        public VvVEpaulette()
+        {
+            Attributes.AttackChance = 5;
+        }
+
+        public VvVEpaulette(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(1);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+		}
+	}
+
+    public class VvVGargishEpaulette : GargishEpaulette
+    {
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        public VvVGargishEpaulette()
+        {
+            Attributes.AttackChance = 5;
+        }
+
+        public VvVGargishEpaulette(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/VvVHairDye.cs

@@ -0,0 +1,72 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+
+namespace Server.Engines.VvV
+{
+	public class VvVHairDye : Item
+	{
+        public override int LabelNumber
+        {
+            get
+            {
+                if (this.Hue == ViceVsVirtueSystem.VirtueHue)
+                    return 1155538;
+
+                return 1155539;
+            }
+        }
+
+        [Constructable]
+        public VvVHairDye(int hue)
+            : base(3838)
+        {
+            Hue = hue;
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (IsChildOf(m.Backpack))
+            {
+                if (ViceVsVirtueSystem.IsVvV(m))
+                {
+                    m.HairHue = this.Hue;
+                    m.FacialHairHue = this.Hue;
+
+                    Delete();
+                    m.PlaySound(0x4E);
+                    m.SendLocalizedMessage(501199);  // You dye your hair
+                }
+                else
+                {
+                    m.SendLocalizedMessage(1155496); // This item can only be used by VvV participants!
+                }
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public VvVHairDye(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/VvVHats.cs

@@ -0,0 +1,90 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+
+namespace Server.Engines.VvV
+{
+    public class VvVWizardsHat : WizardsHat
+	{
+        public override int BasePhysicalResistance { get { return 6; } }
+        public override int BaseFireResistance { get { return 6; } }
+        public override int BaseColdResistance { get { return 6; } }
+        public override int BasePoisonResistance { get { return 6; } }
+        public override int BaseEnergyResistance { get { return 25; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        public VvVWizardsHat()
+        {
+            Attributes.BonusHits = 5;
+            Attributes.RegenMana = 3;
+            Attributes.DefendChance = 4;
+            Attributes.SpellDamage = 10;
+            Attributes.LowerRegCost = 20;
+        }
+
+        public VvVWizardsHat(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(1);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+		}
+	}
+
+    public class VvVGargishEarrings : GargishEarrings
+    {
+        public override int BasePhysicalResistance { get { return 6; } }
+        public override int BaseFireResistance { get { return 6; } }
+        public override int BaseColdResistance { get { return 6; } }
+        public override int BasePoisonResistance { get { return 6; } }
+        public override int BaseEnergyResistance { get { return 25; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        public VvVGargishEarrings()
+        {
+            Attributes.BonusHits = 5;
+            Attributes.RegenMana = 3;
+            Attributes.DefendChance = 4;
+            Attributes.SpellDamage = 10;
+            Attributes.LowerRegCost = 20;
+        }
+
+        public VvVGargishEarrings(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/VvVPotions.cs

@@ -0,0 +1,614 @@
+using Server;
+using System;
+using Server.Items;
+using Server.Mobiles;
+using System.Collections.Generic;
+using Server.Factions;
+
+namespace Server.Engines.VvV
+{
+    public enum PotionType
+    {
+        None = 0x0,
+        AntiParalysis = 0x1,
+        Supernova = 0x2,
+        StatLossRemoval = 0x4,
+        GreaterStamina = 0x8,
+    }
+
+    public class VvVPotionKeg : Item
+    {
+        private PotionType _PotionType;
+        private int _Charges;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public PotionType PotionType { get { return _PotionType; } set { _PotionType = value; InvalidateProperties(); } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int Charges { get { return _Charges; } set { _Charges = value; if (_Charges <= 0) Delete(); else InvalidateProperties(); } }
+
+        public override double DefaultWeight
+        {
+            get
+            {
+                return 10 + _Charges * 1.8;
+            }
+        }
+
+        [Constructable]
+        public VvVPotionKeg(PotionType type)
+            : base(6870)
+        {
+            PotionType = type;
+            Charges = 10;
+
+            switch (type)
+            {
+                default:
+                case PotionType.AntiParalysis: Hue = 2543; break;
+                case PotionType.Supernova: Hue = 13; break;
+                case PotionType.StatLossRemoval: Hue = 2500; break;
+                case PotionType.GreaterStamina: Hue = 437; break;
+            }
+        }
+
+        public override void AddNameProperty(ObjectPropertyList list)
+        {
+            string str;
+
+            switch (_PotionType)
+            {
+                default:
+                case PotionType.AntiParalysis: str = "#1155543"; break;
+                case PotionType.Supernova: str = "#1094718"; break;
+                case PotionType.StatLossRemoval: str = "#1155541"; break;
+                case PotionType.GreaterStamina: str = "#1094764"; break;
+            }
+
+            list.Add(1155535, str); // A Batch of ~1_ITEMS~
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (IsChildOf(m.Backpack))
+            {
+                if (!ViceVsVirtueSystem.IsVvV(m))
+                {
+                    m.SendLocalizedMessage(1155496); // This item can only be used by VvV participants!
+                }
+                else
+                {
+                    Item potion = null;
+
+                    switch (_PotionType)
+                    {
+                        case PotionType.AntiParalysis: potion = new AntiParalysisPotion(); break;
+                        case PotionType.Supernova: potion = new SupernovaPotion(); break;
+                        case PotionType.StatLossRemoval: potion = new StatLossRemovalPotion(); break;
+                        case PotionType.GreaterStamina: potion = new GreaterStaminaPotion(); break;
+                    }
+
+                    if (potion != null)
+                    {
+                        m.SendLocalizedMessage(502242); // You pour some of the keg's contents into an empty bottle...
+
+                        if (m.Backpack == null || !m.Backpack.TryDropItem(m, potion, false))
+                        {
+                            m.SendLocalizedMessage(1155570); // Your backpack could not hold the item.  Free up some space and try again.
+                            potion.Delete();
+                        }
+                        else
+                        {
+                            m.SendLocalizedMessage(502243); // ...and place it into your backpack.
+                            m.PlaySound(0x240);
+
+                            Charges--;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                m.SendLocalizedMessage(1042004); // That must be in your pack for you to use it
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            
+            list.Add(1155569, Charges.ToString()); // Potions: ~1_val~
+            list.Add(1154937); // VvV Item
+        }
+
+        public VvVPotionKeg(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write((int)PotionType);
+            writer.Write(Charges);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            PotionType = (PotionType)reader.ReadInt();
+            Charges = reader.ReadInt();
+        }
+    }
+
+    public abstract class VvVPotion : Item, IFactionItem
+    {
+        #region Factions
+        private FactionItem m_FactionState;
+
+        public FactionItem FactionItemState
+        {
+            get { return m_FactionState; }
+            set
+            {
+                m_FactionState = value;
+            }
+        }
+        #endregion
+
+        public virtual TimeSpan CooldownDuration { get { return TimeSpan.MinValue; } }
+        public virtual PotionType CooldownType { get { return PotionType.None; } }
+
+        public static Dictionary<Mobile, Dictionary<PotionType, DateTime>> _Cooldown = new Dictionary<Mobile, Dictionary<PotionType, DateTime>>();
+
+        public static void RemoveFromCooldown(Mobile m, PotionType type)
+        {
+            if (_Cooldown.ContainsKey(m) && _Cooldown[m].ContainsKey(type))
+            {
+                _Cooldown[m].Remove(type);
+
+                if (_Cooldown[m].Count == 0)
+                    _Cooldown.Remove(m);
+            }
+        }
+
+        public static void CheckCooldown()
+        {
+            List<Mobile> toRemove = new List<Mobile>();
+
+            foreach (KeyValuePair<Mobile, Dictionary<PotionType, DateTime>> kvp in _Cooldown)
+            {
+                List<PotionType> removeTypes = new List<PotionType>();
+
+                foreach (KeyValuePair<PotionType, DateTime> values in kvp.Value)
+                {
+                    if (values.Value < DateTime.UtcNow)
+                        removeTypes.Add(values.Key);
+                }
+
+                foreach (PotionType t in removeTypes)
+                    kvp.Value.Remove(t);
+
+                if (kvp.Value.Count == 0)
+                    toRemove.Add(kvp.Key);
+
+                removeTypes.Clear();
+                removeTypes.TrimExcess();
+            }
+
+            foreach (Mobile mob in toRemove)
+                _Cooldown.Remove(mob);
+
+            toRemove.Clear();
+            toRemove.TrimExcess();
+        }
+
+        public override int LabelNumber
+        {
+            get
+            {
+                switch (CooldownType)
+                {
+                    case PotionType.AntiParalysis: return 1155543;
+                    case PotionType.Supernova: return 1094718;
+                    case PotionType.StatLossRemoval: return 1155541;
+                    case PotionType.GreaterStamina: return 1094764;
+                }
+
+                return base.LabelNumber;
+            }
+        }
+
+        public VvVPotion()
+            : base(3849)
+        {
+            Stackable = true;
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            if (!FactionEquipment.AddFactionProperties(this, list))
+            {
+                list.Add(1154937); // VvV Item
+            }
+        }
+
+        public bool IsInCooldown(Mobile m, ref DateTime dt)
+        {
+            if (_Cooldown.ContainsKey(m))
+            {
+                if (_Cooldown[m].ContainsKey(PotionType.GreaterStamina))
+                {
+                    dt = _Cooldown[m][PotionType.GreaterStamina];
+
+                    if (dt < DateTime.UtcNow)
+                    {
+                        RemoveFromCooldown(m, PotionType.GreaterStamina);
+                        return false;
+                    }
+
+                    return true;
+                }
+
+                if (_Cooldown[m].ContainsKey(CooldownType))
+                {
+                    dt = _Cooldown[m][CooldownType];
+
+                    if (dt < DateTime.UtcNow)
+                    {
+                        RemoveFromCooldown(m, CooldownType);
+                        return false;
+                    }
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public void AddToCooldown(Mobile m)
+        {
+            if (!_Cooldown.ContainsKey(m))
+                _Cooldown[m] = new Dictionary<PotionType, DateTime>();
+
+            _Cooldown[m][CooldownType] = DateTime.UtcNow + CooldownDuration;
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (!Movable)
+                return;
+
+            if (IsChildOf(m.Backpack))
+            {
+                DateTime dt = DateTime.UtcNow;
+
+                if (ViceVsVirtueSystem.Enabled && !ViceVsVirtueSystem.IsVvV(m))
+                {
+                    m.SendLocalizedMessage(1155496); // This item can only be used by VvV participants!
+                }
+                else if (Server.Factions.Settings.Enabled && !FactionEquipment.CanUse(this, m))
+                {
+                }
+                else if (!BasePotion.HasFreeHand(m))
+                {
+                    m.SendLocalizedMessage(502172); // You must have a free hand to drink a potion.
+                }
+                else if (IsInCooldown(m, ref dt))
+                {
+                    TimeSpan left = dt - DateTime.UtcNow;
+
+                    if (left.TotalMinutes > 2)
+                    {
+                        m.SendLocalizedMessage(1114110, ((int)left.TotalMinutes).ToString()); // You must wait ~1_minutes~ minutes before using another one of these.
+                    }
+                    else
+                    {
+                        m.SendLocalizedMessage(1114109, ((int)left.TotalSeconds).ToString()); // You must wait ~1_seconds~ seconds before using another one of these.
+                    }
+                }
+                else if (CheckUse(m))
+                {
+                    UseEffects(m);
+                    Use(m);
+                }
+            }
+            else
+            {
+                m.SendLocalizedMessage(1042004); // That must be in your pack for you to use it
+            }
+        }
+
+        public virtual bool CheckUse(Mobile m)
+        {
+            return true;
+        }
+
+        public abstract void Use(Mobile m);
+
+        public virtual void UseEffects(Mobile m)
+        {
+            m.RevealingAction();
+            m.PlaySound(0x2D6);
+
+            if (m.Body.IsHuman && !m.Mounted)
+                m.Animate(34, 5, 1, true, false, 0);
+
+            if (CooldownDuration != TimeSpan.MinValue)
+            {
+                AddToCooldown(m);
+            }
+
+            Timer.DelayCall<Mobile>(TimeSpan.FromMilliseconds(500), DrinkEffects, m);
+        }
+
+        public virtual void DrinkEffects(Mobile m)
+        {
+        }
+
+        public VvVPotion(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class AntiParalysisPotion : VvVPotion
+    {
+        public override PotionType CooldownType { get { return PotionType.AntiParalysis; } }
+
+        [Constructable]
+        public AntiParalysisPotion()
+        {
+            Hue = 2543;
+        }
+
+        public override bool CheckUse(Mobile m)
+        {
+            if (!m.Paralyzed)
+            {
+                m.SendLocalizedMessage(1155544); // You are not currently paralyzed
+                return false;
+            }
+
+            return true;
+        }
+
+        public override void Use(Mobile m)
+        {
+            m.Paralyzed = false;
+            m.Stam /= 2;
+
+            Consume();
+        }
+
+        public override void DrinkEffects(Mobile m)
+        {
+            m.FixedEffect(0x375A, 10, 15);
+            m.PlaySound(0x1E7);
+        }
+
+        public AntiParalysisPotion(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class SupernovaPotion : VvVPotion
+    {
+        public override TimeSpan CooldownDuration { get { return TimeSpan.FromMinutes(2); } }
+        public override PotionType CooldownType { get { return PotionType.Supernova; } }
+
+        [Constructable]
+        public SupernovaPotion()
+        {
+            Hue = 13;
+        }
+
+        public override void Use(Mobile m)
+        {
+            Effects.SendMovingEffect(m, new Entity(Serial.Zero, new Point3D(m.X, m.Y, m.Z + 25), m.Map), this.ItemID, 3, 0, false, false, this.Hue, 0);
+            
+            int count = 5;
+
+            Timer.DelayCall(TimeSpan.FromSeconds(1), () =>
+                {
+                    m.PlaySound(0x1DD);
+
+                    for (int i = 0; i < count; i++)
+                    {
+                        Timer.DelayCall(TimeSpan.FromMilliseconds(i * 170), index =>
+                            {
+                                Server.Misc.Geometry.Circle2D(m.Location, m.Map, index, (pnt, map) =>
+                                {
+                                    Effects.SendLocationEffect(pnt, map, 0x3709, 30, 10, 0, 5);
+                                });
+                            }, i);
+                    }
+                });
+
+            Timer.DelayCall(TimeSpan.FromMilliseconds(170 * count), () =>
+                {
+                    IPooledEnumerable eable = m.Map.GetMobilesInRange(m.Location, count);
+
+                    foreach (Mobile mob in eable)
+                    {
+                        if (mob != m && Server.Spells.SpellHelper.ValidIndirectTarget(m, mob) && m.CanBeHarmful(mob, false))
+                        {
+                            m.DoHarmful(mob);
+                            AOS.Damage(mob, m, Utility.RandomMinMax(40, 60), 0, 100, 0, 0, 0);
+                        }
+                    }
+
+                    eable.Free();
+                });
+
+            if (m.AccessLevel == AccessLevel.Player)
+                Consume();
+        }
+
+        public override void UseEffects(Mobile m)
+        {
+            AddToCooldown(m);
+        }
+
+        public SupernovaPotion(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class StatLossRemovalPotion : VvVPotion
+    {
+        public override TimeSpan CooldownDuration { get { return TimeSpan.FromMinutes(20); } }
+        public override PotionType CooldownType { get { return PotionType.StatLossRemoval; } }
+
+        [Constructable]
+        public StatLossRemovalPotion()
+        {
+            Hue = 2500;
+        }
+
+        public override bool CheckUse(Mobile m)
+        {
+            if (!Server.Factions.Faction.InSkillLoss(m))
+            {
+                m.SendLocalizedMessage(1155542); // You are not currently under the effects of stat loss.
+                return false;
+            }
+
+            return true;
+        }
+
+        public override void Use(Mobile m)
+        {
+            m.SendLocalizedMessage(1155540); // You feel the effects of your stat loss fade.
+            Server.Factions.Faction.ClearSkillLoss(m);
+
+            Consume();
+        }
+
+        public override void DrinkEffects(Mobile m)
+        {
+            m.PlaySound(0xF6);
+            m.PlaySound(0x1F7);
+            m.FixedParticles(0x3709, 1, 30, 9963, 13, 3, EffectLayer.Head);
+        }
+
+        public StatLossRemovalPotion(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GreaterStaminaPotion : VvVPotion
+    {
+        public override TimeSpan CooldownDuration { get { return TimeSpan.FromSeconds(10); } }
+        public override PotionType CooldownType { get { return PotionType.GreaterStamina; } }
+
+        [Constructable]
+        public GreaterStaminaPotion()
+        {
+            Hue = 437;
+        }
+
+        public override bool CheckUse(Mobile m)
+        {
+            //TODO: Message?  Stam check?
+            return true;
+        }
+
+        public override void Use(Mobile m)
+        {
+            Timer.DelayCall(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), 10, () =>
+            {
+                int gain = Utility.RandomMinMax(10, 13);
+
+                if (m.Stam + gain > m.StamMax)
+                    gain = m.StamMax - m.Stam;
+
+                m.FixedParticles(0x376A, 9, 32, 5005, EffectLayer.Waist);
+                m.Stam += gain;
+            });
+
+            Consume();
+        }
+
+        public override void DrinkEffects(Mobile m)
+        {
+            m.FixedEffect(0x375A, 10, 15);
+            m.PlaySound(0x1E7);
+        }
+
+        public GreaterStaminaPotion(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/VvVRobe.cs

@@ -0,0 +1,51 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Items;
+
+namespace Server.Engines.VvV
+{
+    public class VvVRobe : BaseOuterTorso
+	{
+        public override int LabelNumber
+        {
+            get
+            {
+                if (this.Hue == ViceVsVirtueSystem.VirtueHue)
+                    return 1155532;
+
+                if (this.Hue == ViceVsVirtueSystem.ViceHue)
+                    return 1155533;
+
+                return base.LabelNumber;
+            }
+        }
+
+        [Constructable]
+        public VvVRobe(int hue)
+            : base(0x2684, hue)
+        {
+        }
+
+        public VvVRobe(Serial serial)
+            : base(serial)
+		{
+		}
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+        }
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/VvVSteeds.cs

@@ -0,0 +1,329 @@
+using Server;
+using System;
+using Server.Items;
+using Server.Mobiles;
+using System.Collections.Generic;
+
+namespace Server.Engines.VvV
+{
+	public enum SteedType 
+	{
+		Ostard, 
+		WarHorse
+	}
+
+    public class VvVSteedStatuette : BaseImprisonedMobile
+	{
+		[CommandProperty(AccessLevel.GameMaster)]
+		public SteedType SteedType { get; set; }
+
+        public override BaseCreature Summon
+        {
+            get
+            {
+                switch (this.SteedType)
+                {
+                    default:
+                    case SteedType.Ostard: return new VvVMount("a war ostard", 0xDA, 0x3EA4, this.Hue);
+                    case SteedType.WarHorse: return new VvVMount("a war horse", 0xE2, 0x3EA0, this.Hue);
+                }
+            }
+        }
+
+		[Constructable]
+		public VvVSteedStatuette(SteedType mounttype, int hue) 
+            : base(mounttype == SteedType.Ostard ? 8501 : 8484)
+		{
+            Hue = hue;
+            SteedType = mounttype;
+		}
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1154937); // vvv item
+        }
+
+        public override void OnDoubleClick(Mobile m)
+        {
+            if (!ViceVsVirtueSystem.IsVvV(m))
+            {
+                m.SendLocalizedMessage(1155496); // This item can only be used by VvV participants!
+                return;
+            }
+
+            base.OnDoubleClick(m);
+        }
+		
+		public VvVSteedStatuette(Serial serial) : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+			
+			writer.Write((int)SteedType);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+			
+			SteedType = (SteedType)reader.ReadInt();
+		}
+	}
+	
+	public class VvVMount : BaseMount
+	{
+		private int _Readiness;
+		
+		[CommandProperty(AccessLevel.GameMaster)]
+		public int BattleReadiness
+		{
+			get { return _Readiness; }
+			set
+			{
+				int old = _Readiness;
+				_Readiness = value;
+				
+				if(_Readiness > 20)
+					_Readiness = 20;
+				
+				if(old != value && ControlMaster != null && ControlMaster.NetState != null)
+				{
+					int cliloc;
+					
+					if(old > value)
+					{
+						if(_Readiness < 5)
+							cliloc = 1155551; // *Your steed's battle readiness is dangerously low!*
+						else
+							cliloc = 1155549; // *Your steed's battle readiness is fading...*
+					}
+					else
+					{
+						if(_Readiness == 20)
+							cliloc = 1155553; // *Your steed is at maximum battle readiness!*
+						else
+							cliloc = 1155552;// *Your steed's battle readiness has increased!*
+					}
+					
+					Timer.DelayCall(TimeSpan.FromSeconds(1), () =>
+					{
+                        if(!Deleted && ControlMaster != null)
+						    ControlMaster.PrivateOverheadMessage(Server.Network.MessageType.Regular, 1154, cliloc, ControlMaster.NetState);
+					});
+				}
+				
+				if(_Readiness <= 0)
+					GoPoof();
+			}
+		}
+		
+		[CommandProperty(AccessLevel.GameMaster)]
+		public DateTime NextReadinessAtrophy { get; set; }
+
+        public override bool DeleteOnRelease { get { return true; } }
+
+		public VvVMount(string name, int id, int itemid, int hue) 
+			: base(name, id, itemid, AIType.AI_Animal, FightMode.Aggressor, 10, 1, 0.4, .2)
+		{
+			Hue = hue;
+			
+            if(id == 0xDA)
+                BaseSoundID = 0x275;
+            else
+                BaseSoundID = 0xA8;
+
+			this.InitStats(Utility.Random(300, 100), 125, 60);
+
+            SetStr(400);
+            SetDex(125);
+            SetInt(51, 55);
+
+            SetHits(240);
+            SetMana(0);
+
+            SetDamage(5, 8);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 40, 50);
+            SetResistance(ResistanceType.Fire, 30, 40);
+            SetResistance(ResistanceType.Cold, 30, 40);
+            SetResistance(ResistanceType.Poison, 30, 40);
+            SetResistance(ResistanceType.Energy, 30, 40);
+
+            SetSkill(SkillName.MagicResist, 25.1, 30.0);
+            SetSkill(SkillName.Tactics, 29.3, 44.0);
+            SetSkill(SkillName.Wrestling, 29.3, 44.0);
+
+            Fame = 300;
+            Karma = 300;
+
+            Tamable = true;
+            ControlSlots = 1;
+            MinTameSkill = 29.1;
+			
+			_Readiness = 8;
+			NextReadinessAtrophy = DateTime.UtcNow + TimeSpan.FromHours(24);
+			
+			Steeds.Add(this);
+		}
+		
+		public void GoPoof()
+		{
+			if(Rider != null)
+			{
+				Rider = null;
+			}
+			
+			if(ControlMaster != null && ControlMaster.NetState != null)
+				ControlMaster.PrivateOverheadMessage(Server.Network.MessageType.Regular, 1154, 1155550, ControlMaster.NetState); // *Your steed has depleted it's battle readiness!*
+			
+			Delete();
+		}
+		
+		public override void OnDeath(Container c)
+		{
+			base.OnDeath(c);
+
+            if (BattleReadiness > 1)
+                BattleReadiness--;
+		}
+		
+		public override bool OnDragDrop(Mobile from, Item dropped)
+		{
+			if(from == ControlMaster && dropped is EssenceOfCourage)
+			{
+				EssenceOfCourage ec = dropped as EssenceOfCourage;
+                BattleReadiness += dropped.Amount;
+
+                dropped.Delete();
+
+                if (Body.IsAnimal)
+                {
+                    Animate(3, 5, 1, true, false, 0);
+                }
+                else if (Body.IsMonster)
+                {
+                    Animate(17, 5, 1, true, false, 0);
+                }
+
+				return true;
+			}
+			
+			return base.OnDragDrop(from, dropped);
+		}
+		
+		public override void Delete()
+		{
+			base.Delete();
+			
+			Steeds.Remove(this);
+		}
+
+        public override bool CanTransfer(Mobile m)
+        {
+            if (ControlMaster != null && ControlMaster.NetState != null)
+                ControlMaster.SendLocalizedMessage(1155547); // Pets obtained from VvV are non-transferable.
+
+            return false;
+        }
+
+        public override bool CanFriend(Mobile m)
+        {
+            if (ControlMaster != null && ControlMaster.NetState != null)
+                ControlMaster.SendLocalizedMessage(1155548); // You may not add friends to a VvV War Steed.
+
+            return false;
+        }
+
+        public override int Meat
+        {
+            get
+            {
+                return 3;
+            }
+        }
+
+        public override int Hides
+        {
+            get
+            {
+                return 10;
+            }
+        }
+
+        public override FoodType FavoriteFood
+        {
+            get
+            {
+                if (Body == 0xDA)
+                {
+                    return FoodType.Meat | FoodType.Fish | FoodType.Eggs | FoodType.FruitsAndVegies;
+                }
+                else
+                {
+                    return FoodType.FruitsAndVegies | FoodType.GrainsAndHay;
+                }
+            }
+        }
+		
+		public VvVMount(Serial serial) : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+			
+			writer.Write(_Readiness);
+			writer.Write(NextReadinessAtrophy);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+			
+			_Readiness = reader.ReadInt();
+			NextReadinessAtrophy = reader.ReadDateTime();
+			
+			Steeds.Add(this);
+		}
+		
+		public static List<VvVMount> Steeds { get; set; }
+		
+		public static void Configure()
+		{
+			Steeds = new List<VvVMount>();
+		}
+		
+		public static void Initialize()
+		{
+			Timer.DelayCall(TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(10), () =>
+			{
+                List<VvVMount> steeds = new List<VvVMount>(Steeds);
+
+				steeds.ForEach(s =>
+				{
+					if((s.Map != Map.Internal || (s.Rider != null && s.Rider.Map != Map.Internal)) && s.NextReadinessAtrophy < DateTime.UtcNow)
+					{
+						s.BattleReadiness--;
+						
+						if(!s.Deleted)
+							s.NextReadinessAtrophy = DateTime.UtcNow + TimeSpan.FromHours(24);
+					}
+				});
+				
+				steeds.Clear();
+				steeds.TrimExcess();
+			});
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/VvVTrapKit.cs

@@ -0,0 +1,253 @@
+using Server;
+using System;
+using Server.Items;
+using Server.Mobiles;
+using System.Collections.Generic;
+using Server.Targeting;
+using Server.ContextMenus;
+using System.Linq;
+
+namespace Server.Engines.VvV
+{
+	public class VvVTrapKit : Item
+	{
+        [CommandProperty(AccessLevel.GameMaster)]
+		public DeploymentType DeploymentType { get; set;}
+
+        [CommandProperty(AccessLevel.GameMaster)]
+		public VvVTrapType TrapType { get; set; }
+		
+		public override int LabelNumber { get { return 1154944; } } // Trap Kit
+		
+		private static Dictionary<Mobile, DateTime> _Cooldown = new Dictionary<Mobile, DateTime>();
+		
+		[Constructable]
+		public VvVTrapKit(VvVTrapType type) : base(7866)
+		{
+			TrapType = type;
+            DeploymentType = DeploymentType.Proximaty;
+		}
+		
+		public override void OnDoubleClick(Mobile from)
+		{
+			CheckCooldown();
+			
+			if(IsChildOf(from.Backpack))
+			{
+				ViceVsVirtueSystem sys = ViceVsVirtueSystem.Instance;
+				
+				if(sys != null)
+				{
+					if(!ViceVsVirtueSystem.IsVvV(from))
+					{
+						from.SendLocalizedMessage(1155415); // Only participants in Vice vs Virtue may use this item.
+					}
+					else if(!sys.Battle.OnGoing || !from.Region.IsPartOf(sys.Battle.Region))
+					{
+						from.SendLocalizedMessage(1155406); // This item can only be used in an active VvV battle region!
+					}
+					else if (sys.Battle.TrapCount >= VvVBattle.MaxTraps)
+					{
+						from.SendLocalizedMessage(1155407); // The trap limit for this battle has been reached!
+					}
+					else if (_Cooldown != null && _Cooldown.ContainsKey(from))
+					{
+						from.SendLocalizedMessage(1155408); // You must wait a few moments before attempting to place another trap.
+					}
+					else
+					{
+						from.SendLocalizedMessage(1155409); // Where do you want to place the trap?
+						from.BeginTarget(2, true, Server.Targeting.TargetFlags.None, (m, targeted) =>
+						{
+							IPoint3D p = targeted as IPoint3D;
+							
+							if(p != null)
+							{
+                                if (!sys.Battle.OnGoing || !m.Region.IsPartOf(sys.Battle.Region))
+								{
+									m.SendLocalizedMessage(1155406); // This item can only be used in an active VvV battle region!
+								}
+								else if (sys.Battle.Traps.Count >= VvVBattle.MaxTraps)
+								{
+									m.SendLocalizedMessage(1155407); // The trap limit for this battle has been reached!
+								}
+								else if (!from.InLOS(p))
+								{
+									m.SendLocalizedMessage(1042261); // You cannot place the trap there.
+								}
+								else
+								{
+									TryDeployTrap(m, new Point3D(p));
+								}
+							}
+							else
+								m.SendLocalizedMessage(1042261); // You cannot place the trap there.
+						});
+					}
+				}
+			}
+			else
+			{
+				from.SendLocalizedMessage(1042004); // That must be in your pack for you to use it
+			}
+		}
+		
+		public void TryDeployTrap(Mobile m, Point3D trapLocation)
+		{
+			VvVTrap trap = null;
+			
+			if(this.DeploymentType == DeploymentType.Tripwire)
+			{
+				m.SendLocalizedMessage(1155410); // Target the location to run the tripwire...
+				m.BeginTarget(5, true, TargetFlags.None, (from, targeted) =>
+				{
+					IPoint3D p = targeted as IPoint3D;
+					
+					if(p != null)
+					{
+						Point3D point = new Point3D(p);
+						
+						//TODO: Rules?  For now, must be within 3 tiles of trap
+                        if (!Utility.InRange(point, trapLocation, 3) || point == trapLocation)
+						{
+							m.SendLocalizedMessage(1011577); // This is an invalid location.
+						}
+						else
+						{
+							trap = ConstructTrap(m);
+
+                            if (!trap.SetTripwire(this, trapLocation, point, m.Map))
+                            {
+                                trap.Delete();
+                                m.SendLocalizedMessage(1042261); // You cannot place the trap there.
+                                return;
+                            }
+                            else
+                            {
+                                m.PrivateOverheadMessage(Server.Network.MessageType.Regular, 1154, 1155411, m.NetState); // *You successfully lay the tripwire*
+                            }
+						}
+					}
+					else
+					{
+						m.SendLocalizedMessage(1042261); // You cannot place the trap there.
+					}
+				});
+			}
+			else
+			{
+				m.PrivateOverheadMessage(Server.Network.MessageType.Regular, 1154, 1155412, m.NetState); // *You successfully set the trap*
+				trap = ConstructTrap(m);
+			}
+			
+			if(trap != null)
+			{
+				trap.MoveToWorld(trapLocation, m.Map);
+				Delete();
+
+                ViceVsVirtueSystem.Instance.Battle.Traps.Add(trap);
+
+				AddToCooldown(m);
+			}
+		}
+		
+		private void AddToCooldown(Mobile m)
+		{
+			_Cooldown[m] = DateTime.UtcNow + TimeSpan.FromSeconds(30);
+		}
+		
+		private void CheckCooldown()
+		{
+			if(_Cooldown.Count == 0)
+				return;
+			
+			List<Mobile> mobs = new List<Mobile>(_Cooldown.Keys);
+			
+			foreach(Mobile m in mobs.Where(mob => _Cooldown[mob] < DateTime.UtcNow))
+			{
+				_Cooldown.Remove(m);
+			}
+
+            mobs.Clear();
+            mobs.TrimExcess();
+		}
+		
+		public VvVTrap ConstructTrap(Mobile m)
+		{
+			switch(this.TrapType)
+			{
+				case VvVTrapType.Explosion: return new VvVExplosionTrap(m, this.DeploymentType);
+				case VvVTrapType.Poison: return new VvVPoisonTrap(m, this.DeploymentType);
+				case VvVTrapType.Cold: return new VvVColdTrap(m, this.DeploymentType);
+				case VvVTrapType.Energy: return new VvVEnergyTrap(m, this.DeploymentType);
+				case VvVTrapType.Blade: return new VvVBladeTrap(m, this.DeploymentType);
+			}
+			
+			return null;
+		}
+		
+		public override void GetContextMenuEntries(Mobile m, List<ContextMenuEntry> list)
+		{
+			list.Add(new InternalEntry(this, m));
+		}
+		
+		public override void GetProperties(ObjectPropertyList list)
+		{
+			base.GetProperties(list);
+			
+			list.Add(1154938, String.Format("#{0}", ((int)this.DeploymentType).ToString())); // Deployment Type: ~1_DEPLOYTYPE~
+			list.Add(1154941, String.Format("#{0}", ((int)this.TrapType).ToString())); // Damage Type: ~1_DMGTYPE~
+            list.Add(1154937); // VvV Item
+		}
+
+        private class InternalEntry : ContextMenuEntry
+        {
+            public VvVTrapKit Deed { get; set; }
+            public Mobile Clicker { get; set; }
+
+            public InternalEntry(VvVTrapKit deed, Mobile m)
+                : base(1155514, -1)
+            {
+                Deed = deed;
+                Clicker = m;
+
+                if (!Deed.IsChildOf(m.Backpack))
+                    Enabled = false;
+            }
+
+            public override void OnClick()
+            {
+                if (Deed.DeploymentType == DeploymentType.Proximaty)
+                    Deed.DeploymentType = DeploymentType.Tripwire;
+                else
+                    Deed.DeploymentType = DeploymentType.Proximaty;
+
+                Deed.InvalidateProperties();
+
+                Clicker.PrivateOverheadMessage(Server.Network.MessageType.Regular, 1154, 1155515, Clicker.NetState); // *You adjust the deployment mechanism*
+            }
+        }
+		
+		public VvVTrapKit(Serial serial) : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+
+            writer.Write((int)DeploymentType);
+            writer.Write((int)TrapType);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+
+            DeploymentType = (DeploymentType)reader.ReadInt();
+            TrapType = (VvVTrapType)reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/VvVTraps.cs

@@ -0,0 +1,457 @@
+using Server;
+using System;
+using Server.Items;
+using Server.Mobiles;
+using System.Collections.Generic;
+using Server.Spells;
+using Server.Spells.Necromancy;
+
+namespace Server.Engines.VvV
+{
+	public enum VvVTrapType
+	{
+		Explosion 	= 1015027, // Explosion
+		Poison 		= 1028000, // Poison
+		Cold 		= 1113466, // Freezing
+		Energy 		= 1154942, // Shocking
+		Blade 		= 1154943, // Blades
+	}
+	
+	public enum DeploymentType
+	{
+		Proximaty = 1154939,
+		Tripwire = 1154940
+	}
+
+    public class VvVTrap : Item, IRevealableItem
+	{
+        [CommandProperty(AccessLevel.GameMaster)]
+		public Mobile Owner { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public DeploymentType DeploymentType { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public VvVTrap ParentTrap { get; set; }
+
+        public List<VvVTrap> Links { get; set; }
+		
+		public override bool HandlesOnMovement { get { return true; } }
+        public bool CheckWhenHidden { get { return true; } }
+
+		public virtual int MinDamage { get { return 0; } }
+		public virtual int MaxDamage { get { return 0; } }
+        public virtual VvVTrapType TrapType { get { return VvVTrapType.Explosion; } }
+
+        public static int HiddenID = 8600;
+        public static int VisibleID = 39818;
+
+		public VvVTrap(Mobile owner, DeploymentType type) : base(HiddenID)
+		{
+			Owner = owner;
+			DeploymentType = type;
+			
+			Movable = false;
+            Hue = 0x3D8;
+		}
+		
+		public bool SetTripwire(VvVTrapKit deed, Point3D myLocation, Point3D wireLocation, Map map)
+		{
+            Links = new List<VvVTrap>();
+
+			MovementPath path = new MovementPath(myLocation, wireLocation, map);
+			int x = myLocation.X;
+            int y = myLocation.Y;
+			
+			if(path.Success)
+			{
+				for (int i = 0; i < path.Directions.Length; ++i)
+				{
+					Movement.Movement.Offset(path.Directions[i], ref x, ref y);
+
+                    Point3D p = new Point3D(x, y, this.Map.GetAverageZ(x, y));
+
+                    if (p == myLocation)
+                        continue;
+
+                    VvVTrap trap = deed.ConstructTrap(Owner);
+                    Links.Add(trap);
+                    trap.ParentTrap = this;
+
+                    trap.MoveToWorld(p, map);
+				}
+				
+				return true;
+			}
+			
+			return false;
+		}
+		
+		public override void OnMovement(Mobile m, Point3D oldLocation)
+        {
+			if(IsEnemy(m) && DeploymentType == DeploymentType.Proximaty && m.InRange(this.Location, 3) && ViceVsVirtueSystem.IsEnemy(m, Owner))
+			{
+				Detonate(m);
+			}
+		}
+
+        public bool CheckReveal(Mobile m)
+        {
+            if (!ViceVsVirtueSystem.IsVvV(m) || ItemID != VvVTrap.HiddenID)
+                return false;
+
+            return Utility.Random(100) <= m.Skills[SkillName.DetectHidden].Value;
+        }
+
+        public void OnRevealed(Mobile m)
+        {
+            ItemID = VisibleID;
+
+            if (Links != null)
+            {
+                Links.ForEach(l =>
+                    {
+                        if (!l.Deleted && l.ItemID == HiddenID)
+                            l.ItemID = VisibleID;
+                    });
+            }
+
+            if (ParentTrap != null)
+            {
+                if (ParentTrap.ItemID == HiddenID)
+                    ParentTrap.ItemID = VisibleID;
+
+                ParentTrap.OnRevealed(m);
+            }
+        }
+
+        public bool CheckPassiveDetect(Mobile m)
+        {
+            if (m.InRange(this.Location, 6))
+            {
+                int skill = (int)m.Skills[SkillName.DetectHidden].Value;
+
+                if (skill >= 80 && Utility.Random(600) < skill)
+                    this.PrivateOverheadMessage(Server.Network.MessageType.Regular, 0x21, 500813, m.NetState); // [trapped]
+            }
+
+            return false;
+        }
+		
+		public override bool OnMoveOver(Mobile m)
+		{
+			if(IsEnemy(m))
+			{
+				Detonate(m);
+			}
+			
+			return base.OnMoveOver(m);
+		}
+		
+		public bool IsEnemy(Mobile m)
+		{
+			if(Owner == null)
+				return true;
+		
+			return ViceVsVirtueSystem.IsVvV(m) && ViceVsVirtueSystem.IsVvV(Owner) && ViceVsVirtueSystem.IsEnemy(m, Owner);
+		}
+		
+		public virtual void Detonate(Mobile m)
+		{
+            if(Owner != null)
+                Owner.DoHarmful(m);
+
+            Delete();
+		}
+
+        public override void Delete()
+        {
+            base.Delete();
+
+            if (Links != null)
+            {
+                Links.ForEach(l =>
+                    {
+                        if (!l.Deleted)
+                            l.Delete();
+                    });
+            }
+
+            if (ParentTrap != null && !ParentTrap.Deleted)
+                ParentTrap.Delete();
+        }
+
+		public VvVTrap(Serial serial) : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+			
+			writer.Write(Owner);
+			writer.Write((int)DeploymentType);
+
+            writer.Write(Links != null ? Links.Count : 0);
+
+            if (Links != null)
+            {
+                Links.ForEach(l => writer.Write(l));
+            }
+
+            writer.Write(ParentTrap);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+			
+			Owner = reader.ReadMobile();
+			DeploymentType = (DeploymentType)reader.ReadInt();
+
+            int count = reader.ReadInt();
+
+            for (int i = 0; i < count; i++)
+            {
+                if(Links == null)
+                    Links = new List<VvVTrap>();
+
+                VvVTrap link = reader.ReadItem() as VvVTrap;
+
+                if (link != null)
+                    Links.Add(link);
+            }
+
+            ParentTrap = reader.ReadItem() as VvVTrap;
+		}
+	}
+	
+	public class VvVExplosionTrap : VvVTrap
+	{
+		public override int MinDamage { get { return 40; } }
+		public  override int MaxDamage { get { return 50; } }
+
+        public VvVExplosionTrap(Mobile owner, DeploymentType type)
+            : base(owner, type)
+		{
+		}
+		
+		public override void Detonate(Mobile m)
+		{
+            int dam = Utility.RandomMinMax(MinDamage, MaxDamage);
+
+            if (DeploymentType == DeploymentType.Tripwire)
+                dam *= 2;
+			
+			AOS.Damage(m, Owner, dam, 50, 50, 0, 0, 0);
+			
+			Effects.SendLocationEffect(this.GetWorldLocation(), this.Map, 0x36BD, 15, 10);
+			Effects.PlaySound(this.GetWorldLocation(), this.Map, 0x307);
+
+            base.Detonate(m);
+		}
+
+        public VvVExplosionTrap(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+	
+	public class VvVPoisonTrap : VvVTrap
+	{
+		public override int MinDamage { get { return 25; } }
+		public override int MaxDamage { get { return 35; } }
+        public override VvVTrapType TrapType { get { return VvVTrapType.Poison; } }
+
+        public VvVPoisonTrap(Mobile owner, DeploymentType type)
+            : base(owner, type)
+		{
+		}
+		
+		public override void Detonate(Mobile m)
+		{
+            int dam = Utility.RandomMinMax(MinDamage, MaxDamage);
+
+            if (DeploymentType == DeploymentType.Tripwire)
+                dam *= 2;
+			
+			AOS.Damage(m, Owner, dam, 0, 0, 0, 100, 0);
+			m.ApplyPoison(Owner, Poison.Deadly);
+
+            Effects.SendTargetEffect(m, 0x1145, 3, 16);
+			Effects.PlaySound(this.GetWorldLocation(), this.Map, 0x230);
+
+            base.Detonate(m);
+		}
+		
+		public VvVPoisonTrap(Serial serial) : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+	
+	public class VvVColdTrap : VvVTrap
+	{
+		public override int MinDamage { get { return 25; } }
+		public override int MaxDamage { get { return 35; } }
+        public override VvVTrapType TrapType { get { return VvVTrapType.Cold; } }
+
+        public VvVColdTrap(Mobile owner, DeploymentType type)
+            : base(owner, type)
+		{
+		}
+		
+		public override void Detonate(Mobile m)
+		{
+            int dam = Utility.RandomMinMax(MinDamage, MaxDamage);
+
+            if (DeploymentType == DeploymentType.Tripwire)
+                dam *= 2;
+			
+			AOS.Damage(m, Owner, dam, 0, 0, 100, 0, 0);
+			m.FixedParticles(0x374A, 1, 15, 9502, 97, 3, (EffectLayer)255);
+			
+			m.Paralyze(TimeSpan.FromSeconds(5));
+			
+			Effects.SendLocationParticles(m, 0x374A, 1, 30, 97, 3, 9502, 0);
+			Effects.PlaySound(this.GetWorldLocation(), this.Map, 0x1FB);
+
+            base.Detonate(m);
+		}
+		
+		public VvVColdTrap(Serial serial) : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+	
+	public class VvVEnergyTrap : VvVTrap
+	{
+		public override int MinDamage { get { return 25; } }
+		public override int MaxDamage { get { return 35; } }
+        public override VvVTrapType TrapType { get { return VvVTrapType.Energy; } }
+
+        public VvVEnergyTrap(Mobile owner, DeploymentType type)
+            : base(owner, type)
+		{
+		}
+		
+		public override void Detonate(Mobile m)
+		{
+            int dam = Utility.RandomMinMax(MinDamage, MaxDamage);
+
+            if (DeploymentType == DeploymentType.Tripwire)
+                dam *= 2;
+
+            Effects.SendBoltEffect(m, true, 0);
+            AOS.Damage(m, Owner, dam, 0, 0, 100, 0, 0);
+
+			MortalStrike.BeginWound(m, TimeSpan.FromSeconds(3));
+
+            base.Detonate(m);
+		}
+		
+		public VvVEnergyTrap(Serial serial) : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+	
+	public class VvVBladeTrap : VvVTrap
+	{
+		public override int MinDamage { get { return 25; } }
+		public override int MaxDamage { get { return 35; } }
+        public override VvVTrapType TrapType { get { return VvVTrapType.Blade; } }
+
+        public VvVBladeTrap(Mobile owner, DeploymentType type)
+            : base(owner, type)
+		{
+		}
+		
+		public override void Detonate(Mobile m)
+		{
+            int dam = Utility.RandomMinMax(MinDamage, MaxDamage);
+
+            if (DeploymentType == DeploymentType.Tripwire)
+                dam *= 2;
+			
+			AOS.Damage(m, Owner, dam, 100, 0, 0, 0, 0);
+			Effects.SendLocationEffect(m.Location, m.Map, 0x11AD, 25, 10);
+			Effects.PlaySound(m.Location, m.Map, 0x218);
+			
+			TransformContext context = TransformationSpellHelper.GetContext(m);
+			
+			if ((context != null && (context.Type == typeof(LichFormSpell) || context.Type == typeof(WraithFormSpell))) ||
+                (m is BaseCreature && ((BaseCreature)m).BleedImmune))
+				return;
+				
+			m.SendLocalizedMessage(1060160); // You are bleeding!
+			BleedAttack.BeginBleed(m, Owner, false);
+
+            base.Detonate(m);
+		}
+		
+		public VvVBladeTrap(Serial serial) : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write(0);
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/ViceVsVirtue/Items/Rewards/VvVWands.cs

@@ -0,0 +1,268 @@
+using System;
+using Server;
+using Server.Items;
+
+namespace Server.Engines.VvV
+{
+    public class VvVWand1 : BaseWand, IArcaneEquip
+	{
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        #region Arcane Impl
+        private int m_MaxArcaneCharges, m_CurArcaneCharges;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int MaxArcaneCharges
+        {
+            get
+            {
+                return m_MaxArcaneCharges;
+            }
+            set
+            {
+                m_MaxArcaneCharges = value;
+                InvalidateProperties();
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int CurArcaneCharges
+        {
+            get
+            {
+                return m_CurArcaneCharges;
+            }
+            set
+            {
+                m_CurArcaneCharges = value;
+                InvalidateProperties();
+            }
+        }
+
+        public int TempHue { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool IsArcane
+        {
+            get
+            {
+                return m_MaxArcaneCharges > 0 && m_CurArcaneCharges >= 0;
+            }
+        }
+
+        public override void AddCraftedProperties(ObjectPropertyList list)
+        {
+            base.AddCraftedProperties(list);
+
+            if (IsArcane)
+                list.Add(1061837, "{0}\t{1}", m_CurArcaneCharges, m_MaxArcaneCharges); // arcane charges: ~1_val~ / ~2_val~
+        }
+        #endregion
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1023570; // Wand
+            }
+        }
+
+        public VvVWand1()
+            : base(WandEffect.None, 0, 0)
+        {
+            ItemID = 3571;
+
+            Attributes.SpellChanneling = 1;
+            WeaponAttributes.UseBestSkill = 1;
+
+            m_MaxArcaneCharges = 50;
+            m_CurArcaneCharges = 50;
+        }
+
+        public VvVWand1(Serial serial)
+            : base(serial)
+		{
+		}
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)2); // version
+
+            if (IsArcane)
+            {
+                writer.Write(true);
+                writer.Write(TempHue);
+                writer.Write((int)m_CurArcaneCharges);
+                writer.Write((int)m_MaxArcaneCharges);
+            }
+            else
+            {
+                writer.Write(false);
+            }
+        }
+
+        public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int version = reader.ReadInt();
+
+            switch (version)
+            {
+                case 2:
+                    {
+                        if (reader.ReadBool())
+                        {
+                            TempHue = reader.ReadInt();
+                            m_CurArcaneCharges = reader.ReadInt();
+                            m_MaxArcaneCharges = reader.ReadInt();
+                        }
+
+                        break;
+                    }
+                case 1:
+                    {
+                        if (reader.ReadBool())
+                        {
+                            m_CurArcaneCharges = reader.ReadInt();
+                            m_MaxArcaneCharges = reader.ReadInt();
+                        }
+
+                        break;
+                    }
+            }
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+		}
+	}
+
+    public class VvVWand2 : BaseWand, IArcaneEquip
+    {
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        #region Arcane Impl
+        private int m_MaxArcaneCharges, m_CurArcaneCharges;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int MaxArcaneCharges
+        {
+            get { return m_MaxArcaneCharges; }
+            set
+            {
+                m_MaxArcaneCharges = value;
+                InvalidateProperties();
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int CurArcaneCharges
+        {
+            get { return m_CurArcaneCharges; }
+            set
+            {
+                m_CurArcaneCharges = value;
+                InvalidateProperties();
+            }
+        }
+
+        public int TempHue { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool IsArcane
+        {
+            get
+            {
+                return m_MaxArcaneCharges > 0 && m_CurArcaneCharges >= 0;
+            }
+        }
+
+        public override void AddCraftedProperties(ObjectPropertyList list)
+        {
+            base.AddCraftedProperties(list);
+
+            if (IsArcane)
+                list.Add(1061837, "{0}\t{1}", m_CurArcaneCharges, m_MaxArcaneCharges); // arcane charges: ~1_val~ / ~2_val~
+        }
+        #endregion
+
+        public override int LabelNumber
+        {
+            get
+            {
+                return 1023570; // Wand
+            }
+        }
+
+        public VvVWand2()
+            : base(WandEffect.None, 0, 0)
+        {
+            ItemID = 3571;
+
+            Attributes.SpellChanneling = 1;
+            WeaponAttributes.MageWeapon = 15;
+
+            m_MaxArcaneCharges = 50;
+            m_CurArcaneCharges = 50;
+        }
+
+        public VvVWand2(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)2); // version
+
+            if (IsArcane)
+            {
+                writer.Write(true);
+                writer.Write(TempHue);
+                writer.Write((int)m_CurArcaneCharges);
+                writer.Write((int)m_MaxArcaneCharges);
+            }
+            else
+            {
+                writer.Write(false);
+            }
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            switch (version)
+            {
+                case 2:
+                    {
+                        if (reader.ReadBool())
+                        {
+                            TempHue = reader.ReadInt();
+                            m_CurArcaneCharges = reader.ReadInt();
+                            m_MaxArcaneCharges = reader.ReadInt();
+                        }
+
+                        break;
+                    }
+                case 1:
+                    {
+                        if (reader.ReadBool())
+                        {
+                            m_CurArcaneCharges = reader.ReadInt();
+                            m_MaxArcaneCharges = reader.ReadInt();
+                        }
+
+                        break;
+                    }
+            }
+
+            if (version == 0)
+                Timer.DelayCall(() => ViceVsVirtueSystem.Instance.AddVvVItem(this));
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/VvVAltar.cs

@@ -0,0 +1,466 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Mobiles;
+using Server.Gumps;
+using System.Collections.Generic;
+using Server.Network;
+using Server.Guilds;
+using System.Linq;
+using Server.Engines.Points;
+
+namespace Server.Engines.VvV
+{
+    public class VvVAltar : BaseAddon
+    {
+        public VvVBattle Battle { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool IsActive { get; set; }
+
+        public List<Item> Braziers { get; set; }
+        public List<Item> Torches { get; set; }
+
+        public override bool HandlesOnMovement { get { return IsActive; } }
+
+        public OccupyTimer OccupationTimer { get; set; }
+        public Timer CheckTimer { get; set; }
+
+        public VvVAltar(VvVBattle battle)
+        {
+            Battle = battle;
+
+            Braziers = new List<Item>();
+            Torches = new List<Item>();
+
+            int virtue = Utility.Random(8);
+
+            AddComponent(new AddonComponent(1822), -2, -2, 0);
+            AddComponent(new AddonComponent(1822), -1, -2, 0);
+            AddComponent(new AddonComponent(1822), 0, -2, 0);
+            AddComponent(new AddonComponent(1822), 1, -2, 0);
+            AddComponent(new AddonComponent(1822), 2, -2, 0);
+
+            AddComponent(new AddonComponent(1822), -2, -1, 0);
+            AddComponent(new AddonComponent(1822), -1, -1, 0);
+            AddComponent(new AddonComponent(1822), 0, -1, 0);
+            AddComponent(new AddonComponent(1822), 1, -1, 0);
+            AddComponent(new AddonComponent(1822), 2, -1, 0);
+
+            AddComponent(new AddonComponent(1822), -2, 0, 0);
+            AddComponent(new AddonComponent(1822), -1, 0, 0);
+            AddComponent(new AddonComponent(1822), 0, 0, 0);
+            AddComponent(new AddonComponent(1822), 1, 0, 0);
+            AddComponent(new AddonComponent(1822), 2, 0, 0);
+
+            AddComponent(new AddonComponent(1822), -2, 1, 0);
+            AddComponent(new AddonComponent(1822), -1, 1, 0);
+            AddComponent(new AddonComponent(1822), 0, 1, 0);
+            AddComponent(new AddonComponent(1822), 1, 1, 0);
+            AddComponent(new AddonComponent(1822), 2, 1, 0);
+
+            AddComponent(new AddonComponent(1822), -2, 2, 0);
+            AddComponent(new AddonComponent(1822), -1, 2, 0);
+            AddComponent(new AddonComponent(1822), 0, 2, 0);
+            AddComponent(new AddonComponent(1822), 1, 2, 0);
+            AddComponent(new AddonComponent(1822), 2, 2, 0);
+
+            //NorthWest
+            AddComponent(new AddonComponent(_Tiles[0][virtue]), -2, -2, 5);
+            AddComponent(new AddonComponent(_Tiles[0][virtue] + 1), -2, -1, 5);
+            AddComponent(new AddonComponent(_Tiles[0][virtue] + 2), -1, -1, 5);
+            AddComponent(new AddonComponent(_Tiles[0][virtue] + 3), -1, -2, 5);
+
+            // SouthEast
+            AddComponent(new AddonComponent(_Tiles[0][virtue]), 1, 1, 5);
+            AddComponent(new AddonComponent(_Tiles[0][virtue] + 1), 1, 2, 5);
+            AddComponent(new AddonComponent(_Tiles[0][virtue] + 2), 2, 2, 5);
+            AddComponent(new AddonComponent(_Tiles[0][virtue] + 3), 2, 1, 5);
+
+            //SouthWest
+            AddComponent(new AddonComponent(_Tiles[1][virtue]), -2, 1, 5);
+            AddComponent(new AddonComponent(_Tiles[1][virtue] + 1), -1, 1, 5);
+            AddComponent(new AddonComponent(_Tiles[1][virtue] + 2), -2, 2, 5);
+            AddComponent(new AddonComponent(_Tiles[1][virtue] + 3), -1, 2, 5);
+
+            //NorthEast
+            AddComponent(new AddonComponent(_Tiles[1][virtue]), 1, -2, 5);
+            AddComponent(new AddonComponent(_Tiles[1][virtue] + 1), 2, -2, 5);
+            AddComponent(new AddonComponent(_Tiles[1][virtue] + 2), 1, -1, 5);
+            AddComponent(new AddonComponent(_Tiles[1][virtue] + 3), 2, -1, 5);
+
+            AddComponent(new AddonComponent(1866), -1, -3, 0);
+            AddComponent(new AddonComponent(1847), 0, -3, 0);
+            AddComponent(new AddonComponent(1868), 1, -3, 0);
+
+            AddComponent(new AddonComponent(1868), 3, -1, 0);
+            AddComponent(new AddonComponent(1846), 3, 0, 0);
+            AddComponent(new AddonComponent(1867), 3, 1, 0);
+
+            AddComponent(new AddonComponent(1869), -1, 3, 0);
+            AddComponent(new AddonComponent(1823), 0, 3, 0);
+            AddComponent(new AddonComponent(1867), 1, 3, 0);
+
+            AddComponent(new AddonComponent(1866), -3, -1, 0);
+            AddComponent(new AddonComponent(1865), -3, 0, 0);
+            AddComponent(new AddonComponent(1869), -3, 1, 0);
+
+            AddonComponent c = new AddonComponent(6570);
+            AddComponent(c, 3, -3, 0);
+            Braziers.Add(c);
+
+            c = new AddonComponent(6570);
+            AddComponent(c, 3, 3, 0);
+            Braziers.Add(c);
+
+            c = new AddonComponent(6570);
+            AddComponent(c, -3, 3, 0);
+            Braziers.Add(c);
+
+            c = new AddonComponent(6570);
+            AddComponent(c, -3, -3, 0);
+            Braziers.Add(c);
+        }
+
+        public bool Contains(IPoint3D p)
+        {
+            if (p is IEntity && ((IEntity)p).Map != this.Map)
+                return false;
+
+            return p.X >= this.X - 2 && p.X <= this.X + 2 && p.Y >= this.Y - 2 && p.Y <= this.Y + 2;
+        }
+
+        public void Activate()
+        {
+            IsActive = true;
+
+            CheckTimer = Timer.DelayCall(TimeSpan.FromMilliseconds(500), TimeSpan.FromMilliseconds(500), CheckOccupy);
+            CheckTimer.Start();
+        }
+
+        public void Complete(Guild g)
+        {
+            Timer.DelayCall(TimeSpan.FromSeconds(5), DoOccupy, new object[] { Battle, g });
+
+            Timer.DelayCall(TimeSpan.FromSeconds(2), DoFireworks);
+            IsActive = false;
+
+            if (OccupationTimer != null)
+            {
+                OccupationTimer = null;
+            }
+
+            if (CheckTimer != null)
+            {
+                CheckTimer.Stop();
+                CheckTimer = null;
+            }
+
+            Timer.DelayCall(TimeSpan.FromMinutes(2), () =>
+                {
+                    Torches.ForEach(t => t.Delete());
+                    Torches.Clear();
+                });
+        }
+
+        public static void DoOccupy(object obj)
+        {
+            object[] objs = obj as object[];
+            VvVBattle battle = objs[0] as VvVBattle;
+            Guild g = objs[1] as Guild;
+
+            if (battle != null && g != null)
+                battle.OccupyAltar(g);
+        }
+
+        public void DoFireworks()
+        {
+            if (Deleted)
+                return;
+
+            for (int i = 2; i <= 8; i += 2)
+            {
+                Server.Timer.DelayCall(TimeSpan.FromMilliseconds((i - 2) * 600), o =>
+                {
+                    Server.Misc.Geometry.Circle2D(this.Location, this.Map, (int)o, (pnt, map) =>
+                    {
+                        LaunchFireworks(pnt, map);
+                    });
+                }, i);
+            }
+        }
+
+        public static void LaunchFireworks(Point3D p, Map map)
+        {
+            if (map == null || map == Map.Internal)
+                return;
+
+            Point3D startLoc = new Point3D(p.X, p.Y, p.Z + 10);
+            Point3D endLoc = new Point3D(p.X + Utility.RandomMinMax(-1, 1), p.Y + Utility.RandomMinMax(-1, 1), p.Z + 32);
+
+            Effects.SendMovingEffect(new Entity(Serial.Zero, startLoc, map), new Entity(Serial.Zero, endLoc, map),
+                0x36E4, 5, 0, false, false);
+
+            Server.Timer.DelayCall(TimeSpan.FromSeconds(1.0), () =>
+                {
+                    int hue = Utility.Random(40);
+
+                    if (hue < 8)
+                        hue = 0x66D;
+                    else if (hue < 10)
+                        hue = 0x482;
+                    else if (hue < 12)
+                        hue = 0x47E;
+                    else if (hue < 16)
+                        hue = 0x480;
+                    else if (hue < 20)
+                        hue = 0x47F;
+                    else
+                        hue = 0;
+
+                    if (Utility.RandomBool())
+                        hue = Utility.RandomList(0x47E, 0x47F, 0x480, 0x482, 0x66D);
+
+                    int renderMode = Utility.RandomList(0, 2, 3, 4, 5, 7);
+
+                    Effects.PlaySound(endLoc, map, Utility.Random(0x11B, 4));
+                    Effects.SendLocationEffect(endLoc, map, 0x373A + (0x10 * Utility.Random(4)), 16, 10, hue, renderMode);
+                });
+        }
+
+        public void CheckOccupy()
+        {
+            if (!IsActive || this.Map == null || this.Map == Map.Internal)
+                return;
+
+            IPooledEnumerable eable = this.Map.GetMobilesInBounds(new Rectangle2D(this.X - 2, this.Y - 2, 5, 5));
+            int count = 0;
+
+            foreach (Mobile m in eable)
+            {
+                VvVPlayerEntry entry;
+
+                if (m.Alive && ViceVsVirtueSystem.IsVvV(m, out entry, false, true))
+                {
+                    count++;
+
+                    if (OccupationTimer != null)
+                    {
+                        Guild g = OccupationTimer.Occupier;
+
+                        if (g == null || (entry.Guild != g && !entry.Guild.IsAlly(g)))
+                        {
+                            Clear();
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        this.OccupationTimer = new OccupyTimer(this, entry.Guild);
+                    }
+                }
+            }
+
+            if (this.OccupationTimer != null && !this.OccupationTimer.Running && count > 0)
+            {
+                this.OccupationTimer.Start();
+            }
+            else if (OccupationTimer != null && count == 0)
+            {
+                Clear();
+            }
+
+            eable.Free();
+        }
+
+        private void Clear()
+        {
+            OccupationTimer.Stop();
+            OccupationTimer = null;
+
+            Torches.ForEach(t => t.Delete());
+            Torches.Clear();
+        }
+
+        public class OccupyTimer : Timer
+        {
+            public Guild Occupier { get; set; }
+            public VvVAltar Altar { get; set; }
+
+            private int _Tick;
+
+            public OccupyTimer(VvVAltar altar, Guild occupier)
+                : base(TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(2))
+            {
+                Occupier = occupier;
+                Altar = altar;
+                _Tick = 0;
+            }
+
+            protected override void OnTick()
+            {
+                if (_Tick < 0)
+                {
+                    _Tick = 0;
+                }
+
+                if (_Tick >= _Locs.Length)
+                {
+                    Altar.Complete(Occupier);
+                    Stop();
+                    return;
+                }
+
+                Point3D p = _Locs[_Tick];
+
+                Effects.SendLocationEffect(new Point3D(Altar.X + p.X, Altar.Y + p.Y, Altar.Z + p.Z), Altar.Map, 0x3709, 30, 10);
+                Effects.PlaySound(Altar.Location, Altar.Map, 0x208);
+
+                int index = _Tick / 4;
+
+                if (_Tick > 0 && index < Altar.Braziers.Count && (_Tick + 1) % 4 == 0)
+                {
+                    Server.Timer.DelayCall(TimeSpan.FromSeconds(1), () =>
+                        {
+                            AddonComponent torch = new AddonComponent(6571);
+                            Altar.Torches.Add(torch);
+
+                            Point3D to = Altar.Braziers[index].Location;
+
+                            torch.MoveToWorld(new Point3D(to.X, to.Y, to.Z + 17), Altar.Map);
+                            Effects.PlaySound(to, Altar.Map, 0x47);
+                        });
+                }
+
+                _Tick++;
+
+                if (_Tick >= _Locs.Length)
+                {
+                    Altar.Complete(Occupier);
+                    Stop();
+                }
+            }
+
+            private Point3D[] _Locs =
+            {
+                new Point3D(-1, -2, 7), new Point3D(0, -2, 7), new Point3D(1, -2, 7), new Point3D(2, -2, 7),
+                new Point3D(2, -1, 7), new Point3D(2, 0, 7), new Point3D(2, 1, 7), new Point3D(2, 2, 7),
+                new Point3D(1, 2, 7), new Point3D(0, 2, 7), new Point3D(-1, 2, 7), new Point3D(-2, 2, 7),
+                new Point3D(-2, 1, 7), new Point3D(-2, 0, 7), new Point3D(-2, -1, 7), new Point3D(-2, -2, 7),
+            };
+        }
+
+        public override void Delete()
+        {
+            base.Delete();
+
+            Torches.ForEach(t => t.Delete());
+        }
+
+        public VvVAltar(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write(IsActive);
+
+            writer.Write(Braziers.Count);
+            Braziers.ForEach(b => writer.Write(b));
+
+            writer.Write(Torches.Count);
+            Torches.ForEach(t => writer.Write(t));
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            Braziers = new List<Item>();
+            Torches = new List<Item>();
+
+            IsActive = reader.ReadBool();
+
+            int count = reader.ReadInt();
+            for (int i = 0; i < count; i++)
+            {
+                Item item = reader.ReadItem();
+                if (item != null)
+                    Braziers.Add(item);
+            }
+
+            count = reader.ReadInt();
+            for (int i = 0; i < count; i++)
+            {
+                Item item = reader.ReadItem();
+                if (item != null)
+                    Torches.Add(item);
+            }
+
+            if (IsActive)
+            {
+                CheckTimer = Timer.DelayCall(TimeSpan.FromMilliseconds(500), TimeSpan.FromMilliseconds(500), CheckOccupy);
+                CheckTimer.Start();
+            }
+        }
+
+        private int[][] _Tiles =
+        {
+            new int[] { 5283,  5291,  5299,  5307,  5315,  5323,  5331,  5390 },
+            new int[] { 39372, 39380, 39388, 39396, 39404, 39412, 39420, 39428 }
+        };
+    }
+
+    public class AltarArrow : QuestArrow
+    {
+        public Timer Timer { get; private set; }
+        public VvVAltar Altar { get; private set; }
+
+        public int LastX { get; private set; }
+        public int LastY { get; private set; }
+
+        public AltarArrow(Mobile from, IEntity target)
+            : base(from, target)
+        {
+            Altar = target as VvVAltar;
+
+            Timer = Timer.DelayCall(TimeSpan.FromSeconds(0.25), TimeSpan.FromSeconds(2.5), OnTick); //new TrackTimer(from, target, range, this);
+            Timer.Start();
+        }
+
+        public void OnTick()
+        {
+            if (!Running)
+            {
+                Timer.Stop();
+                return;
+            }
+            else if (this.Mobile.NetState == null || this.Mobile.Deleted || Altar.Deleted || this.Mobile.Map != Altar.Map
+                || ViceVsVirtueSystem.Instance.Battle == null || !ViceVsVirtueSystem.Instance.Battle.OnGoing || !this.Mobile.Region.IsPartOf(ViceVsVirtueSystem.Instance.Battle.Region)
+                || Altar.Contains(this.Mobile))
+            {
+                Stop();
+                return;
+            }
+
+            // this should never happen!
+            if (LastX != Target.X || LastY != Target.Y)
+            {
+                LastX = Target.X;
+                LastY = Target.Y;
+
+                Update();
+            }
+        }
+
+        public override void OnStop()
+        {
+            Timer.Stop();
+        }
+    }
+}

Scripts/Services/ViceVsVirtue/Items/VvVSigil.cs

@@ -0,0 +1,151 @@
+using System;
+using Server;
+using Server.Items;
+using Server.Mobiles;
+using Server.Gumps;
+using System.Collections.Generic;
+using Server.Network;
+using Server.Guilds;
+using System.Linq;
+using Server.Engines.Points;
+
+namespace Server.Engines.VvV
+{
+    public class VvVSigil : Item, IRevealableItem
+    {
+        public const int OwnershipHue = 0xB;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public VvVBattle Battle { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Point3D HomeLocation { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public DateTime LastStolen { get; set; }
+
+        public override int LabelNumber { get { return 1123391; } } // Sigil
+        public override bool HandlesOnMovement { get { return !Visible; } }
+        public bool CheckWhenHidden { get { return true; } }
+
+        public VvVSigil(VvVBattle battle, Point3D home)
+            : base(0x99C7)
+        {
+            Battle = battle;
+            Visible = false;
+
+            Hue = 2721;
+
+            LootType = LootType.Cursed;
+        }
+
+        public void OnStolen(VvVPlayerEntry entry)
+        {
+            if (Battle != null && RootParentEntity == null)
+            {
+                Battle.SpawnPriests();
+                Battle.Update(null, entry, UpdateType.Steal);
+
+                LastStolen = DateTime.UtcNow;
+                HomeLocation = Location;
+
+                Movable = true;
+            }
+        }
+
+        public override bool CheckLift(Mobile from, Item item, ref LRReason reject)
+        {
+            if (LastStolen == DateTime.MinValue)
+            {
+                from.SendLocalizedMessage(1005225); // You must use the stealing skill to pick up the sigil
+                return false;
+            }
+
+            return base.CheckLift(from, item, ref reject);
+        }
+
+        private Mobile FindOwner(object parent)
+        {
+            if (parent is Item)
+                return ((Item)parent).RootParent as Mobile;
+
+            if (parent is Mobile)
+                return (Mobile)parent;
+
+            return null;
+        }
+
+        public void ReturnToHome()
+        {
+            MoveToWorld(HomeLocation, Map.Felucca);
+            Visible = false;
+            Movable = false;
+        }
+
+        public static bool CheckMovement(PlayerMobile pm, Direction d)
+        {
+            if (!ViceVsVirtueSystem.Enabled)
+            {
+                return true;
+            }
+
+            int x = pm.X;
+            int y = pm.Y;
+
+            Movement.Movement.Offset(d, ref x, ref y);
+
+            Region r = Region.Find(new Point3D(x, y, pm.Map.GetAverageZ(x, y)), pm.Map);
+
+            return ViceVsVirtueSystem.IsBattleRegion(r);
+        }
+
+        public bool CheckReveal(Mobile m)
+        {
+            if (!ViceVsVirtueSystem.IsVvV(m))
+                return false;
+
+            return Utility.Random(100) <= m.Skills[SkillName.DetectHidden].Value;
+        }
+
+        public virtual void OnRevealed(Mobile m)
+        {
+            Visible = true;
+        }
+
+        public virtual bool CheckPassiveDetect(Mobile m)
+        {
+            if (m.InRange(this.Location, 4))
+            {
+                int skill = (int)m.Skills[SkillName.DetectHidden].Value;
+
+                if (skill >= 80 && Utility.Random(300) < skill)
+                    return true;
+            }
+
+            return false;
+        }
+
+        public VvVSigil(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+
+            writer.Write(LastStolen);
+            writer.Write(HomeLocation);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            LastStolen = reader.ReadDateTime();
+            HomeLocation = reader.ReadPoint3D();
+        }
+    }
+}