Overwrite

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

Scripts/Items/Internal/DespiseTeleporter.cs

@@ -0,0 +1,347 @@
+using Server;
+using System;
+using Server.Mobiles;
+using Server.Engines.Despise;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Server.Items
+{
+    public class DespiseTeleporter : Teleporter
+    {
+        [Constructable]
+        public DespiseTeleporter()
+        {
+        }
+
+        public override bool CanTeleport(Mobile m)
+        {
+            if (m is DespiseCreature)
+                return false;
+
+            return base.CanTeleport(m);
+        }
+
+        public override void DoTeleport(Mobile m)
+        {
+            Map map = MapDest;
+
+            if (map == null || map == Map.Internal)
+                map = m.Map;
+
+            Point3D p = PointDest;
+
+            if (p == Point3D.Zero)
+                p = m.Location;
+
+            TeleportPets(m, p, map);
+
+            bool sendEffect = (!m.Hidden || m.AccessLevel == AccessLevel.Player);
+
+            if (SourceEffect && sendEffect)
+                Effects.SendLocationEffect(m.Location, m.Map, 0x3728, 10, 10);
+
+            m.MoveToWorld(p, map);
+
+            if (DestEffect && sendEffect)
+                Effects.SendLocationEffect(m.Location, m.Map, 0x3728, 10, 10);
+
+            if (SoundID > 0 && sendEffect)
+                Effects.PlaySound(m.Location, m.Map, SoundID);
+        }
+
+        public static void TeleportPets(Mobile master, Point3D loc, Map map)
+        {
+            var move = new List<Mobile>();
+            IPooledEnumerable eable = master.GetMobilesInRange(3);
+
+            foreach (Mobile m in eable)
+            {
+                if (m is BaseCreature && !(m is DespiseCreature))
+                {
+                    BaseCreature pet = (BaseCreature)m;
+
+                    if (pet.Controlled && pet.ControlMaster == master)
+                    {
+                        if (pet.ControlOrder == OrderType.Guard || pet.ControlOrder == OrderType.Follow ||
+                            pet.ControlOrder == OrderType.Come)
+                        {
+                            move.Add(pet);
+                        }
+                    }
+                }
+            }
+
+            eable.Free();
+
+            foreach (Mobile m in move)
+            {
+                m.MoveToWorld(loc, map);
+            }
+
+            move.Clear();
+            move.TrimExcess();
+        }
+
+        public DespiseTeleporter(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 v = reader.ReadInt();
+		}
+    }
+
+    public class GateTeleporter : Item
+    {
+        private Point3D _Destination;
+        private Map _DestinationMap;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Point3D Destination
+        {
+            get { return _Destination; }
+            set
+            {
+                if (_Destination != value)
+                {
+                    _Destination = value;
+                    AssignDestination(value);
+                }
+            }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Map DestinationMap
+        {
+            get { return _DestinationMap; }
+            set
+            {
+                if (DestinationMap != value)
+                {
+                    _DestinationMap = value;
+                    AssignMap(value);
+                }
+            }
+        }
+
+        public List<InternalTeleporter> Teleporters { get; set; }
+
+        [Constructable]
+        public GateTeleporter()
+            : this(19343, 0, Point3D.Zero, null)
+        {
+        }
+
+        public GateTeleporter(int id, int hue, Point3D destination, Map destinationMap)
+            : base(id)
+        {
+            Hue = hue;
+
+            Movable = false;
+
+            _Destination = destination;
+            _DestinationMap = destinationMap;
+
+            AssignTeleporters();
+        }
+
+        private void AssignTeleporters()
+        {
+            if (Teleporters != null)
+            {
+                foreach (var tele in Teleporters.Where(t => t != null && !t.Deleted))
+                {
+                    tele.Delete();
+                }
+
+                ColUtility.Free(Teleporters);
+            }
+
+            Teleporters = new List<InternalTeleporter>();
+
+            for (int i = 0; i <= 7; i++)
+            {
+                Direction offset = (Direction)i;
+
+                var tele = new InternalTeleporter(this, _Destination, _DestinationMap);
+
+                int x = this.X;
+                int y = this.Y;
+                int z = this.Z;
+
+                Movement.Movement.Offset(offset, ref x, ref y);
+                tele.MoveToWorld(new Point3D(x, y, z), this.Map);
+
+                Teleporters.Add(tele);
+            }
+        }
+
+        public void AssignDestination(Point3D p)
+        {
+            if (Teleporters == null)
+            {
+                AssignTeleporters();
+            }
+            else
+            {
+                Teleporters.ForEach(t => t.PointDest = p);
+            }
+        }
+
+        public void AssignMap(Map map)
+        {
+            if (Teleporters == null)
+            {
+                AssignTeleporters();
+            }
+            else
+            {
+                Teleporters.ForEach(t => t.MapDest = map);
+            }
+        }
+
+        public override void OnMapChange()
+        {
+            if (Teleporters != null)
+            {
+                Teleporters.ForEach(t => t.Map = Map);
+            }
+        }
+
+        public override void OnLocationChange(Point3D old)
+        {
+            if (Teleporters != null)
+            {
+                Teleporters.ForEach(t =>
+                    {
+                        t.Location = new Point3D(X + (t.X - old.X), Y + (t.Y - old.Y), Z + (t.Z - old.Z));
+                    });
+            }
+        }
+
+        public override void Delete()
+        {
+            base.Delete();
+
+            if (Teleporters != null)
+            {
+                Teleporters.ForEach(t => t.Delete());
+
+                ColUtility.Free(Teleporters);
+            }
+        }
+
+        public GateTeleporter(Serial serial)
+            : base(serial)
+		{
+		}
+		
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+			writer.Write((int)0);
+
+            writer.Write(_Destination);
+            writer.Write(_DestinationMap);
+
+            writer.Write(Teleporters == null ? 0 : Teleporters.Count);
+
+            if (Teleporters != null)
+            {
+                Teleporters.ForEach(t => writer.Write(t));
+            }
+		}
+		
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+			int v = reader.ReadInt();
+
+            _Destination = reader.ReadPoint3D();
+            _DestinationMap = reader.ReadMap();
+
+            int count = reader.ReadInt();
+            for (int i = 0; i < count; i++)
+            {
+                if (Teleporters == null)
+                    Teleporters = new List<InternalTeleporter>();
+
+                var tele = reader.ReadItem() as InternalTeleporter;
+
+                if (tele != null)
+                {
+                    Teleporters.Add(tele);
+                    tele.Master = this;
+                }
+            }
+		}
+
+        public class InternalTeleporter : Teleporter
+        {
+            [CommandProperty(AccessLevel.GameMaster)]
+            public GateTeleporter Master { get; set; }
+
+            public InternalTeleporter(GateTeleporter master, Point3D dest, Map destMap)
+                : base(dest, destMap, true)
+            {
+                Master = master;
+            }
+
+            public override bool OnMoveOver(Mobile m)
+            {
+                return true;
+            }
+
+            public override bool HandlesOnMovement { get { return Master != null && Utility.InRange(Master.Location, Location, 1) && this.Map == Master.Map; } }
+            
+            public override void OnMovement(Mobile m, Point3D oldLocation)
+            {
+                if (Master == null || Master.Destination == Point3D.Zero || Master.Map == null || Master.Map == Map.Internal)
+                    return;
+
+                if (m.Location == Location)
+                {
+                    var eable = Map.GetItemsInRange(oldLocation, 0);
+
+                    foreach (Item item in eable)
+                    {
+                        if (item is InternalTeleporter || item == Master)
+                        {
+                            eable.Free();
+                            return;
+                        }
+                    }
+
+                    base.OnMoveOver(m);
+                }
+            }
+
+            public InternalTeleporter(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 v = reader.ReadInt();
+            }
+        }
+    }
+}