Overwrite

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

Scripts/Items/Addons/Craft Addons/CraftAddon.cs

@@ -0,0 +1,264 @@
+using System;
+using Server;
+using Server.Engines.Craft;
+using System.Collections.Generic;
+using Server.Multis;
+using System.Linq;
+using Server.Network;
+
+namespace Server.Items
+{
+    public abstract class CraftAddon : BaseAddon, Server.Gumps.ISecurable
+    {
+        public List<AddonToolComponent> Tools { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public SecureLevel Level { get; set; }
+
+        public abstract CraftSystem CraftSystem { get; }
+
+        [Hue, CommandProperty(AccessLevel.GameMaster)]
+        public override int Hue
+        {
+            get
+            {
+                return base.Hue;
+            }
+            set
+            {
+                if (base.Hue != value)
+                {
+                    base.Hue = value;
+
+                    if (!Deleted && ShareHue && Tools != null)
+                    {
+                        foreach (AddonToolComponent tool in Tools)
+                            tool.Hue = value;
+                    }
+                }
+            }
+        }
+
+        public override BaseAddonDeed Deed { get { return null; } }
+
+        [Constructable]
+        public CraftAddon()
+        {
+            Tools = new List<AddonToolComponent>();
+        }
+
+        public void AddCraftComponent(AddonToolComponent tool, int x, int y, int z)
+        {
+            if (Deleted)
+                return;
+
+            Tools.Add(tool);
+            Level = SecureLevel.CoOwners;
+
+            tool.Addon = this;
+            tool.Offset = new Point3D(x, y, z);
+            tool.MoveToWorld(new Point3D(X + x, Y + y, Z + z), Map);
+        }
+
+        public override AddonFitResult CouldFit(IPoint3D p, Map map, Mobile from, ref BaseHouse house)
+        {
+            AddonFitResult result = base.CouldFit(p, map, from, ref house);
+
+            if (result == AddonFitResult.Valid)
+            {
+                foreach (AddonToolComponent c in Tools)
+                {
+                    Point3D p3D = new Point3D(p.X + c.Offset.X, p.Y + c.Offset.Y, p.Z + c.Offset.Z);
+
+                    if (!map.CanFit(p3D.X, p3D.Y, p3D.Z, c.ItemData.Height, false, true, (c.Z == 0)))
+                        return AddonFitResult.Blocked;
+                    else if (!CheckHouse(from, p3D, map, c.ItemData.Height, ref house))
+                        return AddonFitResult.NotInHouse;
+
+                    if (c.NeedsWall)
+                    {
+                        Point3D wall = c.WallPosition;
+
+                        if (!BaseAddon.IsWall(p3D.X + wall.X, p3D.Y + wall.Y, p3D.Z + wall.Z, map))
+                            return AddonFitResult.NoWall;
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        public virtual void OnCraftComponentUsed(Mobile from, AddonToolComponent tool)
+        {
+            if (!tool.TurnedOn)
+                return;
+
+            if (from.InRange(tool.Location, 2))
+            {
+                BaseHouse house = BaseHouse.FindHouseAt(from);
+
+                if (house != null && house.HasSecureAccess(from, Level))
+                {
+                    from.SendGump(new CraftGump(from, CraftSystem, tool, null));
+                }
+                else
+                {
+                    tool.PublicOverheadMessage(MessageType.Regular, 0x3E9, 1061637); // You are not allowed to access this.
+                }
+            }
+            else
+            {
+                from.SendLocalizedMessage(500325); // I am too far away to do that.
+            }
+        }
+
+        public virtual void OnCraftComponentLoaded(AddonToolComponent tool)
+        {
+        }
+
+        public override void OnLocationChange(Point3D old)
+        {
+            base.OnLocationChange(old);
+
+            Tools.ForEach(t => t.Location = new Point3D(X + t.Offset.X, Y + t.Offset.Y, Z + t.Offset.Z));
+        }
+
+        public override void OnMapChange()
+        {
+            base.OnMapChange();
+
+            Tools.ForEach(t => t.Map = Map);
+        }
+
+        public override void OnAfterDelete()
+        {
+            base.OnAfterDelete();
+
+            Tools.ForEach(t => t.Delete());
+        }
+
+        public CraftAddon(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+
+            writer.Write((int)Level);
+
+            writer.Write(Tools.Count);
+            Tools.ForEach(t => writer.Write(t));
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            Level = (SecureLevel)reader.ReadInt();
+
+            Tools = new List<AddonToolComponent>();
+
+            int count = reader.ReadInt();
+            for (int i = 0; i < count; i++)
+            {
+                AddonToolComponent tool = reader.ReadItem() as AddonToolComponent;
+
+                if (tool != null)
+                {
+                    tool.SetCraftSystem(CraftSystem);
+                    Tools.Add(tool);
+                }
+            }
+        }
+
+        public class ToolDropComponent : LocalizedAddonComponent
+        {
+            public override bool ForceShowProperties { get { return true; } }
+
+            public ToolDropComponent(int id, int cliloc)
+                : base(id, cliloc)
+            {
+            }
+
+            public override bool OnDragDrop(Mobile from, Item dropped)
+            {
+                BaseHouse house = BaseHouse.FindHouseAt(this);
+                CraftAddon addon = Addon as CraftAddon;
+
+                if (house != null && addon != null && house.HasSecureAccess(from, addon.Level))
+                {
+                    if (dropped is ITool && !(dropped is BaseRunicTool))
+                    {
+                        var tool = dropped as ITool;
+
+                        if (tool.CraftSystem == addon.CraftSystem)
+                        {
+                            AddonToolComponent comp = addon.Tools.FirstOrDefault(t => t != null);
+
+                            if (comp == null)
+                                return false;
+
+                            if (comp.UsesRemaining >= comp.MaxUses)
+                            {
+                                from.SendLocalizedMessage(1155740); // Adding this to the power tool would put it over the max number of charges the tool can hold.
+                                return false;
+                            }
+                            else
+                            {
+                                int toadd = Math.Min(tool.UsesRemaining, comp.MaxUses - comp.UsesRemaining);
+
+                                comp.UsesRemaining += toadd;
+                                tool.UsesRemaining -= toadd;
+
+                                if (tool.UsesRemaining <= 0 && !tool.Deleted)
+                                    tool.Delete();
+
+                                from.SendLocalizedMessage(1155741); // Charges have been added to the power tool.
+
+                                Effects.PlaySound(Location, Map, 0x42);
+
+                                return false;
+                            }
+                        }
+                        else
+                        {
+                            from.SendLocalizedMessage(1074836); // The container cannot hold that type of object.
+                            return false;
+                        }
+                    }
+                    else
+                    {
+                        from.SendLocalizedMessage(1074836); // The container cannot hold that type of object.
+                        return false;
+                    }
+                }
+                else
+                {
+                    SendLocalizedMessageTo(from, 1061637); // You are not allowed to access this.
+                    return false;
+                }
+            }
+
+            public ToolDropComponent(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();
+            }
+        }
+    }
+}