Overwrite

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

Scripts/Services/Expansions/High Seas/Items/Artifacts/CorgulsEnchantedSash.cs

@@ -0,0 +1,34 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class CorgulsEnchantedSash : BodySash
+    {
+        public override int LabelNumber { get { return 1149781; } }
+
+        [Constructable]
+        public CorgulsEnchantedSash()
+        {
+            Attributes.BonusStam = 1;
+            Attributes.DefendChance = 5;
+        }
+
+        public CorgulsEnchantedSash(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Artifacts/CorgulsHandbookOnMysticism.cs

@@ -0,0 +1,37 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class CorgulsHandbookOnMysticism : MysticBook
+	{
+        public override int LabelNumber { get { return 1149779; } }
+
+		[Constructable]
+		public CorgulsHandbookOnMysticism ()
+		{
+			Hue = 1159;
+			Attributes.RegenMana = 3;
+			Attributes.DefendChance = 5;
+			Attributes.LowerManaCost = 10;
+			Attributes.LowerRegCost = 20;
+		}
+
+        public CorgulsHandbookOnMysticism(Serial serial)
+            : base(serial)
+		{
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{	
+			base.Serialize(writer);
+            writer.Write((int)0);	
+		}
+	
+		public override void Deserialize(GenericReader reader)
+		{
+		 	base.Deserialize(reader);
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Services/Expansions/High Seas/Items/Artifacts/CorgulsHandbookOnTheUndead.cs

@@ -0,0 +1,37 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class CorgulsHandbookOnTheUndead : NecromancerSpellbook
+    {
+        public override int LabelNumber { get { return 1149780; } }
+
+        [Constructable]
+        public CorgulsHandbookOnTheUndead()
+        {
+            Hue = 2953;
+            Attributes.RegenMana = 3;
+            Attributes.DefendChance = 5;
+            Attributes.LowerManaCost = 10;
+            Attributes.LowerRegCost = 20;
+        }
+
+        public CorgulsHandbookOnTheUndead(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Artifacts/CullingBlade.cs

@@ -0,0 +1,47 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class CullingBlade : BoneHarvester
+    {
+        public override int LabelNumber { get { return 1116630; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        [Constructable]
+        public CullingBlade()
+        {
+            WeaponAttributes.HitManaDrain = 30;
+            WeaponAttributes.HitFatigue = 30;
+            WeaponAttributes.HitLowerDefend = 40;
+            Attributes.RegenHits = 3;
+            Attributes.WeaponSpeed = 20;
+            Attributes.WeaponDamage = 50;
+        }
+
+        public override void GetDamageTypes(Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct)
+        {
+            phys = fire = cold = nrgy = pois = direct = 0;
+            chaos = 100;
+        }
+
+        public CullingBlade(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Artifacts/EnchantedBlade.cs

@@ -0,0 +1,64 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    	public class EnchantedBladeAddon : BaseAddon
+    	{
+
+		    public override BaseAddonDeed Deed{ get{ return new EnchantedBladeDeed(); } }
+
+        	[Constructable]
+        	public EnchantedBladeAddon()
+        	{
+			    AddComponent( new LocalizedAddonComponent(14240, 1034240),  0,  0, 0 );
+        	}
+
+        	public EnchantedBladeAddon(Serial serial)
+            	: base(serial)
+        	{
+        	}
+
+        	public override void Serialize(GenericWriter writer)
+        	{
+            		base.Serialize(writer);
+            		writer.Write((int)0);
+        	}
+
+        	public override void Deserialize(GenericReader reader)
+        	{
+            		base.Deserialize(reader);
+            		int version = reader.ReadInt();
+        	}
+    	}
+
+	public class EnchantedBladeDeed : BaseAddonDeed
+	{
+		public override BaseAddon Addon{ get{ return new EnchantedBladeAddon(); } }
+
+		[Constructable]
+		public EnchantedBladeDeed()
+		{
+            Name = "A deed for an enchanted blade";
+		}
+
+		public EnchantedBladeDeed( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+
+			writer.WriteEncodedInt( 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+
+			int version = reader.ReadEncodedInt();
+		}
+
+	}
+}

Scripts/Services/Expansions/High Seas/Items/Artifacts/EnchantedCoralBracelet.cs

@@ -0,0 +1,40 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class EnchantedCoralBracelet : SilverBracelet
+    {
+        public override int LabelNumber { get { return 1116624; } }
+
+        [Constructable]
+        public EnchantedCoralBracelet()
+        {
+            Hue = 1548;
+            Attributes.BonusHits = 5;
+            Attributes.RegenMana = 1;
+            Attributes.AttackChance = 5;
+            Attributes.DefendChance = 15;
+            Attributes.CastSpeed = 1;
+            Attributes.CastRecovery = 3;
+            Attributes.SpellDamage = 10;
+        }
+
+        public EnchantedCoralBracelet(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Artifacts/EnchantedVortex.cs

@@ -0,0 +1,67 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class EnchantedVortexAddon : BaseAddon
+    {
+
+        public override BaseAddonDeed Deed { get { return new EnchantedVortexDeed(); } }
+
+        [Constructable]
+        public EnchantedVortexAddon()
+        {
+            AddonComponent comp = new AddonComponent(14284);
+            comp.Name = "an enchanted vortex";
+            AddComponent(comp, 0, 0, 0);
+        }
+
+        public EnchantedVortexAddon(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class EnchantedVortexDeed : BaseAddonDeed
+    {
+        public override BaseAddon Addon { get { return new EnchantedVortexAddon(); } }
+
+        [Constructable]
+        public EnchantedVortexDeed()
+        {
+            Name = "A deed for an enchanted vortex";
+        }
+
+        public EnchantedVortexDeed(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Artifacts/HelmOfVengence.cs

@@ -0,0 +1,47 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class HelmOfVengence : NorseHelm
+    {
+        public override int LabelNumber { get { return 1116621; } }
+
+        public override int BasePhysicalResistance { get { return 11; } }
+        public override int BaseFireResistance { get { return 10; } }
+        public override int BaseColdResistance { get { return 14; } }
+        public override int BasePoisonResistance { get { return 7; } }
+        public override int BaseEnergyResistance { get { return 8; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        [Constructable]
+        public HelmOfVengence()
+        {
+            Hue = 2012;
+            Attributes.RegenMana = 3;
+            Attributes.ReflectPhysical = 30;
+            Attributes.AttackChance = 7;
+            Attributes.WeaponDamage = 10;
+            Attributes.LowerManaCost = 8;
+        }
+
+        public HelmOfVengence(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Artifacts/LeviathanHideBracers.cs

@@ -0,0 +1,50 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class LeviathanHideBracers : LeatherArms
+    {
+        public override int LabelNumber { get { return 1116619; } }
+
+        public override int BasePhysicalResistance { get { return 7; } }
+        public override int BaseFireResistance { get { return 9; } }
+        public override int BaseColdResistance { get { return 10; } }
+        public override int BasePoisonResistance { get { return 13; } }
+        public override int BaseEnergyResistance { get { return 14; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        [Constructable]
+        public LeviathanHideBracers()
+        {
+            Hue = 1274;
+
+            AbsorptionAttributes.CastingFocus = 2;
+            Attributes.BonusInt = 6;
+            Attributes.AttackChance = 5;
+            Attributes.RegenStam = 2;
+            Attributes.RegenMana = 2;
+            Attributes.LowerManaCost = 8;
+            Attributes.LowerRegCost = 10;
+        }
+
+        public LeviathanHideBracers(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Artifacts/RingOfTheSoulbinder.cs

@@ -0,0 +1,39 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class RingOfTheSoulbinder : SilverRing
+    {
+        public override int LabelNumber { get { return 1116620; } }
+
+        [Constructable]
+        public RingOfTheSoulbinder()
+        {
+            Hue = 288;
+            Attributes.RegenMana = 2;
+            Attributes.DefendChance = 15;
+            Attributes.CastSpeed = 1;
+            Attributes.CastRecovery = 3;
+            Attributes.SpellDamage = 10;
+            Attributes.LowerRegCost = 10;
+        }
+
+        public RingOfTheSoulbinder(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Artifacts/RuneEngravedPegLeg.cs

@@ -0,0 +1,47 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class RuneEngravedPegLeg : Club
+    {
+        public override int LabelNumber { get { return 1116622; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        [Constructable]
+        public RuneEngravedPegLeg()
+        {
+            WeaponAttributes.HitLightning = 40;
+            WeaponAttributes.HitLowerDefend = 40;
+            Attributes.RegenHits = 3;
+            Attributes.AttackChance = 5;
+            Attributes.WeaponSpeed = 30;
+            Attributes.WeaponDamage = 50;
+        }
+
+        public override void GetDamageTypes(Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct)
+        {
+            phys = fire = cold = nrgy = pois = direct = 0;
+            chaos = 100;
+        }
+
+        public RuneEngravedPegLeg(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Artifacts/SmilingMoonBlade.cs

@@ -0,0 +1,48 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class SmilingMoonBlade : CrescentBlade
+    {
+        public override int LabelNumber { get { return 1116628; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        [Constructable]
+        public SmilingMoonBlade()
+        {
+            Hue = 2567;
+            WeaponAttributes.HitManaDrain = 10;
+            WeaponAttributes.HitFireball = 45;
+            WeaponAttributes.HitLowerDefend = 40;
+            WeaponAttributes.BattleLust = 1;
+            Attributes.WeaponSpeed = 30;
+            Attributes.WeaponDamage = 45;
+        }
+
+        public override void GetDamageTypes(Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct)
+        {
+            phys = fire = chaos = nrgy = pois = direct = 0;
+            cold = 100;
+        }
+
+        public SmilingMoonBlade(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Artifacts/WandOfThunderingGlory.cs

@@ -0,0 +1,46 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class WandOfThunderingGlory : BaseWand
+    {
+        public override int LabelNumber { get { return 1116623; } }
+
+        public override int InitMinHits { get { return 255; } }
+        public override int InitMaxHits { get { return 255; } }
+
+        [Constructable]
+        public WandOfThunderingGlory() : base(WandEffect.None, 0, 0)
+        {
+            WeaponAttributes.HitLightning = 40;
+            Attributes.AttackChance = 5;
+            Attributes.WeaponSpeed = 10;
+            Attributes.WeaponDamage = 50;
+            Attributes.SpellDamage = 10;
+        }
+
+        public override void GetDamageTypes(Mobile wielder, out int phys, out int fire, out int cold, out int pois, out int nrgy, out int chaos, out int direct)
+        {
+            phys = fire = cold = nrgy = pois = direct = 0;
+            chaos = 100;
+        }
+
+        public WandOfThunderingGlory(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/BoatPaint.cs

@@ -0,0 +1,132 @@
+using Server;
+using System;
+using Server.Multis;
+using Server.Targeting;
+
+namespace Server.Items
+{
+    public class BoatPaint : Item
+    {
+        public override int LabelNumber { get { return 1116236; } }
+        public override double DefaultWeight { get { return 10.0; } }
+
+        private bool m_Permanent;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool Permanent { get { return m_Permanent; } set { m_Permanent = value; } }
+
+        public BoatPaint(object hue) : this((int)hue)
+        {
+        }
+
+        [Constructable]
+        public BoatPaint(int hue) : base(4011)
+        {
+            Hue = hue;
+            m_Permanent = false;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.Target = new InternalTarget(from, this);
+                from.SendLocalizedMessage(1116613); //Select the main mast of the ship you wish to dye.
+            }
+        }
+
+        private class InternalTarget : Target
+        {
+            private BoatPaint m_Paint;
+            private Mobile m_From;
+
+            public InternalTarget(Mobile from, BoatPaint paint) : base(5, false, TargetFlags.None)
+            {
+                m_From = from;
+                m_Paint = paint;
+            }
+
+            protected override void OnTarget(Mobile from, object targeted)
+            {
+                if (targeted is IPoint3D)
+                {
+                    IPoint3D pnt = (IPoint3D)targeted;
+                    BaseGalleon galleon = BaseGalleon.FindGalleonAt(pnt, from.Map);
+
+                    if (galleon == null || !galleon.Contains(from))
+                        return;
+
+                    if (galleon.GetSecurityLevel(from) < SecurityLevel.Captain)
+                        from.SendMessage("You must be the captain to paint this ship!");
+
+                    else if (galleon.Contains(pnt)/*&& boat.X == pnt.X && boat.Y == pnt.Y*/)
+                    {
+                        if (m_Paint.Permanent)
+                        {
+                            if (galleon.TryPermanentPaintBoat(from, m_Paint.Hue))
+                                m_Paint.Delete();
+                        }
+                        else
+                        {
+                            if (galleon.TryPaintBoat(from, m_Paint.Hue))
+                                m_Paint.Delete();
+                        }
+                    }
+                    else
+                        from.SendLocalizedMessage(1116612); //You must target the main mast of the ship you wish to dye.
+
+                }
+            }
+        }
+
+        public BoatPaint(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class PermanentBoatPaint : BoatPaint
+    {
+        public override int LabelNumber { get { return 1116768; } }
+
+        [Constructable]
+        public PermanentBoatPaint()
+            : this(Utility.RandomMinMax(1954, 1997))
+        {
+        }
+
+        [Constructable]
+        public PermanentBoatPaint(int hue) : base(hue)
+        {
+            Permanent = true;
+        }
+
+        public static PermanentBoatPaint DropRandom()
+        {
+            return new PermanentBoatPaint(Utility.RandomMinMax(1954, 1997));
+        }
+
+        public PermanentBoatPaint(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/BoatPaintRemover.cs

@@ -0,0 +1,68 @@
+using Server;
+using System;
+using Server.Multis;
+using Server.Targeting;
+
+namespace Server.Items
+{
+    public class BoatPaintRemover : Item
+    {
+        public override int LabelNumber { get { return 1116766; } }
+        public override double DefaultWeight { get { return 10.0; } }
+
+        [Constructable]
+        public BoatPaintRemover() : base(4011)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if(IsChildOf(from.Backpack))
+                from.Target = new InternalTarget(this);
+        }
+
+        private class InternalTarget : Target
+        {
+            private BoatPaintRemover m_PaintRemover;
+
+            public InternalTarget(BoatPaintRemover paintremover)
+                : base(5, false, TargetFlags.None)
+            {
+                m_PaintRemover = paintremover;
+            }
+
+            protected override void OnTarget(Mobile from, object targeted)
+            {
+                if (targeted is IPoint3D)
+                {
+                    IPoint3D pnt = (IPoint3D)targeted;
+                    BaseBoat boat = BaseBoat.FindBoatAt(pnt, from.Map);
+
+                    if (boat is BaseGalleon && boat.Contains(from))
+                    {
+                        if (((BaseGalleon)boat).RemovePaint())
+                            m_PaintRemover.Delete();
+                    }
+
+                    else
+                        from.SendLocalizedMessage(1116612); //You must target the main mast of the ship you wish to dye.
+
+                }
+            }
+        }
+
+        public BoatPaintRemover(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Cannons and Ammo/AmmoInfo.cs

@@ -0,0 +1,169 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Server;
+using Server.Mobiles;
+using Server.Multis;
+
+namespace Server.Items
+{
+    public interface ICannonAmmo
+    {
+        AmmunitionType AmmoType { get; }
+    }
+
+    public enum AmmunitionType
+    {
+        Empty,
+        Cannonball,
+        Grapeshot,
+        FrostCannonball,
+        FlameCannonball
+    }
+
+    public class AmmoInfo
+    {
+        private static Dictionary<Type, AmmoInfo> Infos { get; set; } = new Dictionary<Type, AmmoInfo>();
+
+        public static void Initialize()
+        {
+            if (Core.EJ)
+            {
+                Infos[typeof(Cannonball)] = new AmmoInfo(typeof(HeavyCannonball), AmmunitionType.Cannonball, 1095804, 5000, 5000, 3);
+                Infos[typeof(Grapeshot)] = new AmmoInfo(typeof(HeavyGrapeshot), AmmunitionType.Grapeshot, 1095741, 100, 150, 3);
+
+                Infos[typeof(FlameCannonball)] = new AmmoInfo(typeof(HeavyFlameCannonball), AmmunitionType.FlameCannonball, 1149633, 5000, 5000, 3, true, 50, 50, 0, 0, 0, false);
+                Infos[typeof(FrostCannonball)] = new AmmoInfo(typeof(HeavyFrostCannonball), AmmunitionType.FrostCannonball, 1149634, 30, 50, 3, true, 50, 0, 50, 0, 0, false);
+            }
+            else
+            {
+                Infos[typeof(LightCannonball)] = new AmmoInfo(typeof(LightCannonball), AmmunitionType.Cannonball, 1095804, 5000, 5000, 3);
+                Infos[typeof(HeavyCannonball)] = new AmmoInfo(typeof(HeavyCannonball), AmmunitionType.Cannonball, 1095804, 6500, 6500, 3);
+                Infos[typeof(LightGrapeshot)] = new AmmoInfo(typeof(LightGrapeshot), AmmunitionType.Grapeshot, 1095741, 40, 50, 3);
+                Infos[typeof(HeavyGrapeshot)] = new AmmoInfo(typeof(HeavyGrapeshot), AmmunitionType.Grapeshot, 1095741, 50, 75, 3);
+
+                Infos[typeof(HeavyFlameCannonball)] = new AmmoInfo(typeof(HeavyFlameCannonball), AmmunitionType.FlameCannonball, 1149633, 5000, 5000, 3, true, 50, 50, 0, 0, 0, false);
+                Infos[typeof(LightFlameCannonball)] = new AmmoInfo(typeof(LightFlameCannonball), AmmunitionType.FlameCannonball, 1149633, 5000, 5000, 3, true, 50, 50, 0, 0, 0, false);
+                Infos[typeof(HeavyFrostCannonball)] = new AmmoInfo(typeof(HeavyFrostCannonball), AmmunitionType.FrostCannonball, 1149634, 5000, 5000, 3, true, 50, 0, 50, 0, 0, false);
+                Infos[typeof(LightFrostCannonball)] = new AmmoInfo(typeof(LightFrostCannonball), AmmunitionType.FrostCannonball, 1149634, 5000, 5000, 3, true, 50, 0, 50, 0, 0, false);
+            }
+        }
+
+        public Type Type { get; set; }
+        public AmmunitionType AmmoType { get; set; }
+        public TextDefinition Name { get; set; }
+        public int MinDamage { get; set; }
+        public int MaxDamage { get; set; }
+        public int LateralOffset { get; set; }
+        public int PhysicalDamage { get; set; }
+        public int FireDamage { get; set; }
+        public int ColdDamage { get; set; }
+        public int PoisonDamage { get; set; }
+        public int EnergyDamage { get; set; }
+        public bool SingleTarget { get; set; }
+        public bool RequiresSurface { get; set; }
+
+        public AmmoInfo(Type type, AmmunitionType ammoType, TextDefinition name, int minDamage, int maxDamage, int lateralOffset) 
+            : this(type, ammoType, name, minDamage, maxDamage, lateralOffset, true, 100, 0, 0, 0, 0, false)
+        {
+        }
+
+        public AmmoInfo(Type type, AmmunitionType ammoType, TextDefinition name, int minDamage, int maxDamage, int lateralOffset, bool singleOnly)
+            : this(type, ammoType, name, minDamage, maxDamage, lateralOffset, singleOnly, 100, 0, 0, 0, 0, false)
+        {
+        }
+
+        public AmmoInfo(Type type, AmmunitionType ammoType, TextDefinition name, int minDamage, int maxDamage, int lateralOffset, bool singleOnly, int phys, int fire, int cold, int poison, int energy, bool requiresSurface)
+        {
+            Type = type;
+            AmmoType = ammoType;
+            Name = name;
+            MinDamage = minDamage;
+            MaxDamage = maxDamage;
+            LateralOffset = lateralOffset;
+            PhysicalDamage = phys;
+            FireDamage = fire;
+            ColdDamage = cold;
+            PoisonDamage = poison;
+            EnergyDamage = energy;
+            SingleTarget = singleOnly;
+            RequiresSurface = requiresSurface;
+        }
+
+
+        /// <summary>
+        /// Gets damage for Rising Tides Cannons. This differentiates between the cannon sizes.
+        /// </summary>
+        /// <param name="cannon"></param>
+        /// <returns></returns>
+        public int GetDamage(BaseShipCannon cannon)
+        {
+            return Utility.RandomMinMax(MinDamage, MaxDamage);
+
+            // Fucking EA, after rising tide, made all cannons deal the same amount of damage. I don't get it. If they ever pull their head out of their asses, or you
+            // want, use the code below...
+
+            /*if (AmmoType == AmmunitionType.Grapeshot)
+            {
+                return Utility.RandomMinMax(MinDamage, MaxDamage);
+            }
+
+            int baseDamage = Utility.RandomMinMax(info.MinDamage, info.MaxDamage);
+
+            switch (cannon.Power)
+            {
+                default:
+                case CannonPower.Light: return baseDamage;
+                case CannonPower.Heavy: return baseDamage + 1500;
+                case CannonPower.Massive: return baseDamage + 3000;
+            }*/
+        }
+
+        public static AmmoInfo GetAmmoInfo(Type ammoType)
+        {
+            if (ammoType != null && Infos.ContainsKey(ammoType))
+            {
+                return Infos[ammoType];
+            }
+
+            return null;
+        }
+
+        public static AmmoInfo GetAmmoInfo(AmmunitionType ammoType)
+        {
+            return Infos.Values.FirstOrDefault(i => i.AmmoType == ammoType);
+        }
+
+        public static void GetSurfaceTop(ref Point3D p, Map map)
+        {
+            StaticTile[] tiles = map.Tiles.GetStaticTiles(p.X, p.Y, true);
+            int z = p.Z;
+
+            foreach (StaticTile tile in tiles)
+            {
+                ItemData id = TileData.ItemTable[tile.ID & TileData.MaxItemValue];
+
+                if (id.Surface && (z == p.Z || tile.Z + id.CalcHeight > z))
+                {
+                    z = tile.Z + id.CalcHeight;
+                }
+            }
+
+            if (z != p.Z)
+                p.Z = z;
+        }
+
+        public static TextDefinition GetAmmoName(IShipCannon cannon)
+        {
+            var info = Infos.Values.FirstOrDefault(i => i.AmmoType == cannon.AmmoType);
+
+            if (info == null)
+            {
+                return 1116033; // None 
+            }
+
+            return info.Name;
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Cannons and Ammo/CannonBall.cs

@@ -0,0 +1,388 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class Cannonball : Item, ICommodity, ICannonAmmo
+    {
+        public override int LabelNumber { get { return 1116266; } }
+        public override double DefaultWeight { get { return 1.0; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public virtual AmmunitionType AmmoType { get { return AmmunitionType.Cannonball; } }
+
+        [Constructable]
+        public Cannonball() : this(1)
+        {
+        }
+
+        [Constructable]
+        public Cannonball(int amount) : this(amount, 16932)
+        {
+        }
+
+        [Constructable]
+        public Cannonball(int amount, int itemid)
+            : base(itemid)
+        {
+            Stackable = true;
+            Amount = amount;
+        }
+
+        public Cannonball(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FrostCannonball : Cannonball, ICommodity
+    {
+        public override int LabelNumber { get { return 1116267; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public override AmmunitionType AmmoType { get { return AmmunitionType.FrostCannonball; } }
+
+        [Constructable]
+        public FrostCannonball() : this(1)
+        {
+        }
+
+        [Constructable]
+        public FrostCannonball(int amount) : this(amount, 16939)
+        {
+        }
+
+        [Constructable]
+        public FrostCannonball(int amount, int itemid)
+            : base(itemid)
+        {
+            Stackable = true;
+            Amount = amount;
+        }
+
+        public FrostCannonball(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FlameCannonball : Cannonball, ICommodity
+    {
+        public override int LabelNumber { get { return 1116759; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public override AmmunitionType AmmoType { get { return AmmunitionType.FlameCannonball; } }
+
+        [Constructable]
+        public FlameCannonball() : this(1)
+        {
+        }
+
+        [Constructable]
+        public FlameCannonball(int amount) : this(amount, 17601)
+        {
+        }
+
+        [Constructable]
+        public FlameCannonball(int amount, int itemid)
+            : base(itemid)
+        {
+            Stackable = true;
+            Amount = amount;
+        }
+
+        public FlameCannonball(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class LightCannonball : Item, ICommodity, ICannonAmmo
+    {
+        public override int LabelNumber { get { return 1116266; } }
+        public override double DefaultWeight { get { return 1.0; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public virtual AmmunitionType AmmoType { get { return AmmunitionType.Cannonball; } }
+
+        [Constructable]
+        public LightCannonball() : this(1)
+        {
+        }
+
+        [Constructable]
+        public LightCannonball(int amount) : this(amount, 16932)
+        {
+        }
+
+        [Constructable]
+        public LightCannonball(int amount, int itemid)
+            : base(itemid)
+        {
+            Stackable = true;
+            Amount = amount;
+        }
+
+        public LightCannonball(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (Core.EJ)
+            {
+                Replacer.Replace(this, new Cannonball());
+            }
+        }
+    }
+
+    public class HeavyCannonball : Item, ICommodity, ICannonAmmo
+    {
+        public override int LabelNumber { get { return 1116267; } }
+        public override double DefaultWeight { get { return 1.0; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public virtual AmmunitionType AmmoType { get { return AmmunitionType.Cannonball; } }
+
+        [Constructable]
+        public HeavyCannonball() : this(1)
+        {
+        }
+
+        [Constructable]
+        public HeavyCannonball(int amount) : this(amount, 16932)
+        {
+        }
+
+        public HeavyCannonball(int amount, int itemID) : base(itemID)
+        {
+            Stackable = true;
+            Amount = amount;
+        }
+
+        public HeavyCannonball(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (Core.EJ)
+            {
+                Replacer.Replace(this, new Cannonball());
+            }
+        }
+    }
+
+    public class LightFlameCannonball : Cannonball, ICommodity
+    {
+        public override int LabelNumber { get { return 1116759; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public override AmmunitionType AmmoType { get { return AmmunitionType.FlameCannonball; } }
+
+        [Constructable]
+        public LightFlameCannonball() : this(1)
+        {
+        }
+
+        [Constructable]
+        public LightFlameCannonball(int amount) : base(amount, 17601)
+        {
+        }
+
+        public LightFlameCannonball(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (Core.EJ)
+            {
+                Replacer.Replace(this, new FlameCannonball());
+            }
+        }
+    }
+
+    public class HeavyFlameCannonball : Cannonball, ICommodity
+    {
+        public override int LabelNumber { get { return 1116267; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public override AmmunitionType AmmoType { get { return AmmunitionType.FlameCannonball; } }
+
+        [Constructable]
+        public HeavyFlameCannonball()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public HeavyFlameCannonball(int amount)
+            : base(amount, 17601)
+        {
+        }
+
+        public HeavyFlameCannonball(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (Core.EJ)
+            {
+                Replacer.Replace(this, new FlameCannonball());
+            }
+        }
+    }
+
+    public class LightFrostCannonball : Cannonball, ICommodity
+    {
+        public override int LabelNumber { get { return 1116759; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public override AmmunitionType AmmoType { get { return AmmunitionType.FrostCannonball; } }
+
+        [Constructable]
+        public LightFrostCannonball()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public LightFrostCannonball(int amount)
+            : base(amount, 16939)
+        {
+        }
+
+        public LightFrostCannonball(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (Core.EJ)
+            {
+                Replacer.Replace(this, new FrostCannonball());
+            }
+        }
+    }
+
+    public class HeavyFrostCannonball : Cannonball, ICommodity
+    {
+        public override int LabelNumber { get { return 1116267; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public override AmmunitionType AmmoType { get { return AmmunitionType.FrostCannonball; } }
+
+        [Constructable]
+        public HeavyFrostCannonball()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public HeavyFrostCannonball(int amount)
+            : base(amount, 16939)
+        {
+        }
+
+        public HeavyFrostCannonball(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (Core.EJ)
+            {
+                Replacer.Replace(this, new FrostCannonball());
+            }
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Cannons and Ammo/CannonDeed.cs

@@ -0,0 +1,221 @@
+using Server;
+using System;
+using Server.Multis;
+using Server.Mobiles;
+using Server.Targeting;
+
+namespace Server.Items
+{
+    public enum CannonPower
+    {
+        Light,
+        Heavy,
+        Massive,
+        Pumpkin
+    }
+
+    public abstract class ShipCannonDeed : Item
+    {
+        public abstract CannonPower CannonType { get; }
+
+        public ShipCannonDeed() : base(5362)
+        {
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                BaseGalleon galleon = BaseGalleon.FindGalleonAt(from, from.Map);
+
+                if (galleon != null)
+                {
+                    if (galleon.Owner == from)
+                    {
+                        from.Target = new InternalTarget(this, galleon);
+                    }
+                    else
+                    {
+                        from.SendLocalizedMessage(1116627); // You must be the owner of the ship to do this.
+                    }
+                }
+                else
+                    from.SendLocalizedMessage(1116625); //You must be on the ship to deploy a weapon.
+            }
+        }
+
+        private class InternalTarget : Target
+        {
+            public ShipCannonDeed Deed { get; set; }
+            public BaseGalleon Galleon { get; set; }
+
+            public InternalTarget(ShipCannonDeed deed, BaseGalleon galleon)
+                : base(2, false, TargetFlags.None)
+            {
+                Deed = deed;
+                Galleon = galleon;
+            }
+
+            protected override void OnTarget(Mobile from, object targeted)
+            {
+                Map map = from.Map;
+
+                if (targeted is IPoint3D)
+                {
+                    Point3D pnt = new Point3D((IPoint3D)targeted);
+
+                    var galleon = BaseGalleon.FindGalleonAt(new Point2D(pnt.X, pnt.Y), map);
+
+                    if (galleon != null && Galleon == galleon)
+                    {
+                        galleon.TryAddCannon(from, pnt, Deed);
+                    }
+                }
+            }
+        }
+
+        public ShipCannonDeed(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class CulverinDeed : ShipCannonDeed
+    {
+        public override CannonPower CannonType { get { return CannonPower.Light; } }
+        public override int LabelNumber { get { return 1095793; } }
+
+        [Constructable]
+        public CulverinDeed()
+        {
+            Hue = 1117;
+        }
+
+        public CulverinDeed(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class CarronadeDeed : ShipCannonDeed
+    {
+        public override CannonPower CannonType { get { return CannonPower.Heavy; } }
+        public override int LabelNumber { get { return 1095794; } }
+
+        [Constructable]
+        public CarronadeDeed()
+        {
+            Hue = 1118;
+        }
+
+        public CarronadeDeed(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class BlundercannonDeed : ShipCannonDeed
+    {
+        public override CannonPower CannonType { get { return CannonPower.Massive; } }
+        public override int LabelNumber { get { return 1095794; } }
+
+        [Constructable]
+        public BlundercannonDeed()
+        {
+            Hue = 1126;
+        }
+
+        public BlundercannonDeed(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class LightShipCannonDeed : ShipCannonDeed
+    {
+        public override CannonPower CannonType { get { return CannonPower.Light; } }
+        public override int LabelNumber { get { return 1095793; } }
+
+        [Constructable]
+        public LightShipCannonDeed()
+        {
+            Hue = 1117;
+        }
+
+        public LightShipCannonDeed(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class HeavyShipCannonDeed : ShipCannonDeed
+    {
+        public override CannonPower CannonType { get { return CannonPower.Heavy; } }
+        public override int LabelNumber { get { return 1095794; } }
+
+        [Constructable]
+        public HeavyShipCannonDeed()
+        {
+            Hue = 1118;
+        }
+
+        public HeavyShipCannonDeed(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Cannons and Ammo/FuseCord.cs

@@ -0,0 +1,46 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    [TypeAlias("Server.Items.Fusecord")]
+    public class FuseCord : Item, ICommodity
+    {
+        public override int LabelNumber { get { return 1116305; } } // fuse cord
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        [Constructable]
+        public FuseCord()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public FuseCord(int amount)
+            : base(0x1420)
+        {
+            Stackable = true;
+            Hue = 1164;
+            Amount = amount;
+        }
+
+        public FuseCord(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Cannons and Ammo/GrapeShot.cs

@@ -0,0 +1,131 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class Grapeshot : Item, ICommodity, ICannonAmmo
+    {
+        public override int LabelNumber { get { return 1116030; } } // grapeshot
+        public override double DefaultWeight { get { return 3.5; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public AmmunitionType AmmoType { get { return AmmunitionType.Grapeshot; } }
+
+        [Constructable]
+        public Grapeshot()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public Grapeshot(int amount)
+            : base(0xA2BF)
+        {
+            Stackable = true;
+            Amount = amount;
+        }
+
+        public Grapeshot(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class LightGrapeshot : Item, ICommodity, ICannonAmmo
+    {
+        public override int LabelNumber { get { return 1116030; } }
+        public override double DefaultWeight { get { return 3.5; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public AmmunitionType AmmoType { get { return AmmunitionType.Grapeshot; } }
+
+        [Constructable]
+        public LightGrapeshot() : this(1)
+        {
+        }
+
+        [Constructable]
+        public LightGrapeshot(int amount) : base(16869)
+        {
+            Stackable = true;
+            Amount = amount;
+        }
+
+        public LightGrapeshot(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (Core.EJ)
+            {
+                Replacer.Replace(this, new Grapeshot());
+            }
+        }
+    }
+
+    public class HeavyGrapeshot : Item, ICommodity, ICannonAmmo
+    {
+        public override int LabelNumber { get { return 1116166; } }
+        public override double DefaultWeight { get { return 7.0; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public AmmunitionType AmmoType { get { return AmmunitionType.Grapeshot; } }
+
+        [Constructable]
+        public HeavyGrapeshot() : this(1)
+        {
+        }
+
+        [Constructable]
+        public HeavyGrapeshot(int amount) : base(16869)
+        {
+            Stackable = true;
+            Amount = amount;
+        }
+
+        public HeavyGrapeshot(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (Core.EJ)
+            {
+                Replacer.Replace(this, new Grapeshot());
+            }
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Cannons and Ammo/Matches.cs

@@ -0,0 +1,146 @@
+using System;
+using Server;
+using Server.Targeting;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class Matches : Item, ICommodity
+    {
+        public override int LabelNumber { get { return 1116112; } }
+
+        private static readonly TimeSpan LightDuration = TimeSpan.FromMinutes(60);
+
+        private bool m_IsLight;
+
+        public bool IsLight { get { return m_IsLight; } set { m_IsLight = value; } }
+
+        [Constructable]
+        public Matches() : this(1)
+        {
+        }
+
+        [Constructable]
+        public Matches(int amount) : base(3947)
+        {
+            Stackable = true;
+            Layer = Layer.TwoHanded;
+            Amount = amount;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                if (Amount > 1)
+                {
+                    Container pack = from.Backpack;
+
+                    if(pack != null)
+                    {
+                        Matches match = new Matches();
+
+                        if (pack.CheckHold(from, match, true))
+                        {
+                            pack.DropItem(match);
+                            this.Amount--;
+
+                            match.ItemID = 2578;
+                            from.SendSound(0x047);
+                            match.IsLight = true;
+                        }
+                        else
+                            match.Delete();
+                    }
+                }
+                else if (!m_IsLight)
+                {
+                    new InternalTimer(this);
+                    from.SendLocalizedMessage(1116114); //You ignite the match.
+
+                    ItemID = 2578;
+                    from.SendSound(0x047);
+                    m_IsLight = true;
+                }
+                else
+                {
+                    from.Target = new InternalTarget(this);
+                    from.SendLocalizedMessage(1116113); //Target the cannon whose fuse you wish to light.
+                }
+            }
+        }
+            
+
+        public void BurnOut()
+        {
+            if (RootParent is PlayerMobile)
+                ((PlayerMobile)RootParent).SendLocalizedMessage(1116115); //Your match splutters and dies.
+
+            Delete();
+        }
+
+        private class InternalTimer : Timer
+        {
+            private Matches m_Match;
+
+            public InternalTimer(Matches match) : base(Matches.LightDuration)
+            {
+                m_Match = match;
+                Start();
+            }
+
+            protected override void OnTick()
+            {
+                if (m_Match != null)
+                    m_Match.BurnOut();
+            }
+        }
+
+        private class InternalTarget : Target
+        {
+            private Matches m_Match;
+
+            public InternalTarget(Matches match) : base (3, false, TargetFlags.None)
+            {
+                m_Match = match;
+            }
+
+            protected override void OnTarget(Mobile from, object obj)
+            {
+                if (obj is IShipCannon)
+                {
+                    IShipCannon cannon = (IShipCannon)obj;
+
+                    if (cannon.CanLight)
+                    {
+                        cannon.LightFuse(from);
+                    }
+                    else
+                    {
+                        from.SendLocalizedMessage(1116078); //There is no fuse to light! Prime the cannon first.
+                    }
+                }
+            }
+        }
+
+        public Matches(Serial serial) : base(serial) { }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+            writer.Write(m_IsLight);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+            if (reader.ReadBool())
+                Delete();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Cannons and Ammo/PowderCharge.cs

@@ -0,0 +1,126 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class PowderCharge : Item, ICommodity
+    {
+        public override int LabelNumber { get { return 1116160; } } // powder charge
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        [Constructable]
+        public PowderCharge()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public PowderCharge(int amount)
+            : base(0xA2BE)
+        {
+            Stackable = true;
+            Amount = amount;
+        }
+
+        public PowderCharge(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class LightPowderCharge : Item, ICommodity
+    {
+        public override int LabelNumber { get { return 1116159; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        [Constructable]
+        public LightPowderCharge() : this(1)
+        {
+        }
+
+        [Constructable]
+        public LightPowderCharge(int amount) : base(16932)
+        {
+            Hue = 2031;
+            Stackable = true;
+            Amount = amount;
+        }
+
+
+        public LightPowderCharge(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (Core.EJ)
+            {
+                Replacer.Replace(this, new PowderCharge());
+            }
+        }
+    }
+
+    public class HeavyPowderCharge : Item, ICommodity
+    {
+        public override int LabelNumber { get { return 1116160; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        [Constructable]
+        public HeavyPowderCharge() : this(1)
+        {
+        }
+
+        [Constructable]
+        public HeavyPowderCharge(int amount)
+            : base(16932)
+        {
+            Hue = 2031;
+            Stackable = true;
+            Amount = amount;
+        }
+
+        public HeavyPowderCharge(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (Core.EJ)
+            {
+                Replacer.Replace(this, new PowderCharge());
+            }
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Cannons and Ammo/Ramrod.cs

@@ -0,0 +1,33 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class Ramrod : Item
+    {
+        public override int LabelNumber { get { return 1095838; } } // ramrod
+
+        [Constructable]
+        public Ramrod()
+            : base(0x4246)
+        {
+        }
+
+        public Ramrod(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Cannons and Ammo/SpecialAmmo.cs

@@ -0,0 +1,245 @@
+/*using System;
+using Server;
+
+namespace Server.Items
+{
+    public class LightScatterShot : Item, ICommodity, ICannonAmmo
+    {
+        public override double DefaultWeight { get { return 4.0; } }
+        public override string DefaultName { get { return "Light Scatter Shot"; } }
+
+        int ICommodity.DescriptionNumber { get { return 0; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public AmmoType AmmoType { get { return AmmoType.Grapeshot; } }
+
+        [Constructable]
+        public LightScatterShot()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public LightScatterShot(int amount)
+            : base(16869)
+        {
+            Stackable = true;
+            Amount = amount;
+            Hue = 898;
+        }
+
+        public LightScatterShot(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class HeavyScatterShot : Item, ICommodity, ICannonAmmo
+    {
+        public override double DefaultWeight { get { return 8.0; } }
+        public override string DefaultName { get { return "Heavy Scatter Shot"; } }
+
+        int ICommodity.DescriptionNumber { get { return 0; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public AmmoType AmmoType { get { return AmmoType.Grapeshot; } }
+
+        [Constructable]
+        public HeavyScatterShot()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public HeavyScatterShot(int amount)
+            : base(16869)
+        {
+            Stackable = true;
+            Amount = amount;
+            Hue = 899;
+        }
+
+        public HeavyScatterShot(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class LightFragShot : Item, ICommodity, ICannonAmmo
+    {
+        public override double DefaultWeight { get { return 6.0; } }
+        public override string DefaultName { get { return "Light Fragmentation Shot"; } }
+
+        int ICommodity.DescriptionNumber { get { return 0; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public AmmoType AmmoType { get { return AmmoType.Grapeshot; } }
+
+        [Constructable]
+        public LightFragShot()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public LightFragShot(int amount)
+            : base(16869)
+        {
+            Stackable = true;
+            Amount = amount;
+            Hue = 390;
+        }
+
+        public LightFragShot(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class HeavyFragShot : Item, ICommodity, ICannonAmmo
+    {
+        public override double DefaultWeight { get { return 12.0; } }
+        public override string DefaultName { get { return "Heavy Fragmentation Shot"; } }
+
+        int ICommodity.DescriptionNumber { get { return 0; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public AmmoType AmmoType { get { return AmmoType.Grapeshot; } }
+
+        [Constructable]
+        public HeavyFragShot()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public HeavyFragShot(int amount)
+            : base(16869)
+        {
+            Stackable = true;
+            Amount = amount;
+            Hue = 391;
+        }
+
+        public HeavyFragShot(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class LightHotShot : Item, ICommodity, ICannonAmmo
+    {
+        public override double DefaultWeight { get { return 6.0; } }
+        public override string DefaultName { get { return "Light Hot Shot"; } }
+
+        int ICommodity.DescriptionNumber { get { return 0; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public AmmoType AmmoType { get { return AmmoType.Cannonball; } }
+
+        [Constructable]
+        public LightHotShot()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public LightHotShot(int amount)
+            : base(16932)
+        {
+            Stackable = true;
+            Amount = amount;
+            Hue = 1288;
+        }
+
+        public LightHotShot(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class HeavyHotShot : Item, ICommodity, ICannonAmmo
+    {
+        public override double DefaultWeight { get { return 12.0; } }
+        public override string DefaultName { get { return "Heavy Hot Shot"; } }
+
+        int ICommodity.DescriptionNumber { get { return 0; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        public AmmoType AmmoType { get { return AmmoType.Cannonball; } }
+
+        [Constructable]
+        public HeavyHotShot()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public HeavyHotShot(int amount)
+            : base(16932)
+        {
+            Stackable = true;
+            Amount = amount;
+            Hue = 1288;
+        }
+
+        public HeavyHotShot(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}*/

Scripts/Services/Expansions/High Seas/Items/Cannons and Ammo/Swab.cs

@@ -0,0 +1,28 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class Swab : Item
+    {
+        [Constructable]
+        public Swab()
+            : base(Utility.RandomMinMax(16968, 16969))
+        {
+        }
+
+        public Swab(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/CorgulAltar.cs

@@ -0,0 +1,454 @@
+using Server;
+using System;
+using Server.Mobiles;
+using System.Collections.Generic;
+using Server.Multis;
+using Server.Regions;
+using Server.Targeting;
+
+namespace Server.Items
+{
+    public class CorgulAltar : Container
+    {
+
+        #region Statics
+        private static TimeSpan ExpireTime = TimeSpan.FromMinutes(180);
+        private static TimeSpan CompleteTime = TimeSpan.FromMinutes(15);
+
+        private static readonly int m_RegionSize = 186;
+
+        private static Rectangle2D[] m_WarpLocations = new Rectangle2D[]
+        {
+                new Rectangle2D(2885, 1373, 500, 800),
+                new Rectangle2D(330,  2940, 400, 400),
+                new Rectangle2D(4040, 2550, 500, 350), 
+                new Rectangle2D(4040, 1755, 500, 250),
+                new Rectangle2D(180,  180,  300, 300)
+        };
+
+        public static Rectangle2D[] WarpLocations { get { return m_WarpLocations; } }
+
+        private static Rectangle2D m_BoatKickLocation = new Rectangle2D(2400, 2500, 500, 500);
+        public static Rectangle2D BoatKickLocation { get { return m_BoatKickLocation; } }
+
+        private static Rectangle2D m_LandKickLocation = new Rectangle2D(2125, 3090, 25, 30);
+        public static Rectangle2D LandKickLocation { get { return m_LandKickLocation; } }
+
+        private static Rectangle2D m_CorgulBounds = new Rectangle2D(6337, 1156, m_RegionSize, m_RegionSize);
+
+        public static Rectangle2D CorgulBounds { get { return m_CorgulBounds; } }
+        #endregion
+
+        private bool m_Activated;
+        private bool m_Active;
+        private CorgulWarpRegion m_WarpRegion;
+        private CorgulRegion m_BossRegion;
+        private Point3D m_WarpPoint;
+        private DateTime m_DeadLine;
+        private Mobile m_Boss;
+        private int m_KeyStage;
+        private List<Item> m_IslandMaps = new List<Item>();
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool Activated {  get { return m_Activated; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool Active 
+        { 
+            get { return m_Active; } 
+            set 
+            { 
+                m_Active = value; 
+                PublicOverheadMessage(Server.Network.MessageType.Regular, 25, false, String.Format("Corgul Altar for {0} has been {1}", this.Map, m_Active ? "activated" : "deactivated")); 
+            } 
+        }
+
+        public CorgulWarpRegion WarpRegion { get { return m_WarpRegion; } }
+        public CorgulRegion BossRegion { get { return m_BossRegion; } }
+
+        private Type[] m_Keys = new Type[] { typeof(TreasureMap), typeof(WorldMap) };
+
+        public static Point3D SpawnLoc = new Point3D(6431, 1236, 10);
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public DateTime DeadLine { get { return m_DeadLine; } }
+
+        public int KeyStage { get { return m_KeyStage; } }
+
+        public override int LabelNumber { get { return 1074818; } }
+
+        public CorgulAltar()
+            : base(13807)
+        {
+            Movable = false;
+            Hue = 2075;
+            m_Activated = false;
+            m_Active = true;
+            m_WarpRegion = null;
+            m_WarpPoint = Point3D.Zero;
+            m_KeyStage = 0;
+
+            Timer.DelayCall(TimeSpan.FromSeconds(1.0), InitializeBossRegion);
+        }
+
+        public void InitializeBossRegion()
+        {
+            m_BossRegion = new CorgulRegion(m_CorgulBounds, this);
+            m_BossRegion.Register();
+        }
+
+        public override void Delete()
+        {
+            Active = false;
+            Reset();
+
+            if (m_BossRegion != null)
+            {
+                m_BossRegion.Unregister();
+                m_BossRegion = null;
+            }
+
+            if (m_WarpRegion != null)
+            {
+                m_WarpRegion.Unregister();
+                m_WarpRegion = null;
+            }
+
+            base.Delete();
+        }
+
+        public override void OnMapChange()
+        {
+            if (m_BossRegion != null)
+            {
+                m_BossRegion.Unregister();
+                InitializeBossRegion();
+            }
+
+            Reset();
+        }
+
+        private Point3D GetRandomWarpPoint()
+        {
+            Rectangle2D rec = m_WarpLocations[Utility.Random(m_WarpLocations.Length)];
+
+            int x = Utility.Random(rec.X, rec.Width);
+            int y = Utility.Random(rec.Y, rec.Height);
+
+            return new Point3D(x, y, -5);
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (!m_Active)
+                from.SendMessage("This altar has been deactivated.");
+            else if (!CheckCanUse(from))
+                from.SendLocalizedMessage(1116791); // You must wait a few minutes before making your sacrifice.
+            else if (from.InRange(this.Location, 3))
+            {
+                from.Target = new InternalTarget(this);
+
+                if (m_KeyStage == 0)
+                    from.SendLocalizedMessage(1116586); // Your offering will be consumed by the altar if the sacrifice is accepted. You will then have 30 seconds to re-use the shrine to mark your map and pay the blood cost.
+            }
+
+        }
+
+        private bool CheckCanUse(Mobile from)
+        {
+            if (m_Activated)
+            {
+                if (this.Map == Map.Trammel)
+                    return false;
+
+                if (m_Boss == null || !m_Boss.Alive || m_Boss.Hits < m_Boss.HitsMax / 2)
+                    return false;
+            }
+
+            return true;
+        }
+
+        private class InternalTarget : Target
+        {
+            private CorgulAltar m_Altar;
+
+            public InternalTarget(CorgulAltar altar) : base(-1, false, TargetFlags.None)
+            {
+                m_Altar = altar;
+            }
+
+            protected override void OnTarget(Mobile from, object targeted)
+            {
+                if (targeted is Item && ((Item)targeted).IsChildOf(from.Backpack) && m_Altar.IsKey((Item)targeted, from))
+                    m_Altar.OnSacraficedItem((Item)targeted, from);
+            }
+        }
+
+        public void OnSacraficedItem(Item item, Mobile from)
+        {
+            if (m_KeyStage == 1)
+            {
+                if (!m_Activated)
+                {
+                    SpawnBoss(from);
+                    m_DeadLineTimer = Timer.DelayCall(ExpireTime, new TimerCallback(OnDeadLine));
+                    m_DeadLine = DateTime.UtcNow + ExpireTime;
+                }
+
+                from.Hits = 0;
+                from.Mana = 0;
+                from.Stam = 2;
+                from.PlaySound(0x244);
+                from.FixedParticles(0x3709, 1, 30, 9965, 5, 7, EffectLayer.Waist);
+                from.FixedParticles(0x376A, 1, 30, 9502, 5, 3, EffectLayer.Waist);
+
+                GiveMap(from);
+                ResetKeys();
+            }
+            else
+            {
+                m_KeyStage = 1;
+                from.SendLocalizedMessage(1116585); // Your offering has been accepted. The price of blood will be taken when your -world map- is marked with the secret location.
+
+                m_KeyResetTimer = Timer.DelayCall(TimeSpan.FromSeconds(30), new TimerCallback(ResetKeys));
+            }
+
+            item.Delete();
+        }
+
+        private void ResetKeys()
+        {
+            m_KeyStage = 0;
+
+            if (m_KeyResetTimer != null)
+                m_KeyResetTimer.Stop();
+
+            m_KeyResetTimer = null;
+        }
+
+        public bool IsKey(Item item, Mobile from)
+        {
+            Type type = item.GetType();
+
+            if (m_KeyStage >= 0 && m_KeyStage < m_Keys.Length && type == m_Keys[m_KeyStage])
+                return true;
+            else if (m_KeyStage == 1 && item is PresetMap && item.LabelNumber == 1041204)
+                return true;
+            else if (m_KeyStage == 1 && item is TreasureMap)
+                from.SendLocalizedMessage(1116360); // The island's location cannot be marked on a treasure map.
+            else if (m_KeyStage == 1 && item is MapItem)
+                from.SendLocalizedMessage(1116358); // The island's location cannot be marked on this map.
+            else
+                from.SendLocalizedMessage(1072682); // This is not the proper key.
+            return false;
+        }
+
+        public void OnBossKilled()
+        {
+            m_ResetTimer = Timer.DelayCall(CompleteTime, new TimerCallback(Reset));
+
+            EndDeadLineTimer();
+
+            if (m_BossRegion == null)
+                return;
+
+            foreach (Mobile m in m_BossRegion.GetMobiles())
+            {
+                if (m is PlayerMobile)
+                    m.SendLocalizedMessage(1072681); // The master of this realm has been slain! You may only stay here so long.
+            }
+        }
+
+        public void OnDeadLine()
+        {
+            if (m_BossRegion == null)
+                return;
+
+            foreach (Mobile m in m_BossRegion.GetMobiles())
+            {
+                if (m is PlayerMobile)
+                    m.SendMessage("You have failed to slay Corgul in time.");
+            }
+            Reset();
+        }
+
+        public void Reset()
+        {
+            m_Activated = false;
+
+            m_WarpPoint = Point3D.Zero;
+
+            if(m_BossRegion != null)
+                m_BossRegion.RemovePlayers(false);
+
+            EndResetTimer();
+            EndDeadLineTimer();
+
+            if (m_Boss != null && !m_Boss.Deleted)
+                m_Boss.Delete();
+
+            m_Boss = null;
+
+            foreach (Item item in m_IslandMaps)
+            {
+                if (item != null && !item.Deleted)
+                    item.Delete();
+            }
+
+            Timer.DelayCall(TimeSpan.FromSeconds(1), UnregisterWarpRegion);
+
+            m_IslandMaps.Clear();
+            ResetKeys();
+        }
+
+        private Timer m_ResetTimer;
+        private Timer m_DeadLineTimer;
+        private Timer m_KeyResetTimer;
+
+        public void EndResetTimer()
+        {
+            if (m_ResetTimer != null)
+                m_ResetTimer.Stop();
+
+            m_ResetTimer = null;
+        }
+
+        public void EndDeadLineTimer()
+        {
+            if (m_DeadLineTimer != null)
+                m_DeadLineTimer.Stop();
+
+            m_DeadLine = DateTime.MinValue;
+            m_DeadLineTimer = null;
+        }
+
+        public void UnregisterWarpRegion()
+        {
+            if (m_WarpRegion != null)
+            {
+                m_WarpRegion.Unregister();
+                m_WarpRegion = null;
+            }
+        }
+
+        public void SpawnBoss(Mobile from)
+        {
+            //Spawn boss
+            CorgulTheSoulBinder boss = new CorgulTheSoulBinder(this);
+            boss.MoveToWorld(SpawnLoc, this.Map);
+            boss.SpawnHelpers();
+            m_Boss = boss;
+
+            //create dummy spawn point and bounds for warp region
+            m_WarpPoint = GetRandomWarpPoint();
+            Rectangle2D bounds = GetRectangle(m_WarpPoint);
+
+            //create region based on dummy spot and bounds
+            m_WarpRegion = new CorgulWarpRegion(this, bounds);
+            m_WarpRegion.Register();
+            m_Activated = true;
+        }
+
+        private void GiveMap(Mobile from)
+        {
+            CorgulIslandMap map = new CorgulIslandMap(m_WarpPoint);
+            from.AddToBackpack(map);
+
+            m_IslandMaps.Add(map);
+
+            from.SendLocalizedMessage(1116359); // The island's location has been marked on your map. You should make haste while the island is still afloat.
+        }
+
+        public static Point3D GetRandomPoint(Rectangle2D rec, Map map)
+        {
+            int x = Utility.Random(rec.X, rec.Width);
+            int y = Utility.Random(rec.Y, rec.Height);
+            int z = map.GetAverageZ(x, y);
+
+            return new Point3D(x, y, z);
+        }
+
+        public Rectangle2D GetRectangle(Point3D pnt)
+        {
+            return new Rectangle2D(pnt.X - (m_RegionSize / 2), pnt.Y - (m_RegionSize / 2), m_RegionSize, m_RegionSize);
+        }
+
+        public CorgulAltar(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)1);
+
+            writer.Write(m_DeadLine);
+            writer.Write(m_Boss);
+            writer.Write(m_Activated);
+            writer.Write(m_Active);
+            writer.Write(m_WarpPoint);
+            //writer.Write(m_IslandMap); Old version 0
+
+            writer.Write(m_IslandMaps.Count);
+            foreach (Item item in m_IslandMaps)
+                writer.Write(item);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            switch (version)
+            {
+                case 1:
+                    {
+                        m_DeadLine = reader.ReadDateTime();
+                        m_Boss = reader.ReadMobile();
+                        m_Activated = reader.ReadBool();
+                        m_Active = reader.ReadBool();
+                        m_WarpPoint = reader.ReadPoint3D();
+
+                        int count = reader.ReadInt();
+                        for (int i = 0; i < count; i++)
+                        {
+                            Item map = reader.ReadItem();
+
+                            if (map != null && !map.Deleted && map is CorgulIslandMap)
+                                m_IslandMaps.Add(map);
+                        }
+
+                        break;
+                    }
+                case 0:
+                    {
+                        m_DeadLine = reader.ReadDateTime();
+                        m_Boss = reader.ReadMobile();
+                        m_Activated = reader.ReadBool();
+                        m_Active = reader.ReadBool();
+                        m_WarpPoint = reader.ReadPoint3D();
+                        //m_IslandMap = reader.ReadItem() as CorgulIslandMap;
+                        Item item = reader.ReadItem();
+                        break;
+                    }
+            }
+
+            InitializeBossRegion();
+
+            if (m_Active && m_Activated && m_WarpPoint != Point3D.Zero)
+            {
+                if (m_DeadLine < DateTime.UtcNow || m_Boss == null || m_Boss.Deleted)
+                    Reset();
+                else
+                {
+                    Rectangle2D bounds = GetRectangle(m_WarpPoint);
+                    m_WarpRegion = new CorgulWarpRegion(this, bounds);
+                    m_WarpRegion.Register();
+                    TimeSpan ts = m_DeadLine - DateTime.UtcNow;
+                    m_DeadLineTimer = Timer.DelayCall(ts, new TimerCallback(OnDeadLine));
+                }
+            }
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Fish/Bait.cs

@@ -0,0 +1,275 @@
+using System;
+using Server;
+using Server.Targeting;
+using Server.Prompts;
+
+namespace Server.Items
+{
+    public class Bait : Item
+    {
+        public static readonly bool UsePrompt = true;
+
+        private Type m_BaitType;
+        private object m_Label;
+        private int m_UsesRemaining;
+        private int m_Index;
+        private bool m_Enhanced;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Type BaitType { get { return m_BaitType; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int UsesRemaining { get { return m_UsesRemaining; } set { m_UsesRemaining = value; InvalidateProperties(); } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int Index
+        {
+            get { return m_Index; }
+            set
+            {
+                m_Index = value;
+
+                if (value < 0)
+                    m_Index = 0;
+                if (value >= FishInfo.FishInfos.Count)
+                    m_Index = FishInfo.FishInfos.Count - 1;
+
+                m_BaitType = FishInfo.GetTypeFromIndex(m_Index);
+                Hue = FishInfo.GetFishHue(m_Index);
+                m_Label = FishInfo.GetFishLabel(m_Index);
+                InvalidateProperties();
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool Enhanced { get { return m_Enhanced; } set { m_Enhanced = value; InvalidateProperties(); } }
+
+        [Constructable]
+        public Bait(int index) : base(2454)
+        {
+            Index = index;
+            m_UsesRemaining = 1;
+        }
+
+        [Constructable]
+        public Bait() : base(2454)
+        {
+            m_UsesRemaining = 1;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                if (UsePrompt && m_UsesRemaining > 1)
+                {
+                    from.SendMessage("How much bait would you like to use?");
+                    from.Prompt = new InternalPrompt(this);
+                }
+                else
+                {
+                    from.Target = new InternalTarget(this, 1);
+                    from.SendMessage("Target the fishing pole or lobster trap that you would like to apply the bait to.");
+                }
+            }
+        }
+
+        public void TryBeginTarget(Mobile from, int amount)
+        {
+            if (amount < 0) amount = 1;
+            if (amount > m_UsesRemaining) amount = m_UsesRemaining;
+
+            from.Target = new InternalTarget(this, amount);
+            from.SendMessage("Target the fishing pole or lobster trap that you would like to apply the bait to.");
+        }
+
+        public override void AddNameProperty(ObjectPropertyList list)
+        {
+            object label = FishInfo.GetFishLabel(m_Index);
+
+            if (m_Enhanced)
+            {
+                //~1_token~ ~2_token~ bait
+                if (label is int)
+                    list.Add(1116464, "#{0}\t#{1}", 1116470, (int)label);
+                else if (label is string)
+                    list.Add(1116464, "#{0}\t{1}", 1116470, (string)label);
+            }
+            else if (label is int)
+                list.Add(1116465, String.Format("#{0}", (int)label)); //~1_token~ bait
+            else if (label is string)
+                list.Add(1116465, (string)label);
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            list.Add(1116466, m_UsesRemaining.ToString());  //amount: ~1_val~
+        }
+
+        private class InternalPrompt : Prompt
+        {
+            private Bait m_Bait;
+
+            public InternalPrompt(Bait bait)
+            {
+                m_Bait = bait;
+            }
+
+            public override void OnResponse(Mobile from, string text)
+            {
+                int amount = Utility.ToInt32( text );
+                m_Bait.TryBeginTarget(from, amount);
+            }
+
+            public override void OnCancel(Mobile from)
+            {
+                from.SendMessage("Not applying bait...");
+            }
+        }
+
+        private class InternalTarget : Target
+        {
+            private Bait m_Bait;
+            private int m_Amount;
+
+            public InternalTarget(Bait bait, int amount)
+                : base(0, false, TargetFlags.None)
+            {
+                m_Bait = bait;
+                m_Amount = amount;
+            }
+
+            protected override void OnTarget(Mobile from, object targeted)
+            {
+                if (targeted == m_Bait)
+                    return;
+
+                if (targeted is FishingPole)
+                {
+                    if (!m_Bait.IsFishBait())
+                    {
+                        from.SendMessage("Think again before applying lobster or crab bait to a fishing pole!");
+                        return;
+                    }
+
+                    FishingPole pole = (FishingPole)targeted;
+
+                    bool hasBait = pole.BaitType != null;
+
+                    if (hasBait && pole.BaitType != m_Bait.BaitType)
+                        from.SendMessage("You swap out the old bait for new.");
+
+                    if (pole.BaitType == m_Bait.BaitType)
+                        pole.BaitUses += m_Amount;
+                    else
+                    {
+                        pole.BaitType = m_Bait.BaitType;
+                        pole.BaitUses += m_Amount;
+                    }
+
+                    if (m_Bait.Enhanced)
+                        pole.EnhancedBait = true;
+
+                    from.SendLocalizedMessage(1149759);  //You bait the hook.
+                    m_Bait.UsesRemaining -= m_Amount;
+                }
+                else if (targeted is LobsterTrap)
+                {
+                    if (m_Bait.IsFishBait())
+                    {
+                        from.SendMessage("Think again before applying fish bait to a lobster trap!");
+                        return;
+                    }
+
+                    LobsterTrap trap = (LobsterTrap)targeted;
+
+                    bool hasBait = trap.BaitType != null;
+
+                    trap.BaitType = m_Bait.BaitType;
+                    //trap.Hue = m_Bait.Hue;
+
+                    if (hasBait && trap.BaitType != m_Bait.BaitType)
+                        from.SendMessage("You swap out the old bait for new.");
+
+                    if (trap.BaitType == m_Bait.BaitType)
+                        trap.BaitUses += m_Amount;
+                    else
+                    {
+                        trap.BaitType = m_Bait.BaitType;
+                        trap.BaitUses += m_Amount;
+                    }
+
+                    if (m_Bait.Enhanced)
+                        trap.EnhancedBait = true;
+
+                    from.SendLocalizedMessage(1149760); //You bait the trap.
+                    m_Bait.UsesRemaining -= m_Amount;
+                }
+                else if (targeted is Bait && ((Bait)targeted).IsChildOf(from.Backpack) && ((Bait)targeted).BaitType == m_Bait.BaitType)
+                {
+                    Bait bait = (Bait)targeted;
+
+                    bait.UsesRemaining += m_Amount;
+                    m_Bait.UsesRemaining -= m_Amount;
+
+                    if (m_Bait.UsesRemaining <= 0)
+                    {
+                        m_Bait.Delete();
+                        from.SendLocalizedMessage(1116469); //You combine these baits into one cup and destroy the other cup.
+                    }
+                    else
+                        from.SendMessage("You combine these baits into one cup.");
+
+                    return;
+                }
+
+                if (m_Bait.UsesRemaining <= 0)
+                {
+                    m_Bait.Delete();
+                    from.SendLocalizedMessage(1116467); //Your bait is used up so you destroy the container.
+                }
+            }
+        }
+
+        public bool IsFishBait()
+        {
+            if (m_BaitType == null)
+                Index = Utility.RandomMinMax(0, 34);
+
+            return !m_BaitType.IsSubclassOf(typeof(BaseCrabAndLobster));
+        }
+
+        public Bait(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+
+            writer.Write(m_UsesRemaining);
+            writer.Write(m_Index);
+            writer.Write(m_Enhanced);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            m_UsesRemaining = reader.ReadInt();
+            m_Index = reader.ReadInt();
+            m_Enhanced = reader.ReadBool();
+
+            if (m_Index < 0)
+                m_Index = 0;
+            if (m_Index >= FishInfo.FishInfos.Count)
+                m_Index = FishInfo.FishInfos.Count - 1;
+
+            m_BaitType = FishInfo.FishInfos[m_Index].Type;
+            //Hue = FishInfo.FishInfos[m_Index].Hue;
+            m_Label = FishInfo.GetFishLabel(m_Index);
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Fish/CrabsAndLobsters.cs

@@ -0,0 +1,703 @@
+using Server;
+using System;
+using Server.Targeting;
+using Server.Misc;
+
+namespace Server.Items
+{
+    public class BaseCrabAndLobster : BaseHighseasFish
+    {
+        public override Item GetCarved { get { return null; } }
+        public override int GetCarvedAmount { get { return 1; } }
+        public override double DefaultWeight { get { return 2.0; } }
+
+        public BaseCrabAndLobster(int itemID) : base(itemID)
+        {
+        }
+
+        public BaseCrabAndLobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class RareCrabAndLobster : BaseCrabAndLobster
+    {
+        private Mobile m_CaughtBy;
+        private DateTime m_DateCaught;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Mobile Fisher { get { return m_CaughtBy; } set { m_CaughtBy = value; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public DateTime DateCaught { get { return m_DateCaught; } set { m_DateCaught = value; } }
+
+        public RareCrabAndLobster(int itemID)
+            : base(itemID)
+        {
+        }
+
+        public RareCrabAndLobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+            writer.Write(m_CaughtBy);
+            writer.Write(m_DateCaught);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+            m_CaughtBy = reader.ReadMobile();
+            m_DateCaught = reader.ReadDateTime();
+        }
+    }
+
+    public class Crab : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1096489; } }
+
+        [Constructable]
+        public Crab()
+            : base(BaseHighseasFish.GetCrabID())
+        {
+        }
+
+        public Crab(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class Lobster : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1096491; } }
+
+        [Constructable]
+        public Lobster()
+            : base(BaseHighseasFish.GetLobsterID())
+        {
+        }
+
+        public Lobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class AppleCrab : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116378; } }
+
+        [Constructable]
+        public AppleCrab() : base (BaseHighseasFish.GetCrabID())
+        {
+        }
+
+        public AppleCrab(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class BlueCrab : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116374; } }
+
+        [Constructable]
+        public BlueCrab()
+            : base(BaseHighseasFish.GetCrabID())
+        {
+        }
+
+        public BlueCrab(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class DungeonessCrab : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116373; } }
+
+        [Constructable]
+        public DungeonessCrab()
+            : base(BaseHighseasFish.GetCrabID())
+        {
+        }
+
+        public DungeonessCrab(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class KingCrab : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116375; } }
+
+        [Constructable]
+        public KingCrab()
+            : base(BaseHighseasFish.GetCrabID())
+        {
+        }
+
+        public KingCrab(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class RockCrab : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116376; } }
+
+        [Constructable]
+        public RockCrab()
+            : base(BaseHighseasFish.GetCrabID())
+        {
+        }
+
+        public RockCrab(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class SnowCrab : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116377; } }
+
+        [Constructable]
+        public SnowCrab()
+            : base(BaseHighseasFish.GetCrabID())
+        {
+        }
+
+        public SnowCrab(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class StoneCrab : RareCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116334; } }
+        public override Item GetCarved { get { return new StoneCrabMeat(); } }
+
+        [Constructable]
+        public StoneCrab()
+            : base(BaseHighseasFish.GetCrabID())
+        {
+            Hue = FishInfo.GetFishHue(typeof(StoneCrab));
+        }
+
+        public StoneCrab(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class SpiderCrab : RareCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116336; } }
+        public override Item GetCarved { get { return new SpiderCrabMeat(); } }
+
+        [Constructable]
+        public SpiderCrab()
+            : base(BaseHighseasFish.GetCrabID())
+        {
+            Hue = FishInfo.GetFishHue(typeof(SpiderCrab));
+        }
+
+        public SpiderCrab(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class TunnelCrab : RareCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116372; } }
+
+        [Constructable]
+        public TunnelCrab()
+            : base(BaseHighseasFish.GetCrabID())
+        {
+            Hue = FishInfo.GetFishHue(typeof(TunnelCrab));
+        }
+
+        public TunnelCrab(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class VoidCrab : RareCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116368; } }
+
+        [Constructable]
+        public VoidCrab()
+            : base(BaseHighseasFish.GetCrabID())
+        {
+            Hue = FishInfo.GetFishHue(typeof(VoidCrab));
+        }
+        public VoidCrab(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class CrustyLobster : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116383; } }
+
+        [Constructable]
+        public CrustyLobster()
+            : base(BaseHighseasFish.GetLobsterID())
+        {
+        }
+
+        public CrustyLobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FredLobster : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116382; } }
+
+        [Constructable]
+        public FredLobster()
+            : base(BaseHighseasFish.GetLobsterID())
+        {
+        }
+
+        public FredLobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class HummerLobster : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116381; } }
+
+        [Constructable]
+        public HummerLobster()
+            : base(BaseHighseasFish.GetLobsterID())
+        {
+        }
+
+        public HummerLobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class RockLobster : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116380; } }
+
+        [Constructable]
+        public RockLobster()
+            : base(BaseHighseasFish.GetLobsterID())
+        {
+        }
+
+        public RockLobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class ShovelNoseLobster : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116384; } }
+
+        [Constructable]
+        public ShovelNoseLobster()
+            : base(BaseHighseasFish.GetLobsterID())
+        {
+        }
+
+        public ShovelNoseLobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class SpineyLobster : BaseCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116379; } }
+
+        [Constructable]
+        public SpineyLobster()
+            : base(BaseHighseasFish.GetLobsterID())
+        {
+        }
+
+        public SpineyLobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class BlueLobster : RareCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116366; } }
+        public override Item GetCarved { get { return new BlueLobsterMeat(); } }
+
+        [Constructable]
+        public BlueLobster()
+            : base(BaseHighseasFish.GetLobsterID())
+        {
+            Hue = FishInfo.GetFishHue(typeof(BlueLobster));
+        }
+
+        public BlueLobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class BloodLobster : RareCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116370; } }
+
+        [Constructable]
+        public BloodLobster()
+            : base(BaseHighseasFish.GetLobsterID())
+        {
+            Hue = FishInfo.GetFishHue(typeof(BloodLobster));
+        }
+
+        public BloodLobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class DreadLobster : RareCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116371; } }
+
+        [Constructable]
+        public DreadLobster()
+            : base(BaseHighseasFish.GetLobsterID())
+        {
+            Hue = FishInfo.GetFishHue(typeof(DreadLobster));
+        }
+
+        public DreadLobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class VoidLobster : RareCrabAndLobster
+    {
+        public override int LabelNumber { get { return 1116369; } }
+
+        [Constructable]
+        public VoidLobster()
+            : base(BaseHighseasFish.GetLobsterID())
+        {
+            Hue = FishInfo.GetFishHue(typeof(VoidLobster));
+        }
+
+        public VoidLobster(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class StoneCrabMeat : Item
+    {
+        public override int LabelNumber { get { return 1116317; } }
+
+        [Constructable]
+        public StoneCrabMeat() : base(4159)
+        {
+            Hue = FishInfo.GetFishHue(typeof(StoneCrab));
+        }
+
+        public StoneCrabMeat(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class SpiderCrabMeat : Item
+    {
+        public override int LabelNumber { get { return 1116320; } }
+
+        [Constructable]
+        public SpiderCrabMeat()
+            : base(4159)
+        {
+            Hue = FishInfo.GetFishHue(typeof(SpiderCrab));
+        }
+
+        public SpiderCrabMeat(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class BlueLobsterMeat : Item
+    {
+        public override int LabelNumber { get { return 1116318; } }
+
+        [Constructable]
+        public BlueLobsterMeat()
+            : base(4159)
+        {
+            Hue = FishInfo.GetFishHue(typeof(BlueLobster));
+        }
+
+        public BlueLobsterMeat(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Fish/FishInfo.cs

@@ -0,0 +1,449 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Server;
+using Server.Multis;
+using Server.Regions;
+using Server.Mobiles;
+using Server.Engines.Quests;
+
+namespace Server.Items
+{
+    public class FishInfo
+    {
+        public static void Configure()
+        {
+            //Rare Fish; 0 - 15
+            m_FishInfos.Add(new FishInfo(2506, typeof(AutumnDragonfish),    1116090, "Ilshenar",                 false, RareChance, 105.4));//Confirmed
+            m_FishInfos.Add(new FishInfo(2591, typeof(BlueLobster),         1116366, "Ice",                      false, RareChance, 103.1)); //Confirmed
+            m_FishInfos.Add(new FishInfo(1157, typeof(BullFish),            1116095, "Labyrinth",                false, RareChance, 105.4)); //Confirmed
+            m_FishInfos.Add(new FishInfo(1167, typeof(CrystalFish),         1116092, "Prism of Light",           false, RareChance, 105.4)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2578, typeof(FairySalmon),         1116089, "TerMur",                   false, RareChance, 85.8)); //Confirmed
+            m_FishInfos.Add(new FishInfo(1461, typeof(FireFish),            1116093, "Shame",                    false, RareChance, 95.8)); //Confirmed
+            m_FishInfos.Add(new FishInfo(1257, typeof(GiantKoi),            1116088, "Tokuno",                   true,  RareChance, 95.8)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2579/*1287*/, typeof(GreatBarracuda),1116100, "Felucca",                true,  RareChance, 89.0)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2959, typeof(HolyMackerel),        1116087, "Gravewater Lake",          false, RareChance, 102.9)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2075, typeof(LavaFish),            1116096, "Abyss",                    false, RareChance, 110.0)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2075/*1152*/, typeof(ReaperFish),  1116094, "Doom",                     false, RareChance, 98.1));  //Confirmed
+            m_FishInfos.Add(new FishInfo(2539, typeof(SpiderCrab),          1116367, "Terathan Keep",            false, RareChance, 103.1)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2558, typeof(StoneCrab),           1116365, "T2A",                      true,  RareChance, 103.1)); //Confirmed
+            m_FishInfos.Add(new FishInfo(43,  typeof(SummerDragonfish),    1116091, "Destard",                   false, RareChance, 105.2));  //Confirmed
+            m_FishInfos.Add(new FishInfo(1154, typeof(UnicornFish),         1116086, "Twisted Weald",            false, RareChance, 110.0)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2515, typeof(YellowtailBarracuda), 1116098, "Trammel",                  true,  RareChance, 81.9));//Confirmed
+
+            //Legendary Fish ; 16-34
+            m_FishInfos.Add(new FishInfo(2406, typeof(AbyssalDragonfish),   1116118, "Destard",                  false, LegendaryChance, 120.0)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2500, typeof(BlackMarlin),         1116099, "Felucca",                  true,  LegendaryChance, 110.1)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2117, typeof(BloodLobster),        1116370, "Shame",                    false, LegendaryChance, 115.1)); //Confirmed
+            m_FishInfos.Add(new FishInfo(0,    typeof(BlueMarlin),          1116097, "Trammel",                  true,  LegendaryChance, 105.0)); //Confirmed
+            m_FishInfos.Add(new FishInfo(1777, typeof(DreadLobster),        1116371, "Doom",                     false, LegendaryChance, 115.1));
+            m_FishInfos.Add(new FishInfo(1158, typeof(DungeonPike),         1116107, "Terathan Keep",            false, LegendaryChance, 105.1)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2576, typeof(GiantSamuraiFish),    1116103, "Tokuno",                   true,  LegendaryChance, 110.1)); //Confirmed
+            m_FishInfos.Add(new FishInfo(1281, typeof(GoldenTuna),          1116102, "Tokuno",                   true,  LegendaryChance, 105.0));  //Confirmed
+            m_FishInfos.Add(new FishInfo(2604, typeof(Kingfish),            1116085, "TrammelAndFelucca",        true,  LegendaryChance, 92.2));   //Confirmed
+            m_FishInfos.Add(new FishInfo(1463, typeof(LanternFish),         1116106, "Prism of Light",           false, LegendaryChance, 105.1));  //Confirmed
+            m_FishInfos.Add(new FishInfo(1283, typeof(RainbowFish),         1116108, "Twisted Weald",            false, LegendaryChance, 105.1));
+            m_FishInfos.Add(new FishInfo(2076, typeof(SeekerFish),          1116109, "Labyrinth",                false, LegendaryChance, 105.1));
+            m_FishInfos.Add(new FishInfo(0,    typeof(SpringDragonfish),    1116104, "Ilshenar",                 false, LegendaryChance, 120.0)); //Confirmed
+            m_FishInfos.Add(new FishInfo(1837, typeof(StoneFish),           1116110, "T2A",                      true,  LegendaryChance, 115.1)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2600, typeof(TunnelCrab),          1116372, "Underworld",               false, LegendaryChance, 115.1)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2069, typeof(VoidCrab),            1116368, "TerMur",                   false, LegendaryChance, 120.0)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2071, typeof(VoidLobster),         1116369, "Abyss",                    false, LegendaryChance, 120.0));
+            m_FishInfos.Add(new FishInfo(2499, typeof(WinterDragonfish),    1116105, "Ice",                      false, LegendaryChance, 120.0)); //Confirmed
+            m_FishInfos.Add(new FishInfo(2551, typeof(ZombieFish),          1116101, "Gravewater Lake",          false, LegendaryChance, 115.1)); //Confirmed
+            
+            //Cannot fish up but used for bait
+            m_FishInfos.Add(new FishInfo(1170, typeof(Charydbis),           1150208, "cannotfishup",     true,      LegendaryChance, 120.0));
+
+            m_InvalidatedLocations = false;
+            Timer.DelayCall(TimeSpan.FromSeconds(10), new TimerCallback(InvalidateLocations));
+        }
+
+        public static List<FishInfo> FishInfos { get { return m_FishInfos; } }
+        private static List<FishInfo> m_FishInfos = new List<FishInfo>();
+
+        private int m_Hue;
+        private Type m_Type;
+        private object m_Label;
+        private object m_Location;
+        private bool m_RequiresDeepWater;
+        private double m_BaseChance;
+        private double m_MinSkill;
+
+        public int Hue { get { return m_Hue; } }
+        public Type Type { get { return m_Type; } }
+        public object LabelNumber { get { return m_Label; } }
+        public object Location { get { return m_Location; } set { m_Location = value; } }
+        public bool RequiresDeepWater { get { return m_RequiresDeepWater; } }
+        public double BaseChance { get { return m_BaseChance; } }
+        public double MinSkill { get { return m_MinSkill; } }
+
+        public static readonly double RareChance = 0.0075;
+        public static readonly double LegendaryChance = 0.001;
+
+        public static bool m_InvalidatedLocations;
+
+        public FishInfo(int hue, Type type, object label, object found, bool deepwater, double basechance, double minskill)
+        {
+            m_Hue = hue;
+            m_Type = type;
+            m_Label = label;
+            m_Location = found;
+            m_RequiresDeepWater = deepwater;
+            m_BaseChance = basechance;
+            m_MinSkill = minskill;
+        }
+
+        public static void InvalidateLocations()
+        {
+            if (m_InvalidatedLocations)
+                return;
+
+            int c = 0;
+
+            foreach (FishInfo info in m_FishInfos)
+            {
+                if (info.Location is string)
+                {
+                    string str = info.Location as string;
+
+                    if (str == "Trammel")
+                    {
+                        info.Location = Map.Trammel;
+                        c++;
+                    }
+                    else if (str == "Felucca")
+                    {
+                        info.Location = Map.Felucca;
+                        c++;
+                    }
+                    else if (str == "Tokuno")
+                    {
+                        info.Location = Map.Tokuno;
+                        c++;
+                    }
+                    else if (str == "Ilshenar")
+                    {
+                        info.Location = Map.Ilshenar;
+                        c++;
+                    }
+                    else if (str == "Malas")
+                    {
+                        info.Location = Map.Malas;
+                        c++;
+                    }
+                    else if (str == "TerMur")
+                    {
+                        info.Location = Map.TerMur;
+                        c++;
+                    }
+                }
+            }
+
+            m_InvalidatedLocations = true;
+            //Console.WriteLine("Invalidated {0} Map Locations in FishInfo.cs", c.ToString());
+        }
+
+        public static bool IsRareFish(Type type)
+        {
+            return m_FishInfos.Any(info => info.Type == type);
+        }
+
+        public static FishInfo GetInfo(Type type)
+        {
+            return m_FishInfos.FirstOrDefault(info => info.Type == type);
+        }
+
+        public static FishInfo GetInfo(int hue)
+        {
+            return m_FishInfos.FirstOrDefault(info => info.Hue == hue);
+        }
+
+        public static int GetIndexFromType(Type type)
+        {
+            if(type == null)
+                return -1;
+
+            for(int i = 0; i < m_FishInfos.Count; i++)
+                if(m_FishInfos[i].Type == type)
+                    return i;
+            return -1;
+        }
+
+        public static Type GetTypeFromIndex(int index)
+        {
+            if(index < 0 || index >= m_FishInfos.Count)
+                return m_FishInfos[0].Type;
+
+            return m_FishInfos[index].Type;
+        }
+
+        public static int GetFishHue(int index)
+        {
+            if (index < 0 || index >= m_FishInfos.Count)
+                return 0;
+
+            return m_FishInfos[index].Hue;
+        }
+
+        public static int GetFishHue(Type type)
+        {
+            foreach (FishInfo info in m_FishInfos)
+                if (info.Type == type)
+                    return info.Hue;
+            return 0;
+        }
+
+        public static object GetFishLabel(int index)
+        {
+            if (index < 0 || index >= m_FishInfos.Count)
+                return 0;
+
+            return m_FishInfos[index].LabelNumber;
+        }
+
+        public static object GetFishLabel(Type type)
+        {
+            foreach (FishInfo info in FishInfos)
+            {
+                if (info.Type == type)
+                    return info.LabelNumber;
+            }
+            return null;
+        }
+
+        public static string GetFishLocation(Type type)
+        {
+            foreach (FishInfo info in FishInfos)
+            {
+                if (info.Type == type)
+                    return info.Location.ToString();
+            }
+            return null;
+        }
+
+        public static Type GetSpecialItem(Mobile from, Item harvestItem, Point3D pnt, bool rareOnly)
+        {
+            return GetSpecialItem(from, harvestItem, pnt, 0, rareOnly);
+        }
+
+        public static Type GetSpecialItem(Mobile from, Item harvestItem, Point3D pnt, double bump, bool rareOnly)
+        {
+            InvalidateLocations();
+
+            Map map = from.Map;
+            Point3D fromLoc = from.Location;
+
+            Region reg = from.Region;
+
+            if (reg.Parent != null)
+                reg = reg.Parent;
+
+            double skill = from.Skills[SkillName.Fishing].Value;
+            bool fishing = harvestItem is FishingPole;
+
+            Type bait = null;
+            Type item = null;
+            bool enhanced = false;
+
+            if (harvestItem is FishingPole)
+            {
+                bait = ((FishingPole)harvestItem).BaitType;
+                enhanced = ((FishingPole)harvestItem).EnhancedBait;
+            }
+            else if (harvestItem is LobsterTrap)
+            {
+                bait = ((LobsterTrap)harvestItem).BaitType;
+                enhanced = ((LobsterTrap)harvestItem).EnhancedBait;
+            }
+
+            //insertion of baited type first to increase chances of fishing it up!
+            List<FishInfo> infos = new List<FishInfo>(m_FishInfos);
+
+            if (bait != null)
+            {
+                for (int i = 0; i < infos.Count; i++)
+                {
+                    FishInfo info = infos[i];
+                    if (info.Type == bait)
+                    {
+                        infos.Remove(info);
+                        infos.Insert(0, info);
+                    }
+                }
+            }
+
+            for (int i = 0; i < infos.Count; i++)
+            {
+                FishInfo info = infos[i];
+
+                double baitStr = info.GetBaitStrength(bait, from, enhanced);
+
+                if ((info.RequiresDeepWater && !IsDeepWater(pnt, map, reg)) || skill < info.MinSkill)
+                    continue;
+
+                if (fishing && info.Type.IsSubclassOf(typeof(BaseCrabAndLobster)))
+                    continue;
+
+                if (!fishing && !info.Type.IsSubclassOf(typeof(BaseCrabAndLobster)))
+                    continue;
+
+                if (info.Location is string)
+                {
+                    string loc = (string)info.Location;
+
+                    if (loc.ToLower() == "cannotfishup")
+                        continue;
+
+                    if (loc.ToLower() == "t2a" && Server.Spells.SpellHelper.IsAnyT2A(map, fromLoc) && info.Roll(from, baitStr, bump))
+                        item = info.Type;
+
+                    if (loc.ToLower() == "trammelandfelucca" && (map == Map.Trammel || map == Map.Felucca) && !Server.Spells.SpellHelper.IsAnyT2A(map, fromLoc) && info.Roll(from, baitStr, bump))
+                        item = info.Type;
+
+                    if (loc.ToLower() == "fire island" && IsFireIsland(fromLoc, map) && info.Roll(from, baitStr, bump))
+                        item = info.Type;
+
+                    if (loc.ToLower() == "gravewater lake" && IsGravewaterLake(fromLoc, map))
+                        item = info.Type;
+
+                    if (from.Region != null && from.Region.IsPartOf(loc) && info.Roll(from, baitStr, bump))
+                        item = info.Type;
+
+                }
+                else if (info.Location is Map)
+                {
+                    Map locMap = (Map)info.Location;
+
+                    if (map == locMap && info.Roll(from, baitStr, bump))
+                        item = info.Type;
+                }
+            }
+
+            ColUtility.Free(infos);
+
+            if (!rareOnly && item == null && from is PlayerMobile)
+            {
+                double chance = skill / 121.5;
+
+                bool dungeon = IsDungeon(pnt, map, reg);
+                bool shore = IsShore(pnt, map, reg);
+                bool deep = IsDeepWater(pnt, map, reg);
+
+                if (fishing && chance >= Utility.RandomDouble())
+                {
+                    if (dungeon && skill >= 106.0)
+                        item = BaseHighseasFish.DungeonFish[Utility.Random(BaseHighseasFish.DungeonFish.Length)];
+                    else if (deep && skill >= 80.0)
+                        item = BaseHighseasFish.DeepWaterFish[Utility.Random(BaseHighseasFish.DeepWaterFish.Length)];
+                    else if(shore && skill >= 50.0)
+                        item = BaseHighseasFish.ShoreFish[Utility.Random(BaseHighseasFish.ShoreFish.Length)];
+                }
+                else if (skill >= 50.0 && !fishing && chance >= Utility.RandomDouble())
+                {
+                    item = BaseHighseasFish.LobstersAndCrabs[Utility.Random(BaseHighseasFish.LobstersAndCrabs.Length)];
+                }
+            }
+
+            return item;
+        }
+
+        public double GetBaitStrength(Type baitType, Mobile from, bool enhanced)
+        {
+            if (baitType != this.Type)
+                return 1.0;
+
+            double str = enhanced ? 3.0 : 2.0;
+
+            for (int i = 0; i < from.Items.Count; i++)
+            {
+                Item item = from.Items[i];
+                if (item is IFishingAttire)
+                {
+                    if (item is ISetItem)
+                    {
+                        if (((ISetItem)item).SetEquipped)
+                        {
+                            str += ((double)((IFishingAttire)item).SetBonus / 100) / (double)((ISetItem)item).Pieces;
+                        }
+                        else
+                        {
+                            str += (double)((IFishingAttire)item).BaitBonus / 100;
+                        }
+                    }
+                    else
+                    {
+                        str += (double)((IFishingAttire)item).BaitBonus / 100;
+                    }
+                }
+            }
+            return str;
+        }
+
+        public bool Roll(Mobile from, double baitStr, double bump)
+        {
+            double baseChance = MagicalFishFinder.HasSchool(from) ? BaseChance * 10 : BaseChance;
+
+            return (baseChance + bump) * baitStr > Utility.RandomDouble();
+        }
+
+        public static bool IsDeepWater(Point3D pnt, Map map, Region region)
+        {
+            return SpecialFishingNet.FullValidation(map, pnt.X, pnt.Y) && !IsDungeon(pnt, map, region);
+        }
+
+        public static bool IsShore(Point3D pnt, Map map, Region region)
+        {
+            return !IsDeepWater(pnt, map, region) && !IsDungeon(pnt, map, region);
+        }
+
+        public static bool IsDungeon(Point3D pnt, Map map, Region region)
+        {
+            return region.IsPartOf<DungeonRegion>() || IsMondainDungeon(region) || Server.Spells.SpellHelper.IsTrammelWind(map, pnt) || Server.Spells.SpellHelper.IsFeluccaWind(map, pnt);
+        }
+
+        public static bool IsMondainDungeon(Region region)
+        {
+            if (region.IsPartOf("Twisted Weald"))
+                return true;
+            if (region.IsPartOf("Sanctuary"))
+                return true;
+            if (region.IsPartOf("Prism of Light"))
+                return true;
+            if (region.IsPartOf("Citadel"))
+                return true;
+            if (region.IsPartOf("Bedlam"))
+                return true;
+            if (region.IsPartOf("Blighted Grove"))
+                return true;
+            if (region.IsPartOf("Painted Caves"))
+                return true;
+            if (region.IsPartOf("Palace of Paroxysmus"))
+                return true;
+            if (region.IsPartOf("Labyrinth"))
+                return true;
+            return false;
+        }
+
+        public static bool IsFireIsland(Point3D p, Map map)
+        {
+            return (map == Map.Felucca || map == Map.Trammel) && (p.X > 4559 && p.X < 4636 && p.Y > 3548 && p.Y < 3627
+                        || p.X > 4465 && p.X < 4493 && p.Y > 4479 && p.Y < 3746);
+        }
+
+        public static bool IsGravewaterLake(Point3D p, Map map)
+        {
+            return map == Map.Malas && ((p.X >= 1440 && p.X <= 1863 && p.Y >= 1527 && p.Y <= 1746) || (p.X >= 1381 && p.X <= 1596 && p.Y >= 1565 && p.Y <= 1789));
+        }
+
+        public static Type[] SOSArtifacts { get { return m_SOSArtifacts; } }
+        private static Type[] m_SOSArtifacts = new Type[]
+        {
+            typeof(AntiqueWeddingDress), typeof(GrapeVine),
+            typeof(KelpWovenLeggings),   typeof(LargeFishingNet),
+            typeof(RunedDriftwoodBow),   typeof(ValkyrieArmor)
+        };
+
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Fish/FishPies.cs

@@ -0,0 +1,690 @@
+using Server;
+using System;
+using Server.Mobiles;
+using Server.Engines.Craft;
+using System.Collections.Generic;
+
+namespace Server.Items
+{
+    public enum FishPieEffect
+    {
+        None,
+        MedBoost,
+        FocusBoost,
+        ColdSoak,
+        EnergySoak,
+        FireSoak,
+        PoisonSoak,
+        PhysicalSoak,
+        WeaponDam,
+        HitChance,
+        DefChance,
+        SpellDamage,
+        ManaRegen,
+        HitsRegen,
+        StamRegen,
+        SoulCharge,
+        CastFocus,
+    }
+
+    public class BaseFishPie : Item, IQuality
+    {
+        private ItemQuality _Quality;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public ItemQuality Quality { get { return _Quality; } set { _Quality = value; InvalidateProperties(); } }
+
+        public bool PlayerConstructed { get { return true; } }
+
+        public virtual TimeSpan Duration { get { return TimeSpan.FromMinutes(5); } }
+        public virtual int BuffName { get { return 0; } }
+        public virtual int BuffAmount { get { return 0; } }
+        public virtual FishPieEffect Effect { get { return FishPieEffect.None; } }
+
+        public static Dictionary<Mobile, List<FishPieEffect>> m_EffectsList = new Dictionary<Mobile, List<FishPieEffect>>();
+
+        public BaseFishPie() : base(4161)
+        {
+            Stackable = true;
+        }
+
+        public virtual int OnCraft(int quality, bool makersMark, Mobile from, CraftSystem craftSystem, Type typeRes, ITool tool, CraftItem craftItem, int resHue)
+        {
+            Quality = (ItemQuality)quality;
+
+            return quality;
+        }
+
+        public static bool IsUnderEffects(Mobile from, FishPieEffect type)
+        {
+            if (!m_EffectsList.ContainsKey(from) || m_EffectsList[from] == null)
+                return false;
+
+            return m_EffectsList[from].Contains(type);
+        }
+
+        public static bool TryAddBuff(Mobile from, FishPieEffect type)
+        {
+            if (IsUnderEffects(from, type))
+                return false;
+
+            if (!m_EffectsList.ContainsKey(from))
+                m_EffectsList.Add(from, new List<FishPieEffect>());
+
+            m_EffectsList[from].Add(type);
+            return true;
+        }
+
+        public static void RemoveBuff(Mobile from, FishPieEffect type)
+        {
+            if(!m_EffectsList.ContainsKey(from))
+                return;
+
+            if (m_EffectsList[from] != null && m_EffectsList[from].Contains(type))
+                m_EffectsList[from].Remove(type);
+
+            if (m_EffectsList[from] == null || m_EffectsList[from].Count == 0)
+                m_EffectsList.Remove(from);
+
+            BuffInfo.RemoveBuff(from, BuffIcon.FishPie);
+            from.Delta(MobileDelta.WeaponDamage);
+        }
+
+        public static void ScaleDamage(Mobile from, Mobile to, ref int totalDamage, int phys, int fire, int cold, int pois, int nrgy, int direct)
+        {
+            if (Core.EJ && from is PlayerMobile && to is PlayerMobile)
+            {
+                return;
+            }
+
+            if (IsUnderEffects(to, FishPieEffect.PhysicalSoak) && phys > 0)
+                totalDamage -= (int)Math.Min(5.0, totalDamage * ((double)phys / 100.0));
+
+            if (IsUnderEffects(to, FishPieEffect.FireSoak) && fire > 0)
+                totalDamage -= (int)Math.Min(5.0, totalDamage * ((double)fire / 100.0));
+
+            if (IsUnderEffects(to, FishPieEffect.ColdSoak) && cold > 0)
+                totalDamage -= (int)Math.Min(5.0, totalDamage * ((double)cold / 100.0));
+
+            if (IsUnderEffects(to, FishPieEffect.PoisonSoak) && pois > 0)
+                totalDamage -= (int)Math.Min(5.0, totalDamage * ((double)pois / 100.0));
+
+            if (IsUnderEffects(to, FishPieEffect.EnergySoak) && nrgy > 0)
+                totalDamage -= (int)Math.Min(5.0, totalDamage * ((double)nrgy / 100.0));
+        }
+
+        public virtual bool Apply(Mobile from)
+        {
+            if (TryAddBuff(from, Effect))
+            {
+                switch (Effect)
+                {
+                    default:
+                    case FishPieEffect.None: break;
+                    case FishPieEffect.MedBoost:
+                        TimedSkillMod mod1 = new TimedSkillMod(SkillName.Meditation, true, 10.0, Duration);
+                        mod1.ObeyCap = true;
+                        from.AddSkillMod(mod1);
+                        break;
+                    case FishPieEffect.FocusBoost:
+                        TimedSkillMod mod2 = new TimedSkillMod(SkillName.Focus, true, 10.0, Duration);
+                        mod2.ObeyCap = true;
+                        from.AddSkillMod(mod2);
+                        break;
+                    case FishPieEffect.ColdSoak: break;
+                    case FishPieEffect.EnergySoak: break;
+                    case FishPieEffect.PoisonSoak: break;
+                    case FishPieEffect.FireSoak: break;
+                    case FishPieEffect.PhysicalSoak: break;
+                    case FishPieEffect.WeaponDam: break;
+                    case FishPieEffect.HitChance: break;
+                    case FishPieEffect.DefChance: break;
+                    case FishPieEffect.SpellDamage: break;
+                    case FishPieEffect.ManaRegen: break;
+                    case FishPieEffect.StamRegen: break;
+                    case FishPieEffect.HitsRegen: break;
+                    case FishPieEffect.SoulCharge: break;
+                    case FishPieEffect.CastFocus: break;
+                }
+
+                if (Effect != FishPieEffect.None)
+                {
+                    new InternalTimer(Duration, from, Effect);
+
+                    BuffInfo.AddBuff(from, new BuffInfo(BuffIcon.FishPie, 1116340, LabelNumber));
+                }
+
+                return true;
+            }
+            else
+                from.SendLocalizedMessage(502173); // You are already under a similar effect.
+            return false;
+        }
+
+        private class InternalTimer : Timer
+        {
+            private Mobile m_From;
+            private FishPieEffect m_EffectType;
+
+            public InternalTimer(TimeSpan duration, Mobile from, FishPieEffect type) : base(duration)
+            {
+                m_From = from;
+                m_EffectType = type;
+                Start();
+            }
+
+            protected override void OnTick()
+            {
+                BaseFishPie.RemoveBuff(m_From, m_EffectType);
+            }
+        }
+
+        public override void AddCraftedProperties(ObjectPropertyList list)
+        {
+            if (_Quality == ItemQuality.Exceptional)
+            {
+                list.Add(1060636); // Exceptional
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            list.Add(BuffName, BuffAmount.ToString());
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (!IsChildOf(from.Backpack))
+            {
+                from.SendLocalizedMessage(1042001); // That must be in your pack for you to use it.
+            }
+            else if (Apply(from))
+            {
+                from.FixedEffect(0x375A, 10, 15);
+                from.PlaySound(0x1E7);
+                from.SendLocalizedMessage(1116285, String.Format("#{0}", LabelNumber)); //You eat the ~1_val~.  Mmm, tasty!
+                Delete();
+            }
+        }
+
+        public BaseFishPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1); // version
+
+            writer.Write((int)_Quality);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            if (version > 0)
+                _Quality = (ItemQuality)reader.ReadInt();
+        }
+    }
+
+    public class AutumnDragonfishPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116224; } }
+        public override int BuffName { get { return 1116280; } }
+        public override int BuffAmount { get { return 10; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.MedBoost; } }
+
+        [Constructable]
+        public AutumnDragonfishPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(AutumnDragonfish));
+        }
+
+        public AutumnDragonfishPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class BullFishPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116220; } }
+        public override int BuffName { get { return 1116276; } }
+        public override int BuffAmount { get { return 5; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.WeaponDam; } }
+
+        [Constructable]
+        public BullFishPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(BullFish));
+        }
+
+        public BullFishPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class CrystalFishPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116219; } }
+        public override int BuffName { get { return 1116275; } }
+        public override int BuffAmount { get { return 5; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.EnergySoak; } }
+
+        [Constructable]
+        public CrystalFishPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(CrystalFish));
+        }
+
+        public CrystalFishPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FairySalmonPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116222; } }
+        public override int BuffName { get { return 1116278; } }
+        public override int BuffAmount { get { return 2; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.CastFocus; } }
+
+        [Constructable]
+        public FairySalmonPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(FairySalmon));
+        }
+
+        public FairySalmonPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class FireFishPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116217; } }
+        public override int BuffName { get { return 1116271; } }
+        public override int BuffAmount { get { return 5; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.FireSoak; } }
+
+        [Constructable]
+        public FireFishPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(FireFish));
+        }
+
+        public FireFishPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class GiantKoiPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116216; } }
+        public override int BuffName { get { return 1116270; } }
+        public override int BuffAmount { get { return 5; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.DefChance; } }
+
+        [Constructable]
+        public GiantKoiPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(GiantKoi));
+        }
+
+        public GiantKoiPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GreatBarracudaPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116214; } }
+        public override int BuffName { get { return 1116269; } }
+        public override int BuffAmount { get { return 5; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.HitChance; } }
+
+        [Constructable]
+        public GreatBarracudaPie()
+        {
+            Hue = 1287;// FishInfo.GetFishHue(typeof(GreatBarracuda));
+        }
+
+        public GreatBarracudaPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class HolyMackerelPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116225; } }
+        public override int BuffName { get { return 1116283; } }
+        public override int BuffAmount { get { return 3; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.ManaRegen; } }
+
+        [Constructable]
+        public HolyMackerelPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(HolyMackerel));
+        }
+
+        public HolyMackerelPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class LavaFishPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116223; } }
+        public override int BuffName { get { return 1116279; } }
+        public override int BuffAmount { get { return 5; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.SoulCharge; } }
+
+        [Constructable]
+        public LavaFishPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(LavaFish));
+        }
+
+        public LavaFishPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class ReaperFishPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116218; } }
+        public override int BuffName { get { return 1116274; } }
+        public override int BuffAmount { get { return 5; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.PoisonSoak; } }
+
+        [Constructable]
+        public ReaperFishPie()
+        {
+            Hue = 1152;// FishInfo.GetFishHue(typeof(ReaperFish));
+        }
+
+        public ReaperFishPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class SummerDragonfishPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116221; } }
+        public override int BuffName { get { return 1116277; } }
+        public override int BuffAmount { get { return 5; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.SpellDamage; } }
+
+        [Constructable]
+        public SummerDragonfishPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(SummerDragonfish));
+        }
+
+        public SummerDragonfishPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class UnicornFishPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116226; } }
+        public override int BuffName { get { return 1116284; } }
+        public override int BuffAmount { get { return 3; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.StamRegen; } }
+
+        [Constructable]
+        public UnicornFishPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(UnicornFish));
+        }
+
+        public UnicornFishPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class YellowtailBarracudaPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116215; } }
+        public override int BuffName { get { return 1116282; } }
+        public override int BuffAmount { get { return 3; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.HitsRegen; } }
+
+        [Constructable]
+        public YellowtailBarracudaPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(YellowtailBarracuda));
+        }
+
+        public YellowtailBarracudaPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class StoneCrabPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116227; } }
+        public override int BuffName { get { return 1116272; } }
+        public override int BuffAmount { get { return 3; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.PhysicalSoak; } }
+
+        [Constructable]
+        public StoneCrabPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(StoneCrab));
+        }
+
+        public StoneCrabPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class SpiderCrabPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116229; } }
+        public override int BuffName { get { return 1116281; } }
+        public override int BuffAmount { get { return 10; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.FocusBoost; } }
+
+        [Constructable]
+        public SpiderCrabPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(SpiderCrab));
+        }
+
+        public SpiderCrabPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class BlueLobsterPie : BaseFishPie
+    {
+        public override int LabelNumber { get { return 1116228; } }
+        public override int BuffName { get { return 1116273; } }
+        public override int BuffAmount { get { return 5; } }
+        public override FishPieEffect Effect { get { return FishPieEffect.ColdSoak; } }
+
+        [Constructable]
+        public BlueLobsterPie()
+        {
+            Hue = FishInfo.GetFishHue(typeof(BlueLobster));
+        }
+
+        public BlueLobsterPie(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Fish/Hooks.cs

@@ -0,0 +1,245 @@
+using Server;
+using System;
+using Server.Targeting;
+
+namespace Server.Items
+{
+    public enum HookType
+    {
+        None,
+        Lava,
+        Dredging,
+        JunkProof
+    }
+
+    [Flipable(19270, 19271)]
+    public class BaseFishingHook : Item
+    {
+        private int m_Uses;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int Uses 
+        {
+            get { return m_Uses; } 
+            set { m_Uses = value; } 
+        }
+
+        public virtual HookType HookType { get { return HookType.None; } }
+        public override int LabelNumber { get { return 1098140; } }
+
+        public BaseFishingHook() : this(50)
+        {
+        }
+
+        public BaseFishingHook(int uses) : base(19270)
+        {
+            m_Uses = uses;
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            int condition = GetCondition(m_Uses);
+            list.Add(1149847, String.Format("#{0}", condition)); //Condition: ~1_val~
+        }
+
+        public static int GetCondition(int uses)
+        {
+            if (uses < 10)
+                return 1149853; //worn
+            else if (uses < 20)
+                return 1149852; //fair
+            else if (uses < 30)
+                return 1149851; //very good
+            else if (uses < 40)
+                return 1149850; //good
+            else if (uses < 50)
+                return 1149849; //excellent
+            else
+                return 1149848; //new
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                from.Target = new InternalTarget(this);
+                //TODO: Message?
+            }
+        }
+
+        public static int GetHookType(HookType type)
+        {
+            switch (type)
+            {
+                case HookType.Lava:
+                    return 1150888;
+                case HookType.Dredging:
+                    return 1150890;
+                case HookType.JunkProof:
+                    return 1150883;
+            }
+            return 0;
+        }
+
+        private class InternalTarget : Target
+        {
+            private BaseFishingHook m_Hook;
+
+            public InternalTarget(BaseFishingHook hook)
+                : base(-1, false, TargetFlags.None)
+            {
+                m_Hook = hook;
+            }
+
+            protected override void OnTarget(Mobile from, object targeted)
+            {
+                if (targeted is FishingPole)
+                {
+                    FishingPole pole = (FishingPole)targeted;
+
+                    if (pole.HookType != HookType.None)
+                    {
+                        Item hook = null;
+
+                        switch (pole.HookType)
+                        {
+                            case HookType.None: break;
+                            case HookType.Lava: hook = new LavaHook(pole.HookUses); break;
+                            case HookType.Dredging: hook = new DredgingHook(pole.HookUses); break;
+                            case HookType.JunkProof: hook = new JunkProofHook(pole.HookUses); break;
+                        }
+
+                        if (hook != null)
+                            from.AddToBackpack(hook);
+                    }
+
+                    pole.HookType = m_Hook.HookType;
+                    pole.HookUses = m_Hook.Uses;
+                    pole.OriginalHue = pole.Hue;
+                    pole.Hue = m_Hook.Hue;
+                    from.SendLocalizedMessage(1150884); //You tie the hook to the fishing line.
+                    m_Hook.Delete();
+                }
+            }
+        }
+
+        public BaseFishingHook(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+            writer.Write(m_Uses);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+            m_Uses = reader.ReadInt();
+        }
+
+    }
+
+    [Flipable(19268, 19269)]
+    public class LavaHook : BaseFishingHook
+    {
+        public override HookType HookType { get { return HookType.Lava; } }
+        public override int LabelNumber { get { return 1150888; } }
+
+        [Constructable]
+        public LavaHook(int uses) : base(uses)
+        {
+            Hue = 2075;
+        }
+
+        [Constructable]
+        public LavaHook()
+        {
+            Hue = 2075;
+        }
+
+        public LavaHook(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    [Flipable(19268, 19269)]
+    public class DredgingHook : BaseFishingHook
+    {
+        public override HookType HookType { get { return HookType.Dredging; } }
+        public override int LabelNumber { get { return 1150890; } }
+
+        [Constructable]
+        public DredgingHook(int uses) : base(uses)
+        {
+            Hue = 33;
+        }
+
+        [Constructable]
+        public DredgingHook()
+        {
+            Hue = 33;
+        }
+
+        public DredgingHook(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    [Flipable(19268, 19269)]
+    public class JunkProofHook : BaseFishingHook
+    {
+        public override HookType HookType { get { return HookType.JunkProof; } }
+        public override int LabelNumber { get { return 1150883; } }
+
+        [Constructable]
+        public JunkProofHook(int uses) : base(uses)
+        {
+            Hue = 99;
+        }
+
+        [Constructable]
+        public JunkProofHook()
+        {
+            Hue = 99;
+        }
+
+        public JunkProofHook(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}
+

Scripts/Services/Expansions/High Seas/Items/Fish/LegendaryFish.cs

@@ -0,0 +1,369 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class AbyssalDragonfish : RareFish
+    {
+        public override int LabelNumber { get { return 1116118; } }
+
+        [Constructable]
+        public AbyssalDragonfish()
+            : base(Utility.RandomMinMax(17637, 17638))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public AbyssalDragonfish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class BlackMarlin : RareFish
+    {
+        public override int LabelNumber { get { return 1116099; } }
+
+        [Constructable]
+        public BlackMarlin()
+            : base(Utility.RandomMinMax(17156, 17157))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public BlackMarlin(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class BlueMarlin : RareFish
+    {
+        public override int LabelNumber { get { return 1116097; } }
+
+        [Constructable]
+        public BlueMarlin()
+            : base(Utility.RandomMinMax(17156, 17157))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public BlueMarlin(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class DungeonPike : RareFish
+    {
+        public override int LabelNumber { get { return 1116107; } }
+
+        [Constructable]
+        public DungeonPike()
+            : base(Utility.RandomMinMax(17603, 17604))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public DungeonPike(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GiantSamuraiFish : RareFish
+    {
+        public override int LabelNumber { get { return 1116103; } }
+
+        [Constructable]
+        public GiantSamuraiFish()
+            : base(Utility.RandomMinMax(17158, 17159))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public GiantSamuraiFish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GoldenTuna : RareFish
+    {
+        public override int LabelNumber { get { return 1116102; } }
+
+        [Constructable]
+        public GoldenTuna()
+            : base(Utility.RandomMinMax(17154, 17155))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public GoldenTuna(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class Kingfish : RareFish
+    {
+        public override int LabelNumber { get { return 1116085; } }
+
+        [Constructable]
+        public Kingfish()
+            : base(Utility.RandomMinMax(17158, 17159))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public Kingfish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class LanternFish : RareFish
+    {
+        public override int LabelNumber { get { return 1116106; } }
+
+        [Constructable]
+        public LanternFish()
+            : base(Utility.RandomMinMax(17605, 17606))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public LanternFish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class RainbowFish : RareFish
+    {
+        public override int LabelNumber { get { return 1116108; } }
+
+        [Constructable]
+        public RainbowFish()
+            : base(Utility.RandomMinMax(17154, 17155))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public RainbowFish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class SeekerFish : RareFish
+    {
+        public override int LabelNumber { get { return 1116109; } }
+
+        [Constructable]
+        public SeekerFish()
+            : base(Utility.RandomMinMax(17158, 17159))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public SeekerFish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class SpringDragonfish : RareFish
+    {
+        public override int LabelNumber { get { return 1116104; } }
+
+        [Constructable]
+        public SpringDragonfish()
+            : base(Utility.RandomMinMax(17637, 17638))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public SpringDragonfish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class StoneFish : RareFish
+    {
+        public override int LabelNumber { get { return 1116110; } }
+
+        [Constructable]
+        public StoneFish()
+            : base(Utility.RandomMinMax(17605, 17606))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public StoneFish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class WinterDragonfish : RareFish
+    {
+        public override int LabelNumber { get { return 1116105; } }
+
+        [Constructable]
+        public WinterDragonfish()
+            : base(Utility.RandomMinMax(17637, 17638))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public WinterDragonfish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class ZombieFish : RareFish
+    {
+        public override int LabelNumber { get { return 1116101; } }
+
+        [Constructable]
+        public ZombieFish()
+            : base(Utility.RandomMinMax(17603, 17604))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public ZombieFish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Fish/RareFish.cs

@@ -0,0 +1,738 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class RareFish : BaseHighseasFish
+    {
+        private Mobile m_CaughtBy;
+        private DateTime m_DateCaught;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Mobile Fisher { get { return m_CaughtBy; } set { m_CaughtBy = value; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public DateTime DateCaught { get { return m_DateCaught; } set { m_DateCaught = value; } }
+
+        public RareFish(int itemID)
+            : base(itemID)
+        {
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            list.Add(1070857, m_CaughtBy != null ? m_CaughtBy.Name : "An Unknown Fisher"); //Caught by ~1_fisherman~
+
+            if (m_DateCaught != DateTime.MinValue)
+                list.Add("[{0}]", m_DateCaught.ToShortDateString());
+        }
+
+        public RareFish(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+            writer.Write(m_CaughtBy);
+            writer.Write(m_DateCaught);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+            m_CaughtBy = reader.ReadMobile();
+            m_DateCaught = reader.ReadDateTime();
+        }
+    }
+
+    public class AutumnDragonfish : RareFish
+    {
+        public override int LabelNumber { get { return 1116090; } }
+        public override Item GetCarved { get { return new AutumnDragonfishSteak(); } }
+
+        [Constructable]
+        public AutumnDragonfish()
+            : base(Utility.RandomMinMax(17637, 17638))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public AutumnDragonfish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class BullFish : RareFish
+    {
+        public override int LabelNumber { get { return 1116095; } }
+        public override Item GetCarved { get { return new BullFishSteak(); } }
+
+        [Constructable]
+        public BullFish()
+            : base(Utility.RandomMinMax(17605, 17606))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public BullFish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class CrystalFish : RareFish
+    {
+        public override int LabelNumber { get { return 1116092; } }
+        public override Item GetCarved { get { return new CrystalFishSteak(); } }
+
+        [Constructable]
+        public CrystalFish()
+            : base(Utility.RandomMinMax(17154, 17155))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public CrystalFish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FairySalmon : RareFish
+    {
+        public override int LabelNumber { get { return 1116089; } }
+        public override Item GetCarved { get { return new FairySalmonSteak(); } }
+
+        [Constructable]
+        public FairySalmon()
+            : base(Utility.RandomMinMax(17154, 17155))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public FairySalmon(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FireFish : RareFish
+    {
+        public override int LabelNumber { get { return 1116093; } }
+        public override Item GetCarved { get { return new FireFishSteak(); } }
+
+        [Constructable]
+        public FireFish()
+            : base(Utility.RandomMinMax(17158, 17159))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public FireFish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GiantKoi : RareFish
+    {
+        public override int LabelNumber { get { return 1116088; } }
+        public override Item GetCarved { get { return new GiantKoiSteak(); } }
+
+        [Constructable]
+        public GiantKoi()
+            : base(Utility.RandomMinMax(17605, 17606))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public GiantKoi(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GreatBarracuda : RareFish
+    {
+        public override int LabelNumber { get { return 1116100; } }
+        public override Item GetCarved { get { return new GreatBarracudaSteak(); } }
+
+        [Constructable]
+        public GreatBarracuda()
+            : base(Utility.RandomMinMax(17603, 17604))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public GreatBarracuda(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class HolyMackerel : RareFish
+    {
+        public override int LabelNumber { get { return 1116087; } }
+        public override Item GetCarved { get { return new HolyMackerelSteak(); } }
+
+        [Constructable]
+        public HolyMackerel()
+            : base(Utility.RandomMinMax(17154, 17155))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public HolyMackerel(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class LavaFish : RareFish
+    {
+        public override int LabelNumber { get { return 1116096; } }
+        public override Item GetCarved { get { return new LavaFishSteak(); } }
+
+        [Constructable]
+        public LavaFish()
+            : base(Utility.RandomMinMax(17156, 17157))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public LavaFish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class ReaperFish : RareFish
+    {
+        public override int LabelNumber { get { return 1116094; } }
+        public override Item GetCarved { get { return new ReaperFishSteak(); } }
+
+        [Constructable]
+        public ReaperFish()
+            : base(Utility.RandomMinMax(17603, 17604))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public ReaperFish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class SummerDragonfish : RareFish
+    {
+        public override int LabelNumber { get { return 1116091; } }
+        public override Item GetCarved { get { return new SummerDragonfishSteak(); } }
+
+        [Constructable]
+        public SummerDragonfish()
+            : base(Utility.RandomMinMax(17637, 17638))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public SummerDragonfish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class UnicornFish : RareFish
+    {
+        public override int LabelNumber { get { return 1116086; } }
+        public override Item GetCarved { get { return new UnicornFishSteak(); } }
+
+        [Constructable]
+        public UnicornFish()
+            : base(Utility.RandomMinMax(17156, 17157))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public UnicornFish(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class YellowtailBarracuda : RareFish
+    {
+        public override int LabelNumber { get { return 1116098; } }
+        public override Item GetCarved { get { return new YellowtailBarracudaSteak(); } }
+
+        [Constructable]
+        public YellowtailBarracuda()
+            : base(Utility.RandomMinMax(17603, 17604))
+        {
+            Hue = FishInfo.GetFishHue(this.GetType());
+        }
+
+        public YellowtailBarracuda(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class AutumnDragonfishSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116314; } }
+
+        [Constructable]
+        public AutumnDragonfishSteak()
+        {
+            Hue = FishInfo.GetFishHue(typeof(AutumnDragonfish));
+        }
+
+        public AutumnDragonfishSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class BullFishSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116310; } }
+
+        [Constructable]
+        public BullFishSteak()
+        {
+            Hue = FishInfo.GetFishHue(typeof(BullFish));
+        }
+
+        public BullFishSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class CrystalFishSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116309; } }
+
+        [Constructable]
+        public CrystalFishSteak()
+        {
+            Hue = FishInfo.GetFishHue(typeof(CrystalFish));
+        }
+
+        public CrystalFishSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FairySalmonSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116312; } }
+
+        [Constructable]
+        public FairySalmonSteak()
+        {
+            Hue = FishInfo.GetFishHue(typeof(FairySalmon));
+        }
+
+        public FairySalmonSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class FireFishSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116307; } }
+
+        [Constructable]
+        public FireFishSteak()
+        {
+            Hue = FishInfo.GetFishHue(typeof(FireFish));
+        }
+
+        public FireFishSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class GiantKoiSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116306; } }
+
+        [Constructable]
+        public GiantKoiSteak()
+        {
+            Hue = FishInfo.GetFishHue(typeof(GiantKoi));
+        }
+
+        public GiantKoiSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GreatBarracudaSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116298; } }
+
+        [Constructable]
+        public GreatBarracudaSteak()
+        {
+            Hue = 1287; // FishInfo.GetFishHue(typeof(GreatBarracuda));
+        }
+
+        public GreatBarracudaSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class HolyMackerelSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116315; } }
+
+        [Constructable]
+        public HolyMackerelSteak()
+        {
+            Hue = FishInfo.GetFishHue(typeof(HolyMackerel));
+        }
+
+        public HolyMackerelSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class LavaFishSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116313; } }
+
+        [Constructable]
+        public LavaFishSteak()
+        {
+            Hue = FishInfo.GetFishHue(typeof(LavaFish));
+        }
+
+        public LavaFishSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class ReaperFishSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116308; } }
+
+        [Constructable]
+        public ReaperFishSteak()
+        {
+            Hue = 1152; // FishInfo.GetFishHue(typeof(ReaperFish));
+        }
+
+        public ReaperFishSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class SummerDragonfishSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116311; } }
+
+        [Constructable]
+        public SummerDragonfishSteak()
+        {
+            Hue = FishInfo.GetFishHue(typeof(SummerDragonfish));
+        }
+
+        public SummerDragonfishSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+
+    public class UnicornFishSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116316; } }
+
+        [Constructable]
+        public UnicornFishSteak()
+        {
+            Hue = FishInfo.GetFishHue(typeof(UnicornFish));
+        }
+
+        public UnicornFishSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class YellowtailBarracudaSteak : RawFishSteak
+    {
+        public override int LabelNumber { get { return 1116301; } }
+
+        [Constructable]
+        public YellowtailBarracudaSteak()
+        {
+            Hue = FishInfo.GetFishHue(typeof(YellowtailBarracuda));
+        }
+
+        public YellowtailBarracudaSteak(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Fish/Trophies.cs

@@ -0,0 +1,416 @@
+using Server;
+using System;
+using Server.Mobiles;
+using Server.Multis;
+using System.Linq;
+
+namespace Server.Items
+{
+    public enum TrophyStyle
+    {
+        Marlin,
+        Dragonfish,
+        BoardGrouper,
+        BoardMahi,
+        Lobster,
+        Crab
+    }
+
+    public class FishTrophyDeed : Item
+    {
+        private int m_Weight;
+        private Mobile m_Fisher;
+        private DateTime m_DateCaught;
+        private int m_DeedName;
+        private int m_TrophyName;
+        private int m_TrophyID;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Mobile Fisher { get { return m_Fisher; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int TrophyWeight { get { return m_Weight; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public DateTime DateCaught { get { return m_DateCaught; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int TrophyName { get { return m_TrophyName; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int DeedName { get { return m_DeedName; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int TrophyID { get { return m_TrophyID; } }
+
+        public override int LabelNumber { get { return m_DeedName; } }
+
+        public FishTrophyDeed(int weight, Mobile fisher, DateTime caught, int deedname, int trophyname, int id) : base(0x14F0)
+        {
+            m_Weight = weight;
+            m_Fisher = fisher;
+            m_DateCaught = caught;
+            m_DeedName = deedname;
+            m_TrophyName = trophyname;
+            m_TrophyID = id;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                BaseHouse house = BaseHouse.FindHouseAt(from);
+
+                if (house != null && house.IsCoOwner(from))
+                {
+                    bool northWall = BaseAddon.IsWall(from.X, from.Y - 1, from.Z, from.Map);
+                    bool westWall = BaseAddon.IsWall(from.X - 1, from.Y, from.Z, from.Map);
+
+                    if (northWall && westWall)
+                    {
+                        switch (from.Direction & Direction.Mask)
+                        {
+                            case Direction.North:
+                            case Direction.South: northWall = true; westWall = false; break;
+
+                            case Direction.East:
+                            case Direction.West: northWall = false; westWall = true; break;
+
+                            default: from.SendMessage("Turn to face the wall on which to hang this trophy."); return;
+                        }
+                    }
+
+                    BaseAddon addon = null;
+
+                    if (northWall)
+                        addon = ConstructTrophy(true);
+                    else if (westWall)
+                        addon = ConstructTrophy(false);
+                    else
+                        from.SendLocalizedMessage(1042626); // The trophy must be placed next to a wall.
+
+                    if (addon != null)
+                    {
+                        house.Addons[addon] = from;
+                        addon.MoveToWorld(from.Location, from.Map);
+                        Delete();
+                    }
+                }
+                else
+                {
+                    from.SendLocalizedMessage(502092); // You must be in your house to do this.
+                }
+            }
+            else
+            {
+                from.SendLocalizedMessage(1042001); // That must be in your pack for you to use it.
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            if (m_Weight >= 20)
+            {
+                if (m_Fisher != null)
+                    list.Add(1070857, m_Fisher.Name); // Caught by ~1_fisherman~
+
+                list.Add(1070858, m_Weight.ToString()); // ~1_weight~ stones
+            }
+        }
+
+        public BaseAddon ConstructTrophy(bool north)
+        {
+            BaseAddon addon = null;
+            switch (m_TrophyID)
+            {
+                case 0: addon = new FishTrophy(typeof(AutumnDragonfish),  TrophyStyle.Dragonfish, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 1: addon = new FishTrophy(typeof(BullFish),          TrophyStyle.BoardMahi, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 2: addon = new FishTrophy(typeof(FireFish),          TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 3: addon = new FishTrophy(typeof(GiantKoi),          TrophyStyle.BoardMahi, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 4: addon = new FishTrophy(typeof(LavaFish),          TrophyStyle.Marlin, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 5: addon = new FishTrophy(typeof(SummerDragonfish),  TrophyStyle.Dragonfish, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 6: addon = new FishTrophy(typeof(UnicornFish),       TrophyStyle.Marlin, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 7: addon = new FishTrophy(typeof(AbyssalDragonfish), TrophyStyle.Dragonfish, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 8: addon = new FishTrophy(typeof(BlackMarlin),       TrophyStyle.Marlin, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 9: addon = new FishTrophy(typeof(BlueMarlin),        TrophyStyle.Marlin, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 10: addon = new FishTrophy(typeof(GiantSamuraiFish), TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 11: addon = new FishTrophy(typeof(Kingfish),         TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 12: addon = new FishTrophy(typeof(LanternFish),      TrophyStyle.BoardMahi, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 13: addon = new FishTrophy(typeof(SeekerFish),       TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 14: addon = new FishTrophy(typeof(SpringDragonfish), TrophyStyle.Dragonfish, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 15: addon = new FishTrophy(typeof(StoneFish),        TrophyStyle.BoardMahi, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 16: addon = new FishTrophy(typeof(WinterDragonfish), TrophyStyle.Dragonfish, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+
+                case 17: addon = new FishTrophy(typeof(BlueLobster),      TrophyStyle.Lobster, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 18: addon = new FishTrophy(typeof(BloodLobster),     TrophyStyle.Lobster, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 19: addon = new FishTrophy(typeof(DreadLobster),     TrophyStyle.Lobster, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 20: addon = new FishTrophy(typeof(VoidLobster),      TrophyStyle.Lobster, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 21: addon = new FishTrophy(typeof(StoneCrab),        TrophyStyle.Crab, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 22: addon = new FishTrophy(typeof(SpiderCrab),       TrophyStyle.Crab, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 23: addon = new FishTrophy(typeof(TunnelCrab),       TrophyStyle.Crab, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 24: addon = new FishTrophy(typeof(VoidCrab),         TrophyStyle.Crab, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+
+                case 25: addon = new FishTrophy(typeof(CrystalFish),         TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 26: addon = new FishTrophy(typeof(FairySalmon),         TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 27: addon = new FishTrophy(typeof(GreatBarracuda),      TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 28: addon = new FishTrophy(typeof(HolyMackerel),        TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 29: addon = new FishTrophy(typeof(ReaperFish),          TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 30: addon = new FishTrophy(typeof(YellowtailBarracuda), TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 31: addon = new FishTrophy(typeof(DungeonPike),         TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 32: addon = new FishTrophy(typeof(GoldenTuna),          TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 33: addon = new FishTrophy(typeof(RainbowFish),         TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+                case 34: addon = new FishTrophy(typeof(ZombieFish),          TrophyStyle.BoardGrouper, north, m_TrophyName, m_Weight, m_Fisher, m_DateCaught); break;
+            }
+            return addon;
+        }
+
+        public FishTrophyDeed(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+
+            writer.Write(m_Weight);
+            writer.Write(m_Fisher);
+            writer.Write(m_DateCaught);
+            writer.Write(m_TrophyName);
+            writer.Write(m_DeedName);
+            writer.Write(m_TrophyID);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            m_Weight = reader.ReadInt();
+            m_Fisher = reader.ReadMobile();
+            m_DateCaught = reader.ReadDateTime();
+            m_TrophyName = reader.ReadInt();
+            m_DeedName = reader.ReadInt();
+            m_TrophyID = reader.ReadInt();
+        }
+    }
+
+    public class FishTrophy : BaseAddon
+    {
+        private int m_FishWeight;
+        private Mobile m_Fisher;
+        private DateTime m_DateCaught;
+        private Type m_TypeName;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Mobile Fisher { get { return m_Fisher; } }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public DateTime DateCaught { get { return m_DateCaught; } }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int FishWeight { get { return m_FishWeight; } }
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Type TypeName { get { return m_TypeName; } }
+
+        public FishTrophy(Type type, TrophyStyle style, bool north, int label, int weight, Mobile fisher, DateTime datecaught)
+        {
+            int hue = FishInfo.GetFishHue(type);
+            m_TypeName = type;
+
+            m_FishWeight = weight;
+            m_Fisher = fisher;
+            m_DateCaught = datecaught;
+
+            switch(style)
+            {
+                case TrophyStyle.Marlin:
+                    {
+                        if(north)
+                        {
+                            AddComponent(new TrophyComponent(17641, label, hue), 0, 0, 0);
+                            AddComponent(new TrophyComponent(17642, label, hue), -1, 0, 0); 
+                            AddComponent(new TrophyComponent(17643, label, hue), 1, 0, 0); 
+                        }
+                        else
+                        {
+                            AddComponent(new TrophyComponent(17644, label, hue), 0, 0, 0); 
+                            AddComponent(new TrophyComponent(17645, label, hue), 0, 1, 0); 
+                            AddComponent(new TrophyComponent(17646, label, hue), 0, -1, 0); 
+                        }
+                        break;
+                    }
+                case TrophyStyle.Dragonfish:
+                    {
+                        if (north)
+                            AddComponent(new TrophyComponent(17639, label, hue), 0, 0, 0);
+                        else
+                            AddComponent(new TrophyComponent(17640, label, hue), 0, 0, 0);
+                        break;
+                    }
+                case TrophyStyle.BoardMahi:
+                    {
+                        if (north)
+                        {
+                            AddComponent(new TrophyComponent(19283, label, 0), 0, 0, 0);
+                            AddComponent(new TrophyComponent(19287, label, hue), 0, 0, 0);
+                        }
+                        else
+                        {
+                            AddComponent(new TrophyComponent(19282, label, 0), 0, 0, 0);
+                            AddComponent(new TrophyComponent(19286, label, hue), 0, 0, 0);
+                        }
+                        break;
+                    }
+                case TrophyStyle.BoardGrouper:
+                    {
+                        if (north)
+                        {
+                            AddComponent(new TrophyComponent(19281, label, 0), 0, 0, 0);
+                            AddComponent(new TrophyComponent(19285, label, hue), 0, 0, 0);
+                        }
+                        else
+                        {
+                            AddComponent(new TrophyComponent(19280, label, 0), 0, 0, 0);
+                            AddComponent(new TrophyComponent(19284, label, hue), 0, 0, 0);
+                        }
+                        break;
+                    }
+                case TrophyStyle.Crab:
+                    {
+                        if (north)
+                        {
+                            AddComponent(new TrophyComponent(18106, label, hue), 0, 0, 0);
+                        }
+                        else
+                        {
+                            AddComponent(new TrophyComponent(18107, label, hue), 0, 0, 0);
+                        }
+                        break;
+                    }
+                case TrophyStyle.Lobster:
+                    {
+                        if (north)
+                        {
+                            AddComponent(new TrophyComponent(18108, label, hue), 0, 0, 0);
+                        }
+                        else
+                        {
+                            AddComponent(new TrophyComponent(18109, label, hue), 0, 0, 0);
+                        }
+                        break;
+                    }
+            }
+        }
+
+        public Item TrophyDeed
+        {
+            get
+            {
+                var info = TaxidermyKit.TrophyInfos.FirstOrDefault(i => i.CreatureType == m_TypeName);
+
+                if (info != null)
+                {
+                    return new FishTrophyDeed(m_FishWeight, m_Fisher, m_DateCaught, info.DeedNumber, info.AddonNumber, info.NorthID);
+                }
+
+                return null;
+            }
+        }
+
+        public override void OnChop(Mobile from)
+        {
+            if (Components.Count > 0)
+            {
+                OnComponentUsed(Components[0], from);
+            }
+        }
+
+        public override void OnComponentUsed(AddonComponent c, Mobile from)
+        {
+            if (m_TypeName == null)
+                return;
+
+            var info = TaxidermyKit.TrophyInfos.FirstOrDefault(i => i.CreatureType == m_TypeName);
+
+            if (info != null)
+            {
+                BaseHouse house = BaseHouse.FindHouseAt(c);
+
+                if (house != null && (house.IsCoOwner(from) || (house.Addons.ContainsKey(this) && house.Addons[this] == from)))
+                {
+                    from.AddToBackpack(new FishTrophyDeed(m_FishWeight, m_Fisher, m_DateCaught, info.DeedNumber, info.AddonNumber, info.NorthID));
+
+                    if(house.Addons.ContainsKey(this))
+                        house.Addons.Remove(this);
+
+                    Delete();
+                }
+                else
+                {
+                    from.SendLocalizedMessage(502092); // You must be in your house to do this.
+                }
+            }
+        }
+
+        public FishTrophy(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+            writer.Write(m_TypeName.Name);
+            writer.Write(m_FishWeight);
+            writer.Write(m_Fisher);
+            writer.Write(m_DateCaught);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            string name = reader.ReadString();
+            m_TypeName = ScriptCompiler.FindTypeByName(name);
+            m_FishWeight = reader.ReadInt();
+            m_Fisher = reader.ReadMobile();
+            m_DateCaught = reader.ReadDateTime();
+        }
+    }
+
+    public class TrophyComponent : LocalizedAddonComponent
+    {
+        public override bool ForceShowProperties { get { return true; } }
+
+        public TrophyComponent(int itemID, int label, int hue) : base(itemID, label)
+        {
+            Hue = hue;
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            if (Addon != null && Addon is FishTrophy)
+            {
+                FishTrophy trophy = Addon as FishTrophy;
+
+                list.Add(1070858, trophy.FishWeight.ToString());
+                list.Add(1070857, trophy.Fisher != null ? trophy.Fisher.Name : "Unknown");
+                list.Add(String.Format("[{0}]", trophy.DateCaught.ToShortDateString()));
+            }
+        }
+
+        public TrophyComponent(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/IslandMap.cs

@@ -0,0 +1,41 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class CorgulIslandMap : SeaChart
+    {
+        private Point3D m_DestinationPoint;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Point3D DestinationPoint { get { return m_DestinationPoint; } }
+
+        [Constructable]
+        public CorgulIslandMap(Point3D pnt)
+        {
+            Name = "Island Map";
+            m_DestinationPoint = pnt;
+            AddWorldPin(pnt.X, pnt.Y);
+            Protected = true;
+        }
+
+        public CorgulIslandMap(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+            writer.Write(m_DestinationPoint);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+            m_DestinationPoint = reader.ReadPoint3D();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/LavaFishItems.cs

@@ -0,0 +1,407 @@
+using Server;
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class StoneFootwear : BaseShoes
+    {
+        public static void Initialize()
+        {
+            EventSink.Movement += new MovementEventHandler(EventSink_Movement);
+        }
+
+        [Constructable]
+        public StoneFootwear() : this(Utility.Random(5899, 8))
+        {
+        }
+
+        [Constructable]
+        public StoneFootwear(int itemID) 
+            : base(itemID)
+        {
+            string name = GetNameInfo(ItemID);
+
+            if (name == "thigh boots")
+            {
+                Weight = 4.0;
+            }
+            else if (name == "boots")
+            {
+                Weight = 3.0;
+            }
+            else if (name == "shoes")
+            {
+                Weight = 2.0;
+            }
+            else if (name == "sandals")
+            {
+                Weight = 1.0;
+            }
+
+            StrRequirement = 10;
+        }
+
+        public string GetNameInfo(int itemID)
+        {
+            string name = "foot wear";
+            switch (itemID)
+            {
+                case 5899:
+                case 5900: name = "boots"; break;
+                case 5901:
+                case 5902: name = "sandals"; break;
+                case 5903:
+                case 5904: name = "shoes"; break;
+                case 5905:
+                case 5906: name = "thigh boots"; break;
+            }
+            return name;
+        }
+
+        public override void OnAdded(object parent)
+        {
+            if (parent is Mobile)
+            {
+                Mobile m = (Mobile)parent as Mobile;                
+
+                if (SpiderWebbing.IsTrapped(m))
+                {
+                    SpiderWebbing.RemoveEffects(m);                    
+                }
+
+                m.SendLocalizedMessage(1151094, GetNameInfo(ItemID)); // You manage to equip the stone ~1_token~ and find you can no longer move!
+            }
+        }
+
+        public override void AddNameProperty(ObjectPropertyList list)
+        {
+            list.Add(1151095, GetNameInfo(ItemID)); // stone ~1_token~
+        }
+
+        public static void EventSink_Movement(MovementEventArgs e)
+        {
+            Mobile from = e.Mobile;
+
+            if (from != null && from.Alive)
+            {
+                Item item = from.FindItemOnLayer(Layer.Shoes);
+
+                if (item is StoneFootwear)
+                    e.Blocked = true;
+            }
+        }
+
+        public StoneFootwear(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (version < 1)
+            {
+                string name = GetNameInfo(ItemID);
+
+                if (name == "thigh boots")
+                {
+                    Weight = 4.0;
+                }
+                else if (name == "boots")
+                {
+                    Weight = 3.0;
+                }
+                else if (name == "shoes")
+                {
+                    Weight = 2.0;
+                }
+                else if (name == "sandals")
+                {
+                    Weight = 1.0;
+                }
+
+                StrRequirement = 10;
+            }
+        }
+    }
+
+    public class CrackedLavaRockSouth : Item
+    {
+        public override int LabelNumber { get { return 1098151; } }
+
+        [Constructable]
+        public CrackedLavaRockSouth() : base(19279)
+        {
+        }
+
+        public virtual void OnCrack(Mobile from)
+        {
+            Item item;
+
+            switch (Utility.Random(5))
+            {
+                default:
+                case 0: item = new GeodeEast(); break;
+                case 1: item = new GeodeSouth(); break;
+                case 2: item = new GeodeShardEast(); break;
+                case 3: item = new GeodeShardSouth(); break;
+                case 4: item = new LavaRock(); break;
+            }
+
+            if (item != null)
+            {
+                from.AddToBackpack(item);
+                from.SendMessage("You have split the lava rock!");
+                Delete();
+            }
+        }
+
+        public CrackedLavaRockSouth(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class CrackedLavaRockEast : Item
+    {
+        public override int LabelNumber { get { return 1098151; } }
+
+        [Constructable]
+        public CrackedLavaRockEast() : base(19275)
+        {
+        }
+
+        public virtual void OnCrack(Mobile from)
+        {
+            Item item;
+            from.SendSound(0x3B3);
+
+            if (from.RawStr < Utility.Random(150))
+            {
+                from.SendMessage("You swing, but fail to crack the rock any further.");
+                return;
+            }
+
+            switch (Utility.Random(5))
+            {
+                default:
+                case 0: item = new GeodeEast(); break;
+                case 1: item = new GeodeSouth(); break;
+                case 2: item = new GeodeShardEast(); break;
+                case 3: item = new GeodeShardSouth(); break;
+                case 4: item = new LavaRock(); break;
+            }
+
+            if (item != null)
+            {
+                from.AddToBackpack(item);
+                from.SendMessage("You have split the lava rock!");
+                Delete();
+            }
+        }
+
+        public CrackedLavaRockEast(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GeodeSouth : Item
+    {
+        public override int LabelNumber { get { return 1098145; } }
+
+        [Constructable]
+        public GeodeSouth() : base(Utility.Random(19277, 2))
+        {
+            switch (Utility.Random(4))
+            {
+                case 0: Hue = 2658; break;
+                case 1: Hue = 2659; break;
+                case 2: Hue = 2660; break;
+                case 3: Hue = 2654; break;
+            }
+        }
+
+        public GeodeSouth(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GeodeEast : Item
+    {
+        public override int LabelNumber { get { return 1098145; } }
+
+        [Constructable]
+        public GeodeEast() : base(Utility.Random(19273, 2))
+        {
+            switch (Utility.Random(4))
+            {
+                case 0: Hue = 2658; break;
+                case 1: Hue = 2659; break;
+                case 2: Hue = 2660; break;
+                case 3: Hue = 2654; break;
+            }
+        }
+
+        public GeodeEast(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GeodeShardSouth : Item
+    {
+        public override int LabelNumber { get { return 1098148; } }
+
+        [Constructable]
+        public GeodeShardSouth() : base(19276)
+        {
+            switch (Utility.Random(4))
+            {
+                case 0: Hue = 2658; break;
+                case 1: Hue = 2659; break;
+                case 2: Hue = 2660; break;
+                case 3: Hue = 2654; break;
+            }
+        }
+
+        public GeodeShardSouth(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class GeodeShardEast : Item
+    {
+        public override int LabelNumber { get { return 1098148; } }
+
+        [Constructable]
+        public GeodeShardEast() : base(19272)
+        {
+            switch (Utility.Random(4))
+            {
+                case 0: Hue = 2658; break;
+                case 1: Hue = 2659; break;
+                case 2: Hue = 2660; break;
+                case 3: Hue = 2654; break;
+            }
+        }
+
+        public GeodeShardEast(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class LavaRock : Item
+    {
+        public override int LabelNumber { get { return 1151166; } }
+
+        [Constructable]
+        public LavaRock() : base(Utility.Random(4964, 6))
+        {
+            Hue = 1175;
+        }
+
+        public LavaRock(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class StonePaver : Item
+    {
+        public override int LabelNumber { get { return 1097277; } }
+
+        [Constructable]
+        public StonePaver()
+            : base(Utility.RandomList(18396, 18397, 18398, 18399, 18400, 18405, 18652, 18653, 18654, 18655))
+        {
+            Weight = 5;
+        }
+
+        public StonePaver(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/LavaLobsterTrap.cs

@@ -0,0 +1,37 @@
+using Server;
+using System;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Targeting;
+
+namespace Server.Items
+{
+    public class LavaLobsterTrap : LobsterTrap
+    {
+        [Constructable]
+        public LavaLobsterTrap()
+        {
+        }
+
+        public override int[] UseableTiles { get { return Server.Engines.Harvest.Fishing.LavaTiles; } }
+
+        public override void AddNameProperty(ObjectPropertyList list)
+        {
+            list.Add(1116474); //lava lobster trap
+        }
+
+        public LavaLobsterTrap(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/LobsterTrap.cs

@@ -0,0 +1,473 @@
+using Server;
+using System;
+using System.Collections.Generic;
+using Server.Mobiles;
+using Server.Targeting;
+using Server.Network;
+using Server.Engines.PartySystem;
+
+namespace Server.Items
+{
+    [Flipable(17615, 17616)]
+    public class LobsterTrap : Container, ITelekinesisable
+    {
+        public static readonly int TrapID = Utility.RandomMinMax(17615, 17616);
+        public static readonly int BuoyID = 17611;
+        public static readonly int MaxCatch = 5;
+
+        private Type m_BaitType;
+        private bool m_EnhancedBait;
+        private int m_BaitUses;
+        private bool m_InUse;
+        private Timer m_Timer;
+        private Mobile m_Owner;
+        private int m_Bobs;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Type BaitType 
+        { 
+            get { return m_BaitType; } 
+            set 
+            { 
+                m_BaitType = value;
+
+                if (m_BaitType == null)
+                {
+                    m_EnhancedBait = false;
+                    m_BaitUses = 0;
+                }
+
+                InvalidateProperties(); 
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool EnhancedBait { get { return m_EnhancedBait; } set { m_EnhancedBait = value; InvalidateProperties(); } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int BaitUses { get { return m_BaitUses; } set { m_BaitUses = value; InvalidateProperties(); } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool InUse { get { return m_InUse; } set { m_InUse = value; InvalidateProperties(); } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Mobile Owner { get { return m_Owner; } set { m_Owner = value; InvalidateProperties(); } }
+
+        public override int LabelNumber { get { if (m_Owner == null) return 1096487; else return 0; } }
+        public override bool DisplaysContent { get { return false; } }
+
+        [Constructable]
+        public LobsterTrap() : base(17615)
+        {
+        }
+
+        public void OnTelekinesis(Mobile from)
+        {
+            if (m_InUse && ItemID == BuoyID && CanUseTrap(from))
+                EndTimer(from);
+        }
+
+        public override bool OnDragDropInto(Mobile from, Item item, Point3D p)
+        {
+            return false;
+        }
+
+        public override bool OnDragDrop(Mobile from, Item dropped)
+        {
+            return false;
+        }
+
+        public override bool TryDropItem(Mobile from, Item dropped, bool sendFullMessage)
+        {
+            return false;
+        }
+
+        public override void AddNameProperty(ObjectPropertyList list)
+        {
+            if (ItemID == TrapID)
+            {
+                if (Items.Count == 0)
+                    list.Add(1116389); //empty lobster trap
+                else if (Items.Count >= MaxCatch)
+                    list.Add(1149599); //full lobster trap
+                else
+                    list.Add(1096487); //lobster trap
+            }
+            else
+            {
+                if (m_Owner == null)
+                    list.Add(1096487); //lobster trap
+                else
+                    list.Add(1116390, m_Owner.Name);
+            }
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            if (m_BaitType != null)
+            {
+                object label = FishInfo.GetFishLabel(m_BaitType);
+                if (label is int)
+                    list.Add(1116468, String.Format("#{0}", (int)label)); //baited to attract: ~1_val~
+                else if (label is string)
+                    list.Add(1116468, (string)label);
+
+                list.Add(1116466, m_BaitUses.ToString());
+            }
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (IsChildOf(from.Backpack))
+            {
+                if (ItemID == BuoyID)
+                    ItemID = TrapID;
+
+                if (Items.Count > 0)
+                {
+                    DumpContents(from);
+                    from.SendMessage("You dump the contents of the lobster trap into your pack.");
+                }
+                else
+                {
+                    from.SendLocalizedMessage(500974); //What water do you want to fish in?
+                    from.BeginTarget(-1, true, TargetFlags.None, new TargetCallback(OnTarget));
+                }
+            }
+            else if (ItemID == BuoyID)
+            {
+                if (RootParent != null)
+                    ItemID = TrapID;
+
+                InvalidateProperties();
+
+                if (CanUseTrap(from))
+                    EndTimer(from);
+
+                InvalidateProperties();
+            }
+            else
+            {
+                from.SendLocalizedMessage( 1042001 ); // That must be in your pack for you to use it.
+            }
+        }
+
+        private void DumpContents(Mobile from)
+        {
+            Container pack = from.Backpack;
+
+            foreach (Item item in new List<Item>(this.Items))
+            {
+                if (item == null)
+                    continue;
+
+                if (!pack.TryDropItem(from, item, false))
+                    item.MoveToWorld(from.Location, from.Map);
+
+                from.SendLocalizedMessage(1116386, String.Format("#{0}", item.LabelNumber));
+            }
+        }
+
+        public void OnTarget(Mobile from, object targeted)
+        {
+            if (Deleted || m_InUse)
+                return;
+
+            IPoint3D pnt = (IPoint3D)targeted;
+            Map map = from.Map;
+
+            if (map == null || map == Map.Internal)
+                return;
+
+            int x = pnt.X; int y = pnt.Y; int z = pnt.Z;
+
+            if (!from.InRange(pnt, 6))
+            {
+                from.SendLocalizedMessage(1116388); // The trap is too cumbersome to deploy that far away.
+            }
+            else if (!IsValidTile(targeted, map))
+                from.SendMessage("You cannot deploy a trap there!"); //TODO: Get Cliloc
+            else if (!IsValidLocation(x, y, z, map))
+                from.SendLocalizedMessage(1116393); //The location is too close to another trap.
+            else
+            {
+                m_Owner = from;
+                ItemID = BuoyID;
+                InvalidateProperties();
+                Movable = false;
+                MoveToWorld(new Point3D(x, y, z), map);
+                m_Bobs = 0;
+                m_InUse = true;
+                StartTimer();
+
+                Effects.PlaySound(this, map, Utility.Random(0x025, 3));
+                Effects.SendMovingEffect(from, this, TrapID, 7, 0, false, false);
+            }
+        }
+
+        public void StartTimer()
+        {
+            if (m_Timer != null)
+                m_Timer.Stop();
+
+            m_Timer = Timer.DelayCall(TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1), new TimerCallback(OnTick));
+        }
+
+        public void EndTimer(Mobile from)
+        {
+            if (m_Timer != null)
+            {
+                m_Timer.Stop();
+                m_Timer = null;
+            }
+
+            if (from == null) from = m_Owner;
+            if (from == null)
+                return;
+
+            Movable = true;
+            ItemID = TrapID;
+            InvalidateProperties();
+            m_InUse = false;
+
+            if (RootParent == null)
+            {
+                if (from.Backpack == null || !from.Backpack.TryDropItem(from, this, false))
+                    this.MoveToWorld(from.Location, from.Map);
+            }
+        }
+
+        public void OnTick()
+        {
+            m_Bobs++;
+
+            PublicOverheadMessage(MessageType.Regular, 0, 1116364); //**bob**
+
+            if (m_Owner != null && (!SpecialFishingNet.ValidateDeepWater(Map, X, Y) || m_Owner.Skills[SkillName.Fishing].Base >= 75.0))
+            {
+                m_Owner.CheckSkill(SkillName.Fishing, 0, m_Owner.Skills[SkillName.Fishing].Cap);
+            }
+
+            if (!m_InUse)
+            {
+                EndTimer(null);
+                return;
+            }
+
+            if (m_Bobs * 5 > Utility.Random(100))
+            {
+                OnTrapLost();
+                return;
+            }
+
+            bool rare = true;
+            double bump = (double)m_Bobs / 100.0;
+
+            Type type = FishInfo.GetSpecialItem(m_Owner, this, this.Location, bump, this is LavaLobsterTrap);
+
+            if (type != null)
+            {
+                Item item = Loot.Construct(type);
+                DropItem(item);
+
+                if (item is RareCrabAndLobster && rare)
+                {
+                    RareCrabAndLobster fish = (RareCrabAndLobster)item;
+
+                    fish.Fisher = m_Owner;
+                    fish.DateCaught = DateTime.UtcNow;
+                    fish.Weight = Utility.RandomMinMax(10, 200);
+                    fish.Stackable = false;
+                }
+
+                if (m_Owner != null)
+                    m_Owner.SendMessage("It looks like you caught something!");
+
+                CheckBait();
+            }
+            else if (Utility.RandomBool())
+            {
+                Item item;
+
+                if (Utility.RandomBool())
+                    item = new Crab();
+                else
+                    item = new Lobster();
+
+                if (m_Owner != null)
+                    m_Owner.SendMessage("It looks like you caught something!");
+
+                DropItem(item);
+                CheckBait();
+            }
+        }
+
+        private void CheckBait()
+        {
+            if (m_BaitType != null)
+            {
+                BaitUses--;
+
+                if (m_BaitUses == 0)
+                {
+                    BaitType = null;
+                    EnhancedBait = false;
+
+                    if (m_Owner != null)
+                        m_Owner.SendMessage("You have used up the bait on your lobster trap.");
+                }
+            }
+        }
+
+        public void OnTrapLost()
+        {
+            if (m_Timer != null)
+                m_Timer.Stop();
+
+            Effects.PlaySound(this, this.Map, Utility.Random(0x025, 3));
+
+            IPooledEnumerable eable = this.GetMobilesInRange(12);
+            foreach (Mobile mob in eable)
+            {
+                if (mob is PlayerMobile && m_Owner != null)
+                    mob.SendLocalizedMessage(1116385, m_Owner.Name); //~1_NAME~'s trap bouy is pulled beneath the waves.
+            }
+            eable.Free();
+
+            Delete();
+        }
+
+        private bool CanUseTrap(Mobile from)
+        {
+            if (m_Owner == null || RootParent != null)
+                return false;
+
+            if (!from.InRange(this.Location, 6))
+            {
+                from.SendLocalizedMessage(500295); //You are too far away to do that.
+                return false;
+            }
+
+            //is owner, or in same guild
+            if (m_Owner == from || (from.Guild != null && from.Guild == m_Owner.Guild))
+                return true;
+
+            //partied
+            if (Party.Get(from) == Party.Get(m_Owner))
+                return true;
+
+            //fel rules
+            if (from.Map != null && from.Map.Rules == MapRules.FeluccaRules)
+            {
+                from.CriminalAction(true);
+                from.SendLocalizedMessage(1149823); //The owner of the lobster trap notices you committing a criminal act!
+
+                if (m_Owner != null)
+                    m_Owner.SendMessage("You notice {0} taking your lobster trap out of the water!", from.Name);
+
+                return true;
+            }
+
+            from.SendLocalizedMessage(1116391); //You realize that the trap isn't yours so you leave it alone.
+            return false;
+        }
+
+        public virtual bool IsValidTile(object targeted, Map map)
+        {
+            int tileID = 0;
+
+            if (targeted is LandTarget)
+            {
+                LandTarget obj = (LandTarget)targeted;
+                tileID = obj.TileID;
+            }
+
+            else if (targeted is StaticTarget)
+            {
+                StaticTarget obj = (StaticTarget)targeted;
+                tileID = obj.ItemID;
+            }
+
+            for (int i = 0; i < UseableTiles.Length; i++)
+            {
+                if (UseableTiles[i] == tileID)
+                    return true;
+            }
+            return false;
+        }
+
+        public bool IsValidLocation(int x, int y, int z, Map map)
+        {
+            IPooledEnumerable eable = map.GetItemsInRange(new Point3D(x, y, z), 1);
+
+            foreach (Item item in eable)
+            {
+                if (item is LobsterTrap)
+                {
+                    eable.Free();
+                    return false;
+                }
+            }
+            eable.Free();
+            return true;
+        }
+
+        public virtual int[] UseableTiles { get { return m_WaterTiles; } }
+        private int[] m_WaterTiles = new int[]
+        {
+            //Deep Water
+            0x00AA, 0x00A9, 
+            0x00A8, 0x00AB,
+            0x0136, 0x0137,
+            //Shallow Water
+            0x5797, 0x579C,
+            0x746E, 0x7485,
+            0x7490, 0x74AB,
+            0x74B5, 0x75D5,
+            //Static tiles
+            0x1797, 0x1798,
+            0x1799, 0x179A,
+            0x179B, 0x179C,
+
+        };
+
+        public LobsterTrap(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+
+            int index = FishInfo.GetIndexFromType(m_BaitType);
+            writer.Write(index);
+            writer.Write(m_Bobs);
+            writer.Write(m_InUse);
+            writer.Write(m_Owner);
+            writer.Write(m_BaitUses);
+            writer.Write(m_EnhancedBait);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            int index = reader.ReadInt();
+            m_BaitType = FishInfo.GetTypeFromIndex(index);
+
+            m_Bobs = reader.ReadInt();
+            m_InUse = reader.ReadBool();
+            m_Owner = reader.ReadMobile();
+            m_BaitUses = reader.ReadInt();
+            m_EnhancedBait = reader.ReadBool();
+
+            if (m_BaitType != null && m_BaitUses <= 0)
+                BaitType = null;
+
+            if (m_InUse)
+                StartTimer();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/OracleOfTheSea.cs

@@ -0,0 +1,58 @@
+using Server;
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class OracleOfTheSea : Spyglass
+    {
+        public static readonly int MaxUses = 5;
+
+        public override int LabelNumber { get { return 1150184; } }
+
+        private int m_UsesRemaining;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int UsesRemaining { get { return m_UsesRemaining; } set { m_UsesRemaining = value; InvalidateProperties(); } }
+
+        [Constructable]
+        public OracleOfTheSea()
+        {
+            Hue = 1265;
+            Weight = 3.0;
+            m_UsesRemaining = 5;
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+            list.Add(1060728, "{0}\t{1}", m_UsesRemaining.ToString(), MaxUses.ToString());
+            list.Add(1150207, "#{0}\t", 1150208);
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (m_UsesRemaining <= 0 || !IsChildOf(from.Backpack))
+                base.OnDoubleClick(from);
+
+            if (CharydbisSpawner.SpawnInstance != null && CharydbisSpawner.SpawnInstance.TrySpawnCharybdis(from))
+                UsesRemaining--;
+        }
+
+        public OracleOfTheSea(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+            writer.Write(m_UsesRemaining);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+            m_UsesRemaining = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Resources/BlackPowder.cs

@@ -0,0 +1,45 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class BlackPowder : Item, ICommodity
+    {
+        public override int LabelNumber { get { return 1095826; } } // black powder
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        [Constructable]
+        public BlackPowder()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public BlackPowder(int amount)
+            : base(0x423A)
+        {
+            Stackable = true;
+            Amount = amount;
+            Hue = 1109;
+        }
+
+        public BlackPowder(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Resources/Charcoal.cs

@@ -0,0 +1,45 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class Charcoal : Item, ICommodity
+    {
+        public override int LabelNumber { get { return 1116303; } } // charcoal
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        [Constructable]
+        public Charcoal()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public Charcoal(int amount)
+            : base(0x423A)
+        {
+            Stackable = true;
+            Amount = amount;
+            Hue = 1190;
+        }
+
+        public Charcoal(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Resources/Cooking Ingrediants.cs

@@ -0,0 +1,178 @@
+using Server;
+using System;
+using Server.Targeting;
+
+namespace Server.Items
+{
+    public class MentoSeasoning : Item
+    {
+        public override int LabelNumber { get { return 1116299; } }
+
+        [Constructable]
+        public MentoSeasoning()
+            : base(2454)
+        {
+            Hue = 95;
+        }
+
+        public MentoSeasoning(Serial serial) : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class SamuelsSecretSauce : Item
+    {
+        public override int LabelNumber { get { return 1116338; } }
+
+        [Constructable]
+        public SamuelsSecretSauce() : base(2463)
+        {
+            Hue = 1461;
+        }
+
+        public SamuelsSecretSauce(Serial serial) : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class DarkTruffle : Item
+    {
+        public override int LabelNumber { get { return 1116300; } }
+
+        [Constructable]
+        public DarkTruffle()
+            : base(3352)
+        {
+            Hue = 1908;
+        }
+
+        public DarkTruffle(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FreshGinger : Item
+    {
+        public override int LabelNumber { get { return 1031235; } }
+
+        [Constructable]
+        public FreshGinger()
+            : base(11235)
+        {
+        }
+
+        public FreshGinger(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FishOilFlask : Item
+    {
+        public override int LabelNumber { get { return 1150863; } }
+
+        [Constructable]
+        public FishOilFlask()
+            : base(7192)
+        {
+            Hue = 2404;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if(IsChildOf(from.Backpack))
+                from.Target = new InternalTarget(this);
+        }
+
+        private class InternalTarget : Target
+        {
+            private FishOilFlask m_Flask;
+
+            public InternalTarget(FishOilFlask flask) : base(-1, false, TargetFlags.None)
+            {
+                m_Flask = flask;
+            }
+
+            protected override void OnTarget(Mobile from, object targeted)
+            {
+                if (targeted is OracleOfTheSea)
+                {
+                    if (((OracleOfTheSea)targeted).UsesRemaining >= 5)
+                        from.SendMessage("That is already fully charged!");
+                    else
+                    {
+                        ((OracleOfTheSea)targeted).UsesRemaining = 5;
+                        from.SendMessage("You charge the oracle with the fish oil.");
+                        m_Flask.Delete();
+                    }
+                }
+            }
+        }
+
+        public FishOilFlask(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Resources/MatchCord.cs

@@ -0,0 +1,39 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class Matchcord : Item, ICommodity
+    {
+        public override int LabelNumber { get { return 1095184; } }
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        [Constructable]
+        public Matchcord() : this(1) { }
+
+        [Constructable]
+        public Matchcord(int amount)
+            : base(5153)
+        {
+            Hue = 1171;
+            Stackable = true;
+            Amount = amount;
+        }
+
+        public Matchcord(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Resources/Niter.cs

@@ -0,0 +1,211 @@
+using System;
+using Server;
+using System.Collections.Generic;
+using Server.Engines.Harvest;
+
+namespace Server.Items
+{
+
+    public class NiterDeposit : Item
+    {
+        public enum NiterSize
+        {
+            Gigantic = 1,
+            Massive,
+            Huge,
+            Large,
+            Small
+        }
+
+        private NiterSize m_Size;
+        private int m_Hits;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int Hits 
+        { 
+            get 
+            { 
+                return m_Hits; 
+            } 
+            set
+            { 
+                m_Hits = value; 
+                InvalidateSize();
+            } 
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public NiterSize Size 
+        { 
+            get { return m_Size; }
+            set 
+            { 
+                m_Size = value; 
+                InvalidateID(); 
+            }
+        }
+
+        public override bool Decays { get { return true; } }
+
+        [Constructable]
+        public NiterDeposit() : this(Utility.RandomMinMax(1, 5))
+        {
+        }
+
+        [Constructable]
+        public NiterDeposit(int size)
+        {
+            if (size < 1) size = 1;
+            if (size > 5) size = 5;
+
+            m_Hits = 40 * size;
+            InvalidateSize();
+            Movable = false;
+        }
+
+        public void OnMine(Mobile from, Item tool)
+        {
+            if (tool is IUsesRemaining && ((IUsesRemaining)tool).UsesRemaining < 1)
+                return;
+
+            from.Direction = from.GetDirectionTo(this.Location);
+            from.Animate(11, 5, 1, true, false, 0);
+
+            Timer.DelayCall(TimeSpan.FromSeconds(1), new TimerStateCallback(DoMine), new object[] { from, tool });
+        }
+
+        public void DoMine(object obj)
+        {
+            object[] os = (object[])obj;
+            Mobile from = (Mobile)os[0];
+            Item tool = (Item)os[1];
+
+            if (from != null && from.CheckSkill(SkillName.Mining, 60.0, 100.0))
+            {
+                Container pack = from.Backpack;
+                int count = 1;
+
+                if (from.Skills[SkillName.Mining].Value > 100 && Utility.RandomBool())
+                    count++;
+
+                from.SendLocalizedMessage(1149924, count.ToString()); //You extract ~1_COUNT~ saltpeter from the niter deposit.
+                Saltpeter sp = new Saltpeter(count);
+
+                if (pack == null || !pack.TryDropItem(from, sp, false))
+                    sp.MoveToWorld(from.Location, from.Map);
+
+                Hits--;
+
+                from.PlaySound(Utility.RandomMinMax(0x125, 0x126));
+                CheckTool(tool);
+
+                if (m_Hits <= 0)
+                {
+                    from.SendMessage("You have mined the last of the niter deposit.");
+                    Delete();
+                    return;
+                }
+            }
+            else
+                from.SendLocalizedMessage(1149923);  //You mine the niter deposit but fail to produce any usable saltpeter.
+        }
+
+        public void CheckTool(Item tool)
+        {
+            if (tool != null && tool is IUsesRemaining)
+            {
+                IUsesRemaining toolWithUses = (IUsesRemaining)tool;
+
+                toolWithUses.ShowUsesRemaining = true;
+
+                if (toolWithUses.UsesRemaining > 0)
+                    --toolWithUses.UsesRemaining;
+
+                if (toolWithUses.UsesRemaining < 1)
+                    tool.Delete();
+            }
+        }
+
+        public void InvalidateSize()
+        {
+            if (m_Hits > 160)
+                Size = NiterSize.Gigantic;
+            else if (m_Hits > 120)
+                Size = NiterSize.Massive;
+            else if (m_Hits > 80)
+                Size = NiterSize.Huge;
+            else if (m_Hits > 40)
+                Size = NiterSize.Large;
+            else
+                Size = NiterSize.Small;
+        }
+
+        public void InvalidateID()
+        {
+            switch (m_Size)
+            {
+                default:
+                case NiterSize.Gigantic: ItemID = 4962; break;
+                case NiterSize.Massive: ItemID = 4961; break;
+                case NiterSize.Huge: ItemID = 4967; break;
+                case NiterSize.Large: ItemID = 4964; break;
+                case NiterSize.Small: ItemID = 4965; break;
+            }
+        }
+
+        public override void AddNameProperty(ObjectPropertyList list)
+        {
+            list.Add(1149912, m_Size.ToString());
+        }
+
+        public static bool HasBeenChecked(HarvestBank bank)
+        {
+            if (m_BankTable.ContainsKey(bank) && m_BankTable[bank] < DateTime.UtcNow)
+                m_BankTable.Remove(bank);
+
+            return m_BankTable.ContainsKey(bank);
+        }
+
+        private static Dictionary<HarvestBank, DateTime> m_BankTable = new Dictionary<HarvestBank, DateTime>();
+
+        public static void AddBank(HarvestBank bank)
+        {
+            if (bank == null)
+                return;
+
+            m_BankTable[bank] = DateTime.UtcNow + TimeSpan.FromMinutes(5);
+        }
+
+        public void DefragBanks()
+        {
+            List<HarvestBank> toRemove = new List<HarvestBank>();
+
+            foreach (KeyValuePair<HarvestBank, DateTime> kvp in m_BankTable)
+                if (kvp.Value < DateTime.UtcNow)
+                    toRemove.Add(kvp.Key);
+
+            foreach (HarvestBank bank in toRemove)
+                m_BankTable.Remove(bank);
+        }
+
+        public NiterDeposit(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+            writer.Write(m_Hits);
+            writer.Write((int)m_Size);
+
+            Timer.DelayCall(TimeSpan.FromSeconds(30), new TimerCallback(DefragBanks));
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+            m_Hits = reader.ReadInt();
+            m_Size = (NiterSize)reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Resources/Potash.cs

@@ -0,0 +1,45 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class Potash : Item, ICommodity
+    {
+        public override int LabelNumber { get { return 1116319; } } // potash
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        [Constructable]
+        public Potash()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public Potash(int amount)
+            : base(0x423A)
+        {
+            Stackable = true;
+            Amount = amount;
+            Hue = 1102;
+        }
+
+        public Potash(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Resources/SaltPeter.cs

@@ -0,0 +1,45 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public class Saltpeter : Item, ICommodity
+    {
+        public override int LabelNumber { get { return 1116302; } } // saltpeter
+
+        TextDefinition ICommodity.Description { get { return LabelNumber; } }
+        bool ICommodity.IsDeedable { get { return true; } }
+
+        [Constructable]
+        public Saltpeter()
+            : this(1)
+        {
+        }
+
+        [Constructable]
+        public Saltpeter(int count)
+            : base(0x423A)
+        {
+            Stackable = true;
+            Amount = count;
+            Hue = 1150;
+        }
+
+        public Saltpeter(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/RuinedShipPlans.cs

@@ -0,0 +1,155 @@
+using Server;
+using System;
+using System.Collections.Generic;
+using Server.Targeting;
+using Server.Multis;
+
+namespace Server.Items
+{
+    public class RuinedShipPlans : Item
+	{
+		public enum PlanType
+		{
+			One = 1,
+			Two,
+			Three,
+			Four,
+			Five,
+			Six,
+			Seven,
+			Eight
+		}
+
+		private PlanType m_PlanType;
+		public PlanType Type { get { return m_PlanType; } set { m_PlanType = value; } }
+
+        private List<PlanType> m_Joined = new List<PlanType>();
+        public List<PlanType> Joined { get { return m_Joined; } }
+
+        public override int LabelNumber { get { return 1116784; } }
+
+		[Constructable]
+		public RuinedShipPlans() : this((PlanType)Utility.RandomMinMax(1, 8))
+        {
+        }
+	
+		[Constructable]
+		public RuinedShipPlans(PlanType type) : base(5360)
+		{
+			m_PlanType = type;
+            m_Joined.Add(type);
+		}
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            list.Add(1116747); //Orc Ship
+
+            if(m_Joined.Count == 1)
+                list.Add(1116776, String.Format("{0}\t{1}", ((int)m_PlanType).ToString(), "8")); //Part ~1_val~ of ~2_val~
+            else
+                list.Add(1116777, String.Format("{0}\t{1}", m_Joined.Count.ToString(), "8")); //Parts ~1_val~ of ~2_val~
+
+            if (m_Joined.Count > 1)
+            {
+                m_Joined.Sort();
+
+                string str = "Contains Parts ";
+                foreach (int i in m_Joined)
+                    str += (i.ToString() + ", ");
+
+                list.Add(1114057, str);
+            }
+        }
+
+        public bool TryCombine(Mobile from, RuinedShipPlans plans)
+        {
+            if (m_Joined.Contains(plans.Type))
+            {
+                from.SendLocalizedMessage(1116787); //This part is already attached.
+                return false;
+            }
+
+            plans.Delete();
+            from.PlaySound(0x249);
+
+            foreach (PlanType type in plans.Joined)
+            {
+                if(!m_Joined.Contains(type))
+                    m_Joined.Add(type);
+            }
+
+            InvalidateProperties();
+
+            if (m_Joined.Count == 8)
+            {
+                from.AddToBackpack(new OrcishGalleonDeed());
+                from.SendLocalizedMessage(1116788); //You have completed a deed for an Orc Ship!
+
+                this.Delete();
+            }
+            else
+                from.Target = new InternalTarget(this);
+            return true;
+        }
+
+		public override void OnDoubleClick(Mobile from)
+		{
+            if (IsChildOf(from.Backpack))
+            {
+                from.Target = new InternalTarget(this);
+                from.SendLocalizedMessage(1116785); //Target another piece of ship plans to combine.
+            }
+		}
+
+        private class InternalTarget : Target
+        {
+            private RuinedShipPlans m_Plans;
+
+            public InternalTarget(RuinedShipPlans plans) : base(-1, false, TargetFlags.None)
+            {
+                m_Plans = plans;
+            }
+
+            protected override void OnTarget(Mobile from, object targeted)
+            {
+                if (targeted is Item && !((Item)targeted).IsChildOf(from.Backpack))
+                    from.SendMessage("That must be in your pack to combine.");
+                else if (targeted is RuinedShipPlans)
+                {
+                    RuinedShipPlans toAttach = (RuinedShipPlans)targeted;
+                    m_Plans.TryCombine(from, toAttach);
+                }
+                else
+                    from.SendLocalizedMessage(1116786); //These do not fit together.
+            }
+        }
+		
+		public RuinedShipPlans(Serial serial) : base(serial)
+		{
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{	
+			base.Serialize(writer);
+			writer.Write((int)0);	
+			writer.Write((int)m_PlanType);
+
+            writer.Write(m_Joined.Count);
+            for (int i = 0; i < m_Joined.Count; i++)
+                writer.Write((int)m_Joined[i]);
+		}
+
+        public override void Deserialize(GenericReader reader)
+		{
+		 	base.Deserialize(reader);
+			int version = reader.ReadInt();
+			m_PlanType = (PlanType)reader.ReadInt();
+
+            int count = reader.ReadInt();
+            for(int i = 0; i < count; i++)
+                m_Joined.Add((PlanType)reader.ReadInt());
+		}
+    }
+}

Scripts/Services/Expansions/High Seas/Items/SOS Artifacts/YellowPolkaDotBikini.cs

@@ -0,0 +1,42 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class YellowPolkaDotBikini : LeatherBustierArms
+	{
+        public override int LabelNumber { get { return 1149962; } }
+
+		[Constructable]
+		public YellowPolkaDotBikini() 
+		{
+            Hue = 1169;
+		}
+
+        public override void AddNameProperties(ObjectPropertyList list)
+        {
+            base.AddNameProperties(list);
+            list.Add(1041645); // recovered from a shipwrecklist
+        }
+
+        public YellowPolkaDotBikini(Serial serial)
+            : base(serial)
+		{
+		}
+
+		public override void Serialize(GenericWriter writer)
+		{	
+			base.Serialize(writer);
+            writer.Write((int)1);	
+		}
+	
+		public override void Deserialize(GenericReader reader)
+		{
+		 	base.Deserialize(reader);
+			int version = reader.ReadInt();
+
+            if (version == 0)
+                Hue = 1169;
+		}
+	}
+}

Scripts/Services/Expansions/High Seas/Items/SeaMarketBuoy.cs

@@ -0,0 +1,43 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class SeaMarketBuoy : BaseAddon
+    {
+        [Constructable]
+        public SeaMarketBuoy()
+        {
+            AddonComponent comp1 = new AddonComponent(18102);
+            comp1.Name = "buoy";
+
+            AddonComponent comp2 = new AddonComponent(18103);
+            comp1.Name = "buoy";
+
+            AddonComponent comp3 = new AddonComponent(18104);
+            comp1.Name = "buoy";
+
+            AddonComponent comp4 = new AddonComponent(18105);
+            comp1.Name = "buoy";
+
+            AddComponent(comp1, 0, 0, 0);
+            AddComponent(comp2, 0, -1, 0);
+            AddComponent(comp3, -1, -1, 0);
+            AddComponent(comp4, -1, 0, 0);
+        }
+
+        public SeaMarketBuoy(Serial serial) : base(serial) { }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/Sets/FishermansSet.cs

@@ -0,0 +1,525 @@
+using System;
+using Server;
+
+namespace Server.Items
+{
+    public interface IFishingAttire
+    {
+        int BaitBonus { get; set; }
+        int SetBonus { get; set; }
+    }
+
+    public class FishermansHat : TallStrawHat, ISetItem, IFishingAttire
+    {
+        public override int LabelNumber { get { return 1151190; } } //Fisherman's Tall Straw Hat
+
+        #region ISetItem Members
+        public override SetItem SetID { get { return SetItem.Fisherman; } }
+        public override int Pieces { get { return 4; } }
+        #endregion
+
+        #region IFishingAttire Members
+        public int BaitBonus { get { return 10; } set { } }
+        public int SetBonus { get { return 50; } set { } }
+        #endregion
+
+        public override int InitMinHits { get { return 125; } }
+        public override int InitMaxHits { get { return 125; } }
+
+        public override int BasePhysicalResistance { get { return Resistances.Physical == 0 ? 3 : base.BasePhysicalResistance; } }
+        public override int BaseFireResistance { get { return Resistances.Fire == 0 ? 8 : base.BaseFireResistance; } }
+        public override int BaseColdResistance { get { return Resistances.Cold == 0 ? 23 : base.BaseColdResistance; } }
+        public override int BasePoisonResistance { get { return Resistances.Poison == 0 ? 8 : base.BasePoisonResistance; } }
+        public override int BaseEnergyResistance { get { return Resistances.Energy == 0 ? 8 : base.BaseEnergyResistance; } }
+
+        public override int[] BaseResists
+        {
+            get
+            {
+                var list = new int[5];
+
+                list[0] = base.BasePhysicalResistance;
+                list[1] = base.BaseFireResistance;
+                list[2] = base.BaseColdResistance;
+                list[3] = base.BasePoisonResistance;
+                list[4] = base.BaseEnergyResistance;
+
+                return list;
+            }
+        }
+
+        [Constructable]
+        public FishermansHat()
+        {
+            Hue = 2578;
+            SetHue = 2578;
+        }
+
+        public FishermansHat(Serial serial) : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FishermansTrousers : StuddedLegs, ISetItem, IFishingAttire
+    {
+        public override int LabelNumber { get { return 1151191; } } //Fisherman's Trousers
+
+        #region ISetItem Members
+        public override SetItem SetID { get { return SetItem.Fisherman; } }
+        public override int Pieces { get { return 4; } }
+        #endregion
+
+        #region IFishingAttire Members
+        public int BaitBonus { get { return 10; } set { } }
+        public int SetBonus { get { return 50; } set { } }
+        #endregion
+
+        public override int InitMinHits { get { return 125; } }
+        public override int InitMaxHits { get { return 125; } }
+
+        public override int BasePhysicalResistance { get { return PhysicalBonus == 0 ? 6 : base.BasePhysicalResistance; } }
+        public override int BaseFireResistance { get { return FireBonus == 0 ? 20 : base.BaseFireResistance; } }
+        public override int BaseColdResistance { get { return ColdBonus == 0 ? 7 : base.BaseColdResistance; } }
+        public override int BasePoisonResistance { get { return PoisonBonus == 0 ? 7 : base.BasePoisonResistance; } }
+        public override int BaseEnergyResistance { get { return EnergyBonus == 0 ? 8 : base.BaseEnergyResistance ; } }
+
+        public override int[] BaseResists
+        {
+            get
+            {
+                var list = new int[5];
+
+                list[0] = base.BasePhysicalResistance;
+                list[1] = base.BaseFireResistance;
+                list[2] = base.BaseColdResistance;
+                list[3] = base.BasePoisonResistance;
+                list[4] = base.BaseEnergyResistance;
+
+                return list;
+            }
+        }
+
+        [Constructable]
+        public FishermansTrousers()
+        {
+            Hue = 2578;
+            SetHue = 2578;
+
+            ArmorAttributes.MageArmor = 1;
+        }
+
+        public FishermansTrousers(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FishermansVest : LeatherChest, ISetItem, IFishingAttire
+    {
+        public override int LabelNumber { get { return 1151192; } } //Fisherman's Vest
+
+        #region ISetItem Members
+        public override SetItem SetID { get { return SetItem.Fisherman; } }
+        public override int Pieces { get { return 4; } }
+        #endregion
+
+        #region IFishingAttire Members
+        public int BaitBonus { get { return 10; } set { } }
+        public int SetBonus { get { return 50; } set { } }
+        #endregion
+
+        public override int InitMinHits { get { return 125; } }
+        public override int InitMaxHits { get { return 125; } }
+
+        public override int BasePhysicalResistance { get { return PhysicalBonus == 0 ? 4 : base.BasePhysicalResistance; } }
+        public override int BaseFireResistance { get { return FireBonus == 0 ? 19 : base.BaseFireResistance; } }
+        public override int BaseColdResistance { get { return ColdBonus == 0 ? 5 : base.BaseColdResistance; } }
+        public override int BasePoisonResistance { get { return PoisonBonus == 0 ? 5 : base.BasePoisonResistance; } }
+        public override int BaseEnergyResistance { get { return EnergyBonus == 0 ? 5 : base.BaseEnergyResistance; } }
+
+        public override int[] BaseResists
+        {
+            get
+            {
+                var list = new int[5];
+
+                list[0] = base.BasePhysicalResistance;
+                list[1] = base.BaseFireResistance;
+                list[2] = base.BaseColdResistance;
+                list[3] = base.BasePoisonResistance;
+                list[4] = base.BaseEnergyResistance;
+
+                return list;
+            }
+        }
+
+        [Constructable]
+        public FishermansVest()
+        {
+            Hue = 2578;
+            SetHue = 2578;
+        }
+
+        public FishermansVest(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FishermansEelskinGloves : LeatherGloves, ISetItem, IFishingAttire
+    {
+        public override int LabelNumber { get { return 1151189; } } //Fisherman's Eelskin Gloves
+
+        #region ISetItem Members
+        public override SetItem SetID { get { return SetItem.Fisherman; } }
+        public override int Pieces { get { return 4; } }
+        #endregion
+
+        #region IFishingAttire Members
+        public int BaitBonus { get { return 10; } set { } }
+        public int SetBonus { get { return 50; } set { } }
+        #endregion
+
+        public override int InitMinHits { get { return 125; } }
+        public override int InitMaxHits { get { return 125; } }
+
+        public override int BasePhysicalResistance { get { return PhysicalBonus == 0 ? 4 : base.BasePhysicalResistance; } }
+        public override int BaseFireResistance { get { return FireBonus == 0 ? 19 : base.BaseFireResistance; } }
+        public override int BaseColdResistance { get { return ColdBonus == 0 ? 5 : base.BaseColdResistance; } }
+        public override int BasePoisonResistance { get { return PoisonBonus == 0 ? 5 : base.BasePoisonResistance; } }
+        public override int BaseEnergyResistance { get { return EnergyBonus == 0 ? 5 : base.BaseEnergyResistance; } }
+
+        public override int[] BaseResists
+        {
+            get
+            {
+                var list = new int[5];
+
+                list[0] = base.BasePhysicalResistance;
+                list[1] = base.BaseFireResistance;
+                list[2] = base.BaseColdResistance;
+                list[3] = base.BasePoisonResistance;
+                list[4] = base.BaseEnergyResistance;
+
+                return list;
+            }
+        }
+
+        [Constructable]
+        public FishermansEelskinGloves()
+        {
+            Hue = 2578;
+            SetHue = 2578;
+        }
+
+        public FishermansEelskinGloves(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FishermansChestguard : GargishPlateChest, ISetItem, IFishingAttire
+    {
+        public override int LabelNumber { get { return 1151574; } } //Fisherman's Chestguard
+
+        #region ISetItem Members
+        public override SetItem SetID { get { return SetItem.Fisherman; } }
+        public override int Pieces { get { return 4; } }
+        #endregion
+
+        #region IFishingAttire Members
+        public int BaitBonus { get { return 10; } set { } }
+        public int SetBonus { get { return 50; } set { } }
+        #endregion
+
+        public override int InitMinHits { get { return 125; } }
+        public override int InitMaxHits { get { return 125; } }
+
+        public override int BasePhysicalResistance { get { return PhysicalBonus == 0 ? 24 : base.BasePhysicalResistance; } }
+        public override int BaseFireResistance { get { return FireBonus == 0 ? 10 : base.BaseFireResistance; } }
+        public override int BaseColdResistance { get { return ColdBonus == 0 ? 9 : base.BaseColdResistance; } }
+        public override int BasePoisonResistance { get { return PoisonBonus == 0 ? 10 : base.BasePoisonResistance; } }
+        public override int BaseEnergyResistance { get { return EnergyBonus == 0 ? 9 : base.BaseEnergyResistance; } }
+
+        public override int[] BaseResists
+        {
+            get
+            {
+                var list = new int[5];
+
+                list[0] = base.BasePhysicalResistance;
+                list[1] = base.BaseFireResistance;
+                list[2] = base.BaseColdResistance;
+                list[3] = base.BasePoisonResistance;
+                list[4] = base.BaseEnergyResistance;
+
+                return list;
+            }
+        }
+
+        [Constructable]
+        public FishermansChestguard()
+        {
+            ItemID = 0x4052;
+            Hue = 2578;
+            SetHue = 2578;
+        }
+
+        public FishermansChestguard(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FishermansKilt : GargishClothKiltArmor, ISetItem, IFishingAttire
+    {
+        public override int LabelNumber { get { return 1151575; } } // Fisherman's Kilt
+
+        #region ISetItem Members
+        public override SetItem SetID { get { return SetItem.Fisherman; } }
+        public override int Pieces { get { return 4; } }
+        #endregion
+
+        #region IFishingAttire Members
+        public int BaitBonus { get { return 10; } set { } }
+        public int SetBonus { get { return 50; } set { } }
+        #endregion
+
+        public override int InitMinHits { get { return 125; } }
+        public override int InitMaxHits { get { return 125; } }
+
+        public override int BasePhysicalResistance { get { return PhysicalBonus == 0 ? 7 : base.BasePhysicalResistance; } }
+        public override int BaseFireResistance { get { return FireBonus == 0 ? 21 : base.BaseFireResistance; } }
+        public override int BaseColdResistance { get { return ColdBonus == 0 ? 8 : base.BaseColdResistance; } }
+        public override int BasePoisonResistance { get { return PoisonBonus == 0 ? 8 : base.BasePoisonResistance; } }
+        public override int BaseEnergyResistance { get { return EnergyBonus == 0 ? 8 : base.BaseEnergyResistance; } }
+
+        public override int[] BaseResists
+        {
+            get
+            {
+                var list = new int[5];
+
+                list[0] = base.BasePhysicalResistance;
+                list[1] = base.BaseFireResistance;
+                list[2] = base.BaseColdResistance;
+                list[3] = base.BasePoisonResistance;
+                list[4] = base.BaseEnergyResistance;
+
+                return list;
+            }
+        }
+
+        [Constructable]
+        public FishermansKilt()
+        {
+            Hue = 2578;
+            SetHue = 2578;
+        }
+
+        public FishermansKilt(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FishermansArms : GargishLeatherArms, ISetItem, IFishingAttire
+    {
+        public override int LabelNumber { get { return 1151576; } } // Fisherman's Arms
+
+        #region ISetItem Members
+        public override SetItem SetID { get { return SetItem.Fisherman; } }
+        public override int Pieces { get { return 4; } }
+        #endregion
+
+        #region IFishingAttire Members
+        public int BaitBonus { get { return 10; } set { } }
+        public int SetBonus { get { return 50; } set { } }
+        #endregion
+
+        public override int InitMinHits { get { return 125; } }
+        public override int InitMaxHits { get { return 125; } }
+
+        public override int BasePhysicalResistance { get { return PhysicalBonus == 0 ? 7 : base.BasePhysicalResistance; } }
+        public override int BaseFireResistance { get { return FireBonus == 0 ? 8 : base.BaseFireResistance; } }
+        public override int BaseColdResistance { get { return ColdBonus == 0 ? 21 : base.BaseColdResistance; } }
+        public override int BasePoisonResistance { get { return PoisonBonus == 0 ? 8 : base.BasePoisonResistance; } }
+        public override int BaseEnergyResistance { get { return EnergyBonus == 0 ? 8 : base.BaseEnergyResistance; } }
+
+        public override int[] BaseResists
+        {
+            get
+            {
+                var list = new int[5];
+
+                list[0] = base.BasePhysicalResistance;
+                list[1] = base.BaseFireResistance;
+                list[2] = base.BaseColdResistance;
+                list[3] = base.BasePoisonResistance;
+                list[4] = base.BaseEnergyResistance;
+
+                return list;
+            }
+        }
+
+        [Constructable]
+        public FishermansArms()
+        {
+            Hue = 2578;
+            SetHue = 2578;
+        }
+
+        public FishermansArms(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class FishermansEarrings : GargishEarrings, ISetItem, IFishingAttire
+    {
+        public override int LabelNumber { get { return 1151577; } } // Fisherman's Earrings
+
+        #region ISetItem Members
+        public override SetItem SetID { get { return SetItem.Fisherman; } }
+        public override int Pieces { get { return 4; } }
+        #endregion
+
+        #region IFishingAttire Members
+        public int BaitBonus { get { return 10; } set { } }
+        public int SetBonus { get { return 50; } set { } }
+        #endregion
+
+        public override int InitMinHits { get { return 125; } }
+        public override int InitMaxHits { get { return 125; } }
+
+        public override int BasePhysicalResistance { get { return PhysicalBonus == 0 ? 3 : base.BasePhysicalResistance; } }
+        public override int BaseFireResistance { get { return FireBonus == 0 ? 4 : base.BaseFireResistance; } }
+        public override int BaseColdResistance { get { return ColdBonus == 0 ? 4 : base.BaseColdResistance; } }
+        public override int BasePoisonResistance { get { return PoisonBonus == 0 ? 4 : base.BasePoisonResistance; } }
+        public override int BaseEnergyResistance { get { return EnergyBonus == 0 ? 17 : base.BaseEnergyResistance; } }
+
+        public override int[] BaseResists
+        {
+            get
+            {
+                var list = new int[5];
+
+                list[0] = base.BasePhysicalResistance;
+                list[1] = base.BaseFireResistance;
+                list[2] = base.BaseColdResistance;
+                list[3] = base.BasePoisonResistance;
+                list[4] = base.BaseEnergyResistance;
+
+                return list;
+            }
+        }
+
+        [Constructable]
+        public FishermansEarrings()
+        {
+            Hue = 2578;
+            SetHue = 2578;
+        }
+
+        public FishermansEarrings(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/ShippingCrate.cs

@@ -0,0 +1,187 @@
+using Server;
+using System;
+using System.Collections.Generic;
+using Server.ContextMenus;
+using Server.Multis;
+using Server.Gumps;
+
+namespace Server.Items
+{
+    public class ShipCrate : SmallCrate
+    {
+        public static readonly int DT = 30;
+
+        private Mobile m_Owner;
+        private BaseBoat m_Boat;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Mobile Owner { get { return m_Owner; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public BaseBoat Boat { get { return m_Boat; } }
+
+        public override TimeSpan DecayTime
+        {
+            get
+            {
+                return TimeSpan.FromMinutes(DT);
+            }
+        }
+
+        public override bool Decays
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public ShipCrate(Mobile owner, BaseBoat boat)
+        {
+            LiftOverride = true;
+            m_Owner = owner;
+            m_Boat = boat;
+            Movable = false;
+        }
+
+        public override void Delete()
+        {
+            Server.Mobiles.DockMaster.RemoveCrate(this);
+            base.Delete();
+        }
+
+        public override void AddNameProperty(ObjectPropertyList list)
+        {
+            if (m_Owner != null)
+                list.Add(1116515, m_Owner.Name);
+            else
+                list.Add("a shipping crate");
+        }
+
+        public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
+        {
+            base.GetContextMenuEntries(from, list);
+            list.Add(new DestroyCrate(from, this));
+
+            if(m_Boat != null && this.Items.Count > 0)
+                list.Add(new LoadShip(from, this));
+        }
+
+        private class DestroyCrate : ContextMenuEntry
+        {
+            private Mobile m_From;
+            private ShipCrate m_Crate;
+
+            public DestroyCrate(Mobile from, ShipCrate crate) : base(1116522, 3)
+            {
+                m_From = from;
+                m_Crate = crate;
+            }
+
+            public override void OnClick()
+            {
+                m_From.SendGump(new InternalGump(m_Crate)); 
+            }
+        }
+
+        private class LoadShip : ContextMenuEntry
+        {
+            private Mobile m_From;
+            private ShipCrate m_Crate;
+
+            public LoadShip(Mobile from, ShipCrate crate)
+                : base(1116521, 3) //Load Ship from Crate
+            {
+                m_From = from;
+                m_Crate = crate;
+            }
+
+            public override void OnClick()
+            {
+                if (m_Crate == null || m_Crate.Boat == null)
+                    return;
+
+                Container hold;
+
+                if(m_Crate.Boat is BaseGalleon)
+                    hold = ((BaseGalleon)m_Crate.Boat).GalleonHold;
+                else
+                    hold = m_Crate.Boat.Hold;
+
+                if(hold == null)
+                    return;
+
+                if (m_From.InRange(m_Crate.Boat.Location, Server.Mobiles.DockMaster.DryDockDistance))
+                {
+                    List<Item> items = new List<Item>(m_Crate.Items);
+                    foreach (Item item in items)
+                        hold.DropItem(item);
+
+                    m_From.SendMessage("You hold has been loaded from the shipping crate.");
+                }
+                else
+                    m_From.SendLocalizedMessage(1116519); //I can't find your ship! You need to bring it in closer.
+            }
+        }
+
+        private class InternalGump : BaseConfirmGump
+        {
+            private ShipCrate m_Crate;
+
+            public override int LabelNumber { get { return 1116523; } } // Are you sure you want to destroy your shipping crate and its contents?
+
+            public InternalGump(ShipCrate crate)
+            {
+                m_Crate = crate;
+            }
+
+            public override void Confirm(Mobile from)
+            {
+                if(m_Crate != null)
+                    m_Crate.Delete();
+            }
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (from != m_Owner)
+            {
+                from.SendLocalizedMessage(1112589); //This does not belong to you! Find your own!
+                return;
+            }
+
+            base.OnDoubleClick(from);
+        }   
+
+        public override void OnItemRemoved(Item item)
+        {
+            base.OnItemRemoved(item);
+
+            if (this.TotalItems == 0)
+                Delete();
+        }
+
+        public ShipCrate(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+
+            writer.Write(m_Owner);
+            writer.Write(m_Boat);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            m_Owner = reader.ReadMobile();
+            m_Boat = reader.ReadItem() as BaseBoat;
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/SmugglersCache.cs

@@ -0,0 +1,65 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class SmugglersCache : Container
+    {
+        public override int LabelNumber { get { return 1150042; } }
+
+        public SmugglersCache()
+            : base(Utility.RandomList(3644, 3645, 3646, 3647, 3648, 3649, 3650, 3651))
+        {
+            int toDrop = Utility.RandomMinMax(15, 20);
+            for (int i = 0; i < toDrop; i++)
+            {
+                DropItem(GetRandomBeverage());
+            }
+
+            if (0.5 < Utility.RandomDouble())
+                DropItem(SmugglersLiquor.GetRandom());
+
+            DropItem(SmugglersLiquor.GetRandom());
+        }
+
+        public BeverageType RandomBeverageType()
+        {
+            switch (Utility.Random(4))
+            {
+                case 0: return BeverageType.Ale;
+                case 1: return BeverageType.Cider;
+                case 2: return BeverageType.Liquor;
+                case 3: return BeverageType.Wine;
+            }
+
+            return BeverageType.Milk;
+        }
+
+        public BaseBeverage GetRandomBeverage()
+        {
+            switch (Utility.Random(2))
+            {
+                default:
+                case 0: return new BeverageBottle(RandomBeverageType());
+                case 1: return new Jug(RandomBeverageType());
+            }
+        }
+
+        public SmugglersCache(Serial serial)
+            : base(serial)
+		{
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+			int version = reader.ReadInt();
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+			writer.Write( (int)0 );
+		}
+    }
+}

Scripts/Services/Expansions/High Seas/Items/SmugglersLiquor.cs

@@ -0,0 +1,256 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class SmugglersLiquor : BaseBeverage
+    {
+        private int m_Label;
+        private SmugglersLiquorType m_Type;
+
+        public override int LabelNumber { get { return m_Label; } }
+        public override int MaxQuantity { get { return 5; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public SmugglersLiquorType LiquorType { get { return m_Type; } set { m_Type = value; ItemID = ComputeItemID(); } }
+
+        public enum SmugglersLiquorType
+        {
+            AppleIsleWhiskey,
+            ArabellasGargishStout,
+            DiablosBlazePort,
+            EldadorElvenWine,
+            EquinoxWine,
+            FitchsWhiteAle,
+            GatheredSpiritsWhisky,
+            GoldenBrewRum,
+            JoesSpicyBrew,
+            KazolasTreeTopWine,
+            Moonshine,
+            NapaValleysChardonnay,
+            OtisHomemadeBrew,
+            PandorasPinotNoir,
+            RedEyeRum,
+            RoyalGuardAle,
+            SaltyDogMead,
+            SapewinWine,
+            SerpentsCrossLager,
+            SummerSolsticeBrew,
+            VesperAle,
+            WaxingDarkBrew,
+            WhiteRoseZinfandel,
+        }
+
+        [Constructable]
+        public SmugglersLiquor() : this((SmugglersLiquorType)Utility.Random(26))
+        {
+        }
+
+        public SmugglersLiquor(SmugglersLiquorType type) : base(GetContents(type))
+        {
+            this.LiquorType = type;
+        }
+
+        public static BeverageType GetContents(SmugglersLiquorType type)
+        {
+            switch (type)
+            {
+                default:
+                case SmugglersLiquorType.AppleIsleWhiskey: return BeverageType.Liquor;
+                case SmugglersLiquorType.ArabellasGargishStout: return BeverageType.Ale;
+                case SmugglersLiquorType.DiablosBlazePort: return BeverageType.Ale;
+                case SmugglersLiquorType.EldadorElvenWine: return BeverageType.Wine;
+                case SmugglersLiquorType.EquinoxWine: return BeverageType.Wine;                    
+                case SmugglersLiquorType.FitchsWhiteAle: return BeverageType.Ale;                   
+                case SmugglersLiquorType.GatheredSpiritsWhisky: return BeverageType.Liquor;
+                case SmugglersLiquorType.GoldenBrewRum: return BeverageType.Liquor;  
+                case SmugglersLiquorType.JoesSpicyBrew: return BeverageType.Ale;                   
+                case SmugglersLiquorType.KazolasTreeTopWine: return BeverageType.Wine;                   
+                case SmugglersLiquorType.Moonshine: return BeverageType.Liquor;                  
+                case SmugglersLiquorType.NapaValleysChardonnay: return BeverageType.Wine;                    
+                case SmugglersLiquorType.OtisHomemadeBrew: return BeverageType.Ale;                   
+                case SmugglersLiquorType.PandorasPinotNoir: return BeverageType.Wine;                    
+                case SmugglersLiquorType.RedEyeRum: return BeverageType.Liquor;                    
+                case SmugglersLiquorType.RoyalGuardAle: return BeverageType.Ale;                    
+                case SmugglersLiquorType.SaltyDogMead: return BeverageType.Ale;                   
+                case SmugglersLiquorType.SapewinWine: return BeverageType.Wine;                    
+                case SmugglersLiquorType.SerpentsCrossLager: return BeverageType.Ale;                   
+                case SmugglersLiquorType.SummerSolsticeBrew: return BeverageType.Ale;                    
+                case SmugglersLiquorType.VesperAle: return BeverageType.Ale;                   
+                case SmugglersLiquorType.WaxingDarkBrew: return BeverageType.Ale;                    
+                case SmugglersLiquorType.WhiteRoseZinfandel: return BeverageType.Wine;                   
+            }
+        }
+
+        public override int ComputeItemID()
+        {
+            int id = 0;
+            switch (m_Type)
+            {
+                case SmugglersLiquorType.AppleIsleWhiskey:
+                    id = 2504;
+                    Hue = 692; //Confirmed
+                    m_Label = 1150020;
+                    break;
+                case SmugglersLiquorType.ArabellasGargishStout:
+                    id = 2459;
+                    Hue = 507;  //Confirmed
+                    m_Label = 1150033;
+                    break;
+                case SmugglersLiquorType.DiablosBlazePort:
+                    id = 2459;
+                    Hue = 675; //Confirmed
+                    m_Label = 1150034;
+                    break;
+                case SmugglersLiquorType.EldadorElvenWine:
+                    id = 2459;
+                    Hue = 540; //Confirmed
+                    m_Label = 1150029;
+                    break;
+                case SmugglersLiquorType.EquinoxWine:
+                    id = 2459;
+                    Hue = 634; //Confirmed
+                    m_Label = 1150037;
+                    break;
+                case SmugglersLiquorType.FitchsWhiteAle:
+                    id = 2459;
+                    Hue = 687; //Confirmed
+                    m_Label = 1150035;
+                    break;
+                case SmugglersLiquorType.GatheredSpiritsWhisky:
+                    id = 2459;
+                    Hue = 654; //Confirmed
+                    m_Label = 1150026;
+                    break;
+                case SmugglersLiquorType.GoldenBrewRum:
+                    id = 2459;
+                    Hue = 584;  //Confirmed
+                    m_Label = 1150039;
+                    break;
+                case SmugglersLiquorType.JoesSpicyBrew:
+                    id = 2459;
+                    Hue = 535; //Confirmed
+                    m_Label = 1150027;
+                    break;
+                case SmugglersLiquorType.KazolasTreeTopWine:
+                    id = 2504;
+                    Hue = 512; //Confirmed
+                    m_Label = 1150036;
+                    break;
+                case SmugglersLiquorType.Moonshine:
+                    id = 2504;
+                    Hue = 555; //Confirmed
+                    m_Label = 1150041;
+                    break;
+                case SmugglersLiquorType.NapaValleysChardonnay:
+                    id = 2459;
+                    Hue = 600;  //Confirmed
+                    m_Label = 1150025;
+                    break;
+                case SmugglersLiquorType.OtisHomemadeBrew:
+                    id = 2459;
+                    Hue = 680; //Confirmed
+                    m_Label = 1150019;
+                    break;
+                case SmugglersLiquorType.PandorasPinotNoir:
+                    id = 2459;
+                    Hue = 621; //Confirmed
+                    m_Label = 1150023;
+                    break;
+                case SmugglersLiquorType.RedEyeRum:
+                    id = 2459;
+                    Hue = 687; //Confirmed
+                    m_Label = 1150022;
+                    break;
+                case SmugglersLiquorType.RoyalGuardAle:
+                    id = 2504;
+                    Hue = 651; //Confirmed
+                    m_Label = 1150024;
+                    break;
+                case SmugglersLiquorType.SaltyDogMead:
+                    id = 2504;
+                    Hue = 566; //Confirmed
+                    m_Label = 1150028;
+                    break;
+                case SmugglersLiquorType.SapewinWine:
+                    id = 2459;
+                    Hue = 557;  //Confirmed
+                    m_Label = 1150040;
+                    break;
+                case SmugglersLiquorType.SerpentsCrossLager:
+                    id = 2459;
+                    Hue = 593; //Confirmed
+                    m_Label = 1150031;
+                    break;
+                case SmugglersLiquorType.SummerSolsticeBrew:
+                    id = 2459;
+                    Hue = 663;  //Confirmed
+                    m_Label = 1150038;
+                    break;
+                case SmugglersLiquorType.VesperAle:
+                    id = 2504;
+                    Hue = 519; //Confirmed
+                    m_Label = 1150032;
+                    break;
+                case SmugglersLiquorType.WaxingDarkBrew:
+                    id = 2459;
+                    Hue = 567; //Confirmed
+                    m_Label = 1150030;
+                    break;
+                case SmugglersLiquorType.WhiteRoseZinfandel:
+                    id = 2459;
+                    Hue = 516; //Confirmed
+                    m_Label = 1150021;
+                    break;
+            }
+            return id;
+        }
+
+        public static Item GetRandom()
+        {
+            int pick = Utility.Random(22);
+
+            return new SmugglersLiquor((SmugglersLiquorType)pick) as Item;
+        }
+
+        public SmugglersLiquor(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)2);
+
+            writer.Write(m_Label);
+            writer.Write((int)m_Type);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            switch (version)
+            {
+                case 2:
+                    m_Label = reader.ReadInt();
+                    m_Type = (SmugglersLiquorType)reader.ReadInt();
+                    break;
+                case 1:
+                    m_Type = (SmugglersLiquorType)reader.ReadInt();
+                    ComputeItemID();
+                    break;
+                case 0:
+                    int type = reader.ReadInt();
+
+                    if (type > (int)SmugglersLiquorType.WhiteRoseZinfandel)
+                        m_Type = SmugglersLiquorType.WhiteRoseZinfandel;
+                    else
+                        m_Type = (SmugglersLiquorType)type;
+                    break;
+            }
+        }
+    }
+}

Scripts/Services/Expansions/High Seas/Items/WhiteClothDyeTub.cs

@@ -0,0 +1,34 @@
+using Server;
+using System;
+
+namespace Server.Items
+{
+    public class WhiteClothDyeTub : DyeTub
+	{
+		[Constructable]
+		public WhiteClothDyeTub()
+		{
+			Hue = DyedHue = 2498;
+			Redyable = false;
+		}
+
+        public WhiteClothDyeTub(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();
+		}
+	}
+}