Overwrite

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

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();
+        }
+    }
+}