Overwrite

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

Scripts/Services/Seasonal Events/KrampusEncounter/Items/BarbedWhip.cs

@@ -0,0 +1,47 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    public class BarbedWhip : BaseBashing, Server.Engines.Craft.IRepairable
+    {
+		public Server.Engines.Craft.CraftSystem RepairSystem { get { return Server.Engines.Craft.DefTinkering.CraftSystem; } }
+        public override int LabelNumber { get { return 1125641; } } // Barbed Whip		
+
+        [Constructable]
+        public BarbedWhip()
+            : base(0xA289)
+        {
+            Weight = 5.0;
+        }
+
+        public BarbedWhip(Serial serial)
+            : base(serial)
+        {
+        }
+		
+		public override bool CanBeWornByGargoyles { get { return true; } }
+        public override WeaponAbility PrimaryAbility { get { return WeaponAbility.ConcussionBlow; } }
+        public override WeaponAbility SecondaryAbility { get { return WeaponAbility.WhirlwindAttack; } }
+        public override int AosStrengthReq { get { return 20; } }
+        public override int AosMinDamage { get { return 13; } }
+        public override int AosMaxDamage { get { return 17; } }
+        public override float MlSpeed { get { return 3.25f; } }
+        public override int DefHitSound { get { return 0x23B; } }
+        public override int DefMissSound { get { return 0x23A; } }
+        public override int InitMinHits { get { return 30; } }
+        public override int InitMaxHits { get { return 60; } }
+		
+        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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/BladedWhip.cs

@@ -0,0 +1,47 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    public class BladedWhip : BaseSword, Server.Engines.Craft.IRepairable
+    {
+		public Server.Engines.Craft.CraftSystem RepairSystem { get { return Server.Engines.Craft.DefTinkering.CraftSystem; } }
+        public override int LabelNumber { get { return 1125643; } } // Bladed Whip
+
+        [Constructable]
+        public BladedWhip()
+            : base(0xA28B)
+        {
+            Weight = 5.0;
+        }
+
+        public BladedWhip(Serial serial)
+            : base(serial)
+        {
+        }
+		
+		public override bool CanBeWornByGargoyles { get { return true; } }
+        public override WeaponAbility PrimaryAbility { get { return WeaponAbility.BleedAttack; } }
+        public override WeaponAbility SecondaryAbility { get { return WeaponAbility.WhirlwindAttack; } }
+        public override int AosStrengthReq { get { return 20; } }
+        public override int AosMinDamage { get { return 13; } }
+        public override int AosMaxDamage { get { return 17; } }
+        public override float MlSpeed { get { return 3.25f; } }
+        public override int DefHitSound { get { return 0x23B; } }
+        public override int DefMissSound { get { return 0x23A; } }
+        public override int InitMinHits { get { return 30; } }
+        public override int InitMaxHits { get { return 60; } }
+		
+        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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/Branch.cs

@@ -0,0 +1,60 @@
+using System;
+
+namespace Server.Items
+{
+    public class GoldBranch : Item
+    {
+        public override int LabelNumber { get { return 1158835; } } // branch
+
+        [Constructable]
+        public GoldBranch()
+            : base(Utility.RandomList(3458, 3473))
+        {
+            Hue = 2721;
+        }
+        public GoldBranch(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+
+    public class SilverBranch : Item
+    {
+        public override int LabelNumber { get { return 1158835; } } // branch
+
+        [Constructable]
+        public SilverBranch()
+            : base(Utility.RandomList(3458, 3473))
+        {
+            Hue = 2500;
+        }
+        public SilverBranch(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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/DirtySnowballs.cs

@@ -0,0 +1,33 @@
+using System;
+
+namespace Server.Items
+{
+    public class DirtySnowballs : SnowPile
+    {
+        public override int LabelNumber { get { return 1158833; } } // dirty snowballs
+
+        [Constructable]
+        public DirtySnowballs()
+        {
+            ItemID = 0xE74;
+            Hue = 1301;
+        }
+
+        public DirtySnowballs(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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/KrampusCoinPurse.cs

@@ -0,0 +1,61 @@
+using System;
+
+namespace Server.Items
+{
+    public class KrampusCoinPurse : Bag
+    {
+        [Constructable]
+        public KrampusCoinPurse()
+            : this(0)
+        {
+        }
+
+        public KrampusCoinPurse(int karma)
+        {
+            Name = "Krampus' Coin Purse"; // No Cliloc!
+
+            for (int i = 0; i < 25; i++)
+            {
+                DropItemStacked(Loot.RandomGem());
+            }
+
+            DropItem(new Gold(Utility.RandomMinMax(2000, 5000)));
+
+            if (.25 > Utility.RandomDouble())
+            {
+                if (Utility.RandomBool())
+                {
+                    DropItem(new DirtySnowballs());
+                }
+                else
+                {
+                    if (karma > 0)
+                    {
+                        DropItem(new GoldBranch());
+                    }
+                    else
+                    {
+                        DropItem(new SilverBranch());
+                    }
+                }
+            }
+        }
+
+        public KrampusCoinPurse(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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/KrampusMinionBoots.cs

@@ -0,0 +1,39 @@
+using System;
+
+namespace Server.Items
+{
+    public class KrampusMinionBoots : BaseShoes
+    {
+        public override int LabelNumber { get { return 1125637; } } // krampus minion boots
+
+        [Constructable]
+        public KrampusMinionBoots()
+            : this(0)
+        {
+            Weight = 2.0;
+        }
+
+        [Constructable]
+        public KrampusMinionBoots(int hue)
+            : base(0xA28D, hue)
+        {
+        }
+
+        public KrampusMinionBoots(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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/KrampusMinionEarrings.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace Server.Items
+{
+    public class KrampusMinionEarrings : BaseArmor
+    {
+        public override int LabelNumber { get { return 1125645; } } // krampus minion earrings        
+
+        [Constructable]
+        public KrampusMinionEarrings()
+            : base(0xA295)
+        {
+            Layer = Layer.Earrings;
+        }
+
+        public KrampusMinionEarrings(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Race RequiredRace { get { return Race.Gargoyle; } }
+        public override bool CanBeWornByGargoyles { get { return true; } }
+
+        public override ArmorMaterialType MaterialType { get { return ArmorMaterialType.Chainmail; } }
+        public override ArmorMeditationAllowance DefMedAllowance { get { return ArmorMeditationAllowance.All; } }
+
+        public override int BasePhysicalResistance { get { return 1; } }
+        public override int BaseFireResistance { get { return 2; } }
+        public override int BaseColdResistance { get { return 2; } }
+        public override int BasePoisonResistance { get { return 2; } }
+        public override int BaseEnergyResistance { get { return 3; } }
+
+        public override int InitMinHits { get { return 30; } }
+        public override int InitMaxHits { get { return 50; } }
+
+        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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/KrampusMinionHat.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace Server.Items
+{
+    public class KrampusMinionHat : BaseHat
+    {
+        public override int LabelNumber { get { return 1125639; } } // krampus minion hat
+
+        public override int BasePhysicalResistance { get { return 0; } }
+        public override int BaseFireResistance { get { return 5; } }
+        public override int BaseColdResistance { get { return 9; } }
+        public override int BasePoisonResistance { get { return 5; } }
+        public override int BaseEnergyResistance { get { return 5; } }
+
+        public override int InitMinHits { get { return 20; } }
+        public override int InitMaxHits { get { return 30; } }
+
+        [Constructable]
+        public KrampusMinionHat()
+            : this(0)
+        {
+        }
+
+        [Constructable]
+        public KrampusMinionHat(int hue)
+            : base(0xA28F, hue)
+        {
+            Weight = 3.0;
+        }
+
+        public KrampusMinionHat(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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/KrampusMinionTalons.cs

@@ -0,0 +1,50 @@
+using System;
+
+namespace Server.Items
+{
+    public class KrampusMinionTalons : BaseShoes
+    {
+        public override int LabelNumber { get { return 1125644; } } // krampus minion talons
+
+        [Constructable]
+        public KrampusMinionTalons()
+            : this(0)
+        {
+            Weight = 2.0;
+        }
+
+        [Constructable]
+        public KrampusMinionTalons(int hue)
+            : base(0xA294, 1153)
+        {
+        }
+
+        public KrampusMinionTalons(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Race RequiredRace { get { return Race.Gargoyle; } }
+        public override bool CanBeWornByGargoyles { get { return true; } }
+
+        public override CraftResource DefaultResource
+        {
+            get
+            {
+                return CraftResource.RegularLeather;
+            }
+        }
+
+        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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/KrampusPunishinList.cs

@@ -0,0 +1,44 @@
+using System;
+
+namespace Server.Items
+{
+    [Flipable(0x46AE, 0x46AF)]
+    public class KrampusPunishinList : Item
+    {
+        private string _Name;
+
+        [Constructable]
+        public KrampusPunishinList(string name)
+            : base(0x46AE)
+        {
+            _Name = name;
+            Hue = 0x21;
+        }
+
+        public override void AddNameProperty(ObjectPropertyList list)
+        {
+            list.Add(1158834, _Name);
+        }
+
+        public KrampusPunishinList(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+
+            writer.Write(_Name);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            _Name = reader.ReadString();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/NaughtyTitleDeed.cs

@@ -0,0 +1,32 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class NaughtyTitleDeed : BaseRewardTitleDeed
+    {
+        public override TextDefinition Title { get { return new TextDefinition(1158797); } } // Naughty
+
+        [Constructable]
+        public NaughtyTitleDeed()
+        {
+        }
+
+        public NaughtyTitleDeed(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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/NiceTitleDeed.cs

@@ -0,0 +1,32 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class NiceTitleDeed : BaseRewardTitleDeed
+    {
+        public override TextDefinition Title { get { return new TextDefinition(1158798); } } // Nice
+
+        [Constructable]
+        public NiceTitleDeed()
+        {
+        }
+
+        public NiceTitleDeed(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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/PunisherTitleDeed.cs

@@ -0,0 +1,32 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Items
+{
+    public class PunisherTitleDeed : BaseRewardTitleDeed
+    {
+        public override TextDefinition Title { get { return new TextDefinition(1158795); } } // Punisher
+
+        [Constructable]
+        public PunisherTitleDeed()
+        {
+        }
+
+        public PunisherTitleDeed(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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Items/SpikedWhip.cs

@@ -0,0 +1,50 @@
+using System;
+using Server.Engines.Craft;
+
+namespace Server.Items
+{
+    public class SpikedWhip : BaseSword, Server.Engines.Craft.IRepairable
+    {
+		public Server.Engines.Craft.CraftSystem RepairSystem { get { return Server.Engines.Craft.DefTinkering.CraftSystem; } }
+        public override int LabelNumber { get { return 1125634; } } // Spiked Whip
+
+        [Constructable]
+        public SpikedWhip()
+            : base(0xA292)
+        {
+            Weight = 5.0;
+        }
+
+        public SpikedWhip(Serial serial)
+            : base(serial)
+        {
+        }
+
+		public override bool CanBeWornByGargoyles { get { return true; } }
+        public override WeaponAbility PrimaryAbility { get { return WeaponAbility.ArmorPierce; } }
+        public override WeaponAbility SecondaryAbility { get { return WeaponAbility.WhirlwindAttack; } }
+        public override int AosStrengthReq { get { return 20; } }
+        public override int AosMinDamage { get { return 13; } }
+        public override int AosMaxDamage { get { return 17; } }
+        public override float MlSpeed { get { return 3.25f; } }
+        public override int DefHitSound { get { return 0x23B; } }
+        public override int DefMissSound { get { return 0x23A; } }
+        public override int InitMinHits { get { return 30; } }
+        public override int InitMaxHits { get { return 60; } }
+        public override SkillName DefSkill { get { return SkillName.Fencing; } }
+        public override WeaponType DefType { get { return WeaponType.Piercing; } }
+        public override WeaponAnimation DefAnimation { get { return WeaponAnimation.Pierce1H; } }
+
+        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();
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/KrampusEncounter.cs

@@ -0,0 +1,337 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+using Server;
+using Server.Items;
+using Server.Mobiles;
+using Server.Engines.CityLoyalty;
+using Server.Spells;
+using Server.Network;
+using Server.Commands;
+using Server.Gumps;
+
+namespace Server.Engines.SeasonalEvents
+{
+    [PropertyObject]
+    public class KrampusEncounter
+    {
+        public static string FilePath = Path.Combine("Saves/Misc", "KrampusEncounter.bin");
+
+        public static bool Enabled { get { return SeasonalEventSystem.IsActive(EventType.KrampusEncounter); } }
+        public static KrampusEncounter Encounter { get; set; }
+
+        public static readonly int MinComplete = 20;
+
+        public static void Configure()
+        {
+            EventSink.WorldSave += OnSave;
+            EventSink.WorldLoad += OnLoad;
+        }
+
+        public static void Initialize()
+        {
+            CommandSystem.Register("KrampusEncounter", AccessLevel.Administrator, e =>
+            {
+                if (Encounter != null)
+                {
+                    e.Mobile.SendGump(new PropertiesGump(e.Mobile, Encounter));
+                }
+                else
+                {
+                    e.Mobile.SendMessage("Encounter null");
+                }
+            });
+        }
+
+        public static void OnSave(WorldSaveEventArgs e)
+        {
+            CheckEnabled();
+
+            Persistence.Serialize(
+                FilePath,
+                writer =>
+                {
+                    writer.Write(0);
+
+                    if (Encounter != null)
+                    {
+                        writer.Write(1);
+                        Encounter.Serialize(writer);
+                    }
+                    else
+                    {
+                        writer.Write(0);
+                    }
+                });
+        }
+
+        public static void OnLoad()
+        {
+            Persistence.Deserialize(
+                FilePath,
+                reader =>
+                {
+                    reader.ReadInt(); // version
+
+                    if (reader.ReadInt() == 1)
+                    {
+                        Encounter = new KrampusEncounter();
+                        Encounter.Deserialize(reader);
+                    }
+                });
+        }
+
+        public static void CheckEnabled()
+        {
+            if (Enabled)
+            {
+                if (Encounter == null)
+                {
+                    Encounter = new KrampusEncounter();
+                }
+            }
+            else
+            {
+                if (Encounter != null && Encounter.Krampus == null)
+                {
+                    Encounter = null;
+                }
+            }
+        }
+
+        public static bool KrampusSpawned()
+        {
+            return Enabled && Encounter != null && Encounter.Krampus != null && !Encounter.Krampus.Deleted;
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int TotalTradesComplete { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public int Wave { get { return (int)Math.Max(1, (int)Math.Min(6, (double)TotalTradesComplete / 4.1)); } }
+
+        public Dictionary<PlayerMobile, int> CompleteTable { get; set; } = new Dictionary<PlayerMobile, int>();
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Krampus Krampus { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Point3D SpawnLocation { get; set; }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool KrampusSpawning { get { return SpawnMap != null && SpawnLocation != Point3D.Zero; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Map SpawnMap { get; set; }
+
+        public KrampusEncounter()
+        {
+        }
+
+        public void OnTradeComplete(Mobile m, TradeEntry entry)
+        {
+            bool distCheck = entry.Distance > 0;
+
+            // 0 distance indicates they used a moongate
+            if (m is PlayerMobile && distCheck)
+            {
+                var pm = (PlayerMobile)m;
+
+                if (!CompleteTable.ContainsKey(pm))
+                {
+                    CompleteTable[pm] = 1;
+                }
+                else
+                {
+                    CompleteTable[pm]++;
+                }
+            }
+
+            if (TotalTradesComplete > MinComplete || distCheck)
+            {
+                TotalTradesComplete++;
+            }
+        }
+
+        public Type[] GetCreatureTypes(Mobile m, bool wet)
+        {
+            if (Krampus != null || KrampusSpawning)
+            {
+                return null;
+            }
+
+            if (wet)
+            {
+                return _WetSpawnTypes;
+            }
+            else
+            {
+                var wave = (int)Math.Max(1, (int)Math.Min(6, (double)TotalTradesComplete / 4.1)); // TODO: Is this right?
+
+                if (wave == 6)
+                {
+                    if ((m.Map == Map.Trammel || (Siege.SiegeShard && m.Map == Map.Felucca)) && !SpellHelper.IsAnyT2A(m.Map, m.Location))
+                    {
+                        SpawnKrampus(m);
+
+                        return null;
+                    }
+
+                    return _SpawnTypes[4];
+                }
+
+                return _SpawnTypes[wave - 1];
+            }
+        }
+
+        private void SpawnKrampus(Mobile m)
+        {
+            SpawnMap = m.Map;
+            var p = m.Location;
+
+            for (int i = 0; i < 25; i++)
+            {
+                int x = p.X + (Utility.RandomMinMax(-3, 3));
+                int y = p.Y + (Utility.RandomMinMax(-3, 3));
+                int z = m.Map.GetAverageZ(x, y);
+
+                if (SpawnMap.CanSpawnMobile(x, y, z))
+                {
+                    p = new Point3D(x, y, z);
+                    break;
+                }
+            }
+
+            SpawnLocation = p;
+
+            foreach (var ns in NetState.Instances)
+            {
+                var mob = ns.Mobile;
+
+                if (mob != null && CityTradeSystem.HasTrade(mob))
+                {
+                    mob.LocalOverheadMessage(MessageType.Regular, 1150, 1158832, String.Format("{0}\t{1}", WorldLocationInfo.GetLocationString(SpawnLocation, SpawnMap), Sextant.GetCoords(SpawnLocation, SpawnMap))); // *You sense Krampus has been spotted near ~2_where~ at ~1_coords~!*
+                }
+            }
+
+            Timer.DelayCall(TimeSpan.FromMinutes(5), () =>
+            {
+                SpawnKrampus();
+            });
+        }
+
+        private void SpawnKrampus()
+        {
+            Krampus = new Krampus();
+            Krampus.SpawnLocation = SpawnLocation;
+            Krampus.Home = SpawnLocation;
+            Krampus.RangeHome = 5;
+
+            Krampus.MoveToWorld(SpawnLocation, SpawnMap);
+            Krampus.Summon(Krampus, true);
+
+            var rec = new Rectangle2D(SpawnLocation.X - 10, SpawnLocation.Y - 10, 20, 20);
+
+            for (var i = 0; i < 2; i++)
+            {
+                var drake = new FrostDrake();
+
+                Point3D p = new Point3D(SpawnLocation);
+
+                for (int j = 0; i < 10; j++)
+                {
+                    p = SpawnMap.GetRandomSpawnPoint(rec);
+
+                    if (SpawnMap.CanSpawnMobile(p.X, p.Y, p.Z))
+                    {
+                        break;
+                    }
+                }
+
+                drake.MoveToWorld(p, SpawnMap);
+                drake.Home = p;
+                drake.RangeHome = 15;
+            }
+
+            SpawnLocation = Point3D.Zero;
+            SpawnMap = null;
+        }
+
+        public void OnKrampusKilled()
+        {
+            Krampus = null;
+
+            CompleteTable.Clear();
+            TotalTradesComplete = 0;
+
+            if (!Enabled)
+            {
+                Encounter = null;
+            }
+        }
+
+        public Type[][] _SpawnTypes =
+        {
+            new Type[] { typeof(FrostOoze), typeof(FrostSpider) },
+            new Type[] { typeof(SnowElemental), typeof(IceElemental) },
+            new Type[] { typeof(IceSerpent), typeof(FrostTroll) },
+            new Type[] { typeof(IceFiend), typeof(WhiteWyrm) },
+			new Type[] { typeof(KrampusMinion) },
+			new Type[] { typeof(Krampus) }
+        };
+
+        public Type[] _WetSpawnTypes =
+        {
+            typeof(SeaSerpent), typeof(DeepSeaSerpent), typeof(Kraken), typeof(WaterElemental)
+        };
+
+        public void Serialize(GenericWriter writer)
+        {
+            writer.Write(0);
+
+            writer.Write(Krampus);
+            writer.Write(SpawnLocation);
+            writer.Write(SpawnMap);
+
+            writer.Write(TotalTradesComplete);
+
+            writer.Write(CompleteTable.Count);
+
+            foreach (var kvp in CompleteTable)
+            {
+                writer.Write(kvp.Key);
+                writer.Write(kvp.Value);
+            }
+        }
+
+        public void Deserialize(GenericReader reader)
+        {
+            reader.ReadInt();
+
+            Krampus = reader.ReadMobile() as Krampus;
+            SpawnLocation = reader.ReadPoint3D();
+            SpawnMap = reader.ReadMap();
+
+            TotalTradesComplete = reader.ReadInt();
+
+            int count = reader.ReadInt();
+
+            for (int i = 0; i < count; i++)
+            {
+                var m = reader.ReadMobile() as PlayerMobile;
+                var c = reader.ReadInt();
+
+                if (m != null)
+                {
+                    CompleteTable[m] = c;
+                }
+            }
+
+            if (KrampusSpawning && Krampus == null)
+            {
+                Timer.DelayCall(TimeSpan.FromMinutes(2), SpawnKrampus);
+            }
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Mobiles/Krampus.cs

@@ -0,0 +1,450 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Server;
+using Server.Items;
+using Server.Engines.SeasonalEvents;
+using Server.Spells;
+
+namespace Server.Mobiles
+{
+    [CorpseName("the corpse of krampus")]
+    public class Krampus : BaseCreature
+    {
+        public override bool TeleportsTo { get { return true; } }
+
+        public List<BaseCreature> SummonedHelpers { get; set; }
+        public List<BaseCreature> InitialSpawn { get; set; }
+
+        private DateTime _NextSpecial;
+        public const int MaxSummons = 24;
+
+        private DateTime _LastActivity;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public Point3D SpawnLocation { get; set; }
+
+        public bool IsKrampusEncounter { get { return KrampusEncounter.Encounter != null && KrampusEncounter.Encounter.Krampus == this; } }
+
+        [Constructable]
+        public Krampus()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            Name = "Krampus";
+            Body = 1484;
+
+            SetStr(700, 750);
+            SetDex(800, 900);
+            SetInt(500, 600);
+
+            SetHits(40000);
+
+            SetDamage(28, 35);
+
+            SetDamageType(ResistanceType.Physical, 50);
+            SetDamageType(ResistanceType.Cold, 50);
+
+            SetResistance(ResistanceType.Physical, 80, 90);
+            SetResistance(ResistanceType.Fire, 70, 80);
+            SetResistance(ResistanceType.Cold, 80, 90);
+            SetResistance(ResistanceType.Poison, 70, 80);
+            SetResistance(ResistanceType.Energy, 70, 80);
+
+            SetSkill(SkillName.MagicResist, 150);
+            SetSkill(SkillName.Tactics, 110, 120);
+            SetSkill(SkillName.Wrestling, 120.0, 125.0);
+            SetSkill(SkillName.DetectHidden, 60.0, 70.0);
+            SetSkill(SkillName.Parry, 60, 70);
+
+            Fame = 30000;
+            Karma = -30000;
+
+            switch (Utility.Random(3))
+            {
+                case 0:
+                    SetMagicalAbility(MagicalAbility.Piercing); break;
+                case 1:
+                    SetMagicalAbility(MagicalAbility.Bashing); break;
+                case 2:
+                    SetMagicalAbility(MagicalAbility.Slashing); break;
+            }
+
+            _NextSpecial = DateTime.UtcNow;
+        }
+
+        public int TotalSummons()
+        {
+            if (SummonedHelpers == null)
+            {
+                return 0;
+            }
+
+            return SummonedHelpers.Where(bc => bc != null && bc.Alive).Count();
+        }
+
+        public void Summon(Mobile target, bool initial = false)
+        {
+            if (target == null || (!initial && InitialSpawn != null && InitialSpawn.Count > 0))
+                return;
+
+            var map = Map;
+
+            if (map == null || TotalSummons() > MaxSummons)
+                return;
+
+            if (!initial)
+            {
+                MovingEffect(target, 0xA271, 10, 0, false, false, 0, 0);
+            }
+
+            Timer.DelayCall(TimeSpan.FromSeconds(initial ? 0.25 : 1.0), com =>
+            {
+                if (!com.Alive)
+                    return;
+
+                int count = Utility.RandomMinMax(3, 5);
+
+                for (int i = 0; i < count; i++)
+                {
+                    Point3D p = com.Location;
+
+                    for (int j = 0; j < 10; j++)
+                    {
+                        int x = Utility.RandomMinMax(p.X - 3, p.X + 3);
+                        int y = Utility.RandomMinMax(p.Y - 3, p.Y + 3);
+                        int z = map.GetAverageZ(x, y);
+
+                        if (map.CanSpawnMobile(x, y, z))
+                        {
+                            p = new Point3D(x, y, z);
+                            break;
+                        }
+                    }
+
+                    BaseCreature spawn = new KrampusMinion();
+
+                    if (spawn != null)
+                    {
+                        spawn.MoveToWorld(p, map);
+                        spawn.Home = p;
+                        spawn.RangeHome = 5;
+                        spawn.Team = this.Team;
+                        spawn.SummonMaster = this;
+
+                        if (!initial)
+                        {
+                            if (spawn.Combatant != null)
+                            {
+                                if (!(spawn.Combatant is PlayerMobile) || !((PlayerMobile)spawn.Combatant).HonorActive)
+                                    spawn.Combatant = com;
+                            }
+                            else
+                            {
+                                spawn.Combatant = com;
+                            }
+                        }
+
+                        AddHelper(spawn, initial);
+                    }
+                }
+
+                if (initial)
+                {
+                    Blessed = true;
+                }
+            }, target);
+
+            _NextSpecial = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(20, 40));
+        }
+
+        protected virtual void AddHelper(BaseCreature bc, bool initial)
+        {
+            if (initial)
+            {
+                if (InitialSpawn == null)
+                    InitialSpawn = new List<BaseCreature>();
+
+                if (!InitialSpawn.Contains(bc))
+                    InitialSpawn.Add(bc);
+            }
+            else
+            {
+                if (SummonedHelpers == null)
+                    SummonedHelpers = new List<BaseCreature>();
+
+                if (!SummonedHelpers.Contains(bc))
+                    SummonedHelpers.Add(bc);
+            }
+        }
+
+        private Mobile _LastTeleported;
+
+        public override void OnAfterTeleport(Mobile m)
+        {
+            m.SendLocalizedMessage(1072195); // Without warning, you are magically transported closer to your enemy!
+        }
+
+        public override void OnGaveMeleeAttack(Mobile defender)
+        {
+            base.OnGaveMeleeAttack(defender);
+
+            if (defender == _LastTeleported)
+            {
+                BoneBreakerContext.CheckHit(this, defender);
+            }
+
+            _LastTeleported = null;
+        }
+
+        public override int GetIdleSound()
+        {
+            return 1589;
+        }
+
+        public override int GetAngerSound()
+        {
+            return 1586;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 1588;
+        }
+
+        public override int GetDeathSound()
+        {
+            return 1587;
+        }
+
+        public Krampus(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.SuperBoss, 5);
+        }
+
+        public override void OnThink()
+        {
+            base.OnThink();
+
+            if (Blessed)
+            {
+                if (InitialSpawn != null)
+                {
+                    if (InitialSpawn.All(s => s.Deleted))
+                    {
+                        ColUtility.Free(InitialSpawn);
+                        InitialSpawn = null;
+
+                        Blessed = false;
+                    }
+                }
+                else
+                {
+                    Blessed = false;
+                }
+            }
+
+            if (Combatant == null)
+            {
+                if (SpawnLocation != Point3D.Zero &&
+                    _LastActivity > DateTime.MinValue &&
+                    _LastActivity + TimeSpan.FromHours(2) < DateTime.UtcNow)
+                {
+                    Delete();
+                }
+
+                return;
+            }
+
+            _LastActivity = DateTime.UtcNow;
+
+            if (_NextSpecial < DateTime.UtcNow && 0.25 > Utility.RandomDouble())
+            {
+                if (Utility.RandomBool())
+                {
+                    var target = GetTeleportTarget();
+
+                    if (target != null)
+                    {
+                        Summon(target);
+                    }
+                }
+                else
+                {
+                    int baseDamage = 100;
+                    bool switched = false;
+
+                    PlaySound(0x20D);
+
+                    foreach (var m in SpellHelper.AcquireIndirectTargets(this, Location, Map, 10).OfType<Mobile>())
+                    {
+                        var range = (int)GetDistanceToSqrt(m);
+
+                        if (range < 1) range = 1;
+                        if (range > 4) range = 4;
+
+                        m.PlaySound(0x20D);
+                        AOS.Damage(this, m, baseDamage / range, 0, 0, 0, 0, 0, 100, 0);
+
+                        if (!switched && 0.2 > Utility.RandomDouble())
+                        {
+                            Combatant = m;
+                            switched = true;
+                        }
+                    }
+                }
+
+                _NextSpecial = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(30, 60));
+            }
+
+            if (Map != null && SpawnLocation != Point3D.Zero && !Utility.InRange(Location, SpawnLocation, 25))
+            {
+                MoveToWorld(SpawnLocation, Map);
+            }
+        }
+
+        public override void OnDeath(Container c)
+        {
+            if (IsKrampusEncounter)
+            {
+                var rights = GetLootingRights();
+
+                foreach (var ds in rights.Where(s => s.m_Mobile is PlayerMobile && s.m_HasRight))
+                {
+                    var m = ds.m_Mobile as PlayerMobile;
+                    int ordersComplete = 0;
+
+                    if (KrampusEncounter.Encounter.CompleteTable.ContainsKey(m))
+                    {
+                        ordersComplete = KrampusEncounter.Encounter.CompleteTable[m];
+                    }
+
+                    if (ordersComplete >= 3 || Utility.RandomMinMax(0, 8) <= ordersComplete)
+                    {
+                        Item item = null;
+
+                        switch (Utility.Random(13))
+                        {
+                            case 0: item = new KrampusCoinPurse(m.Karma); break;
+                            case 1: item = new CardOfSemidar(Utility.RandomMinMax(0, 6)); break;
+                            case 2: item = new NiceTitleDeed(); break;
+                            case 3: item = new NaughtyTitleDeed(); break;
+                            case 4: item = new PunisherTitleDeed(); break;
+                            case 5: item = new RecipeScroll(586); break; // minion hat
+                            case 6: item = new RecipeScroll(587); break; // minion boots
+                            case 7: item = new KrampusCoinPurse(463); break; // minion talons
+                            case 8: item = new KrampusCoinPurse(588); break; // minion earrings
+                            case 9: item = new KrampusPunishinList(m.Name); break;
+                            case 10: item = new SpikedWhip(); break;
+                            case 11: item = new BarbedWhip(); break;
+                            case 12: item = new BladedWhip(); break;
+                        }
+
+                        if (item != null)
+                        {
+                            m.SendLocalizedMessage(1156269); // For your valor in defeating your foe a specialty item has been awarded to you!
+
+                            if (m.Backpack == null || !m.Backpack.TryDropItem(m, item, false))
+                            {
+                                m.BankBox.DropItem(item);
+                            }
+                        }
+                    }
+                }
+            }
+
+            base.OnDeath(c);
+        }
+
+        public override void Delete()
+        {
+            base.Delete();
+
+            if (IsKrampusEncounter)
+            {
+                KrampusEncounter.Encounter.OnKrampusKilled();
+            }
+
+            if (SummonedHelpers != null)
+            {
+                ColUtility.SafeDelete(SummonedHelpers);
+                ColUtility.Free(SummonedHelpers);
+            }
+
+            if (InitialSpawn != null)
+            {
+                ColUtility.SafeDelete(InitialSpawn);
+                ColUtility.Free(InitialSpawn);
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+
+            writer.Write(SpawnLocation);
+
+            writer.Write(SummonedHelpers == null ? 0 : SummonedHelpers.Count);
+
+            if (SummonedHelpers != null)
+                SummonedHelpers.ForEach(m => writer.Write(m));
+
+            writer.Write(InitialSpawn == null ? 0 : InitialSpawn.Count);
+
+            if (InitialSpawn != null)
+                InitialSpawn.ForEach(m => writer.Write(m));
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            SpawnLocation = reader.ReadPoint3D();
+
+            int count = reader.ReadInt();
+
+            if (count > 0)
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    BaseCreature summon = reader.ReadMobile() as BaseCreature;
+
+                    if (summon != null)
+                    {
+                        if (SummonedHelpers == null)
+                            SummonedHelpers = new List<BaseCreature>();
+
+                        SummonedHelpers.Add(summon);
+                    }
+                }
+            }
+
+            count = reader.ReadInt();
+
+            if (count > 0)
+            {
+                for (int i = 0; i < count; i++)
+                {
+                    BaseCreature summon = reader.ReadMobile() as BaseCreature;
+
+                    if (summon != null)
+                    {
+                        if (InitialSpawn == null)
+                            InitialSpawn = new List<BaseCreature>();
+
+                        InitialSpawn.Add(summon);
+                    }
+                }
+            }
+
+            _NextSpecial = DateTime.UtcNow;
+        }
+    }
+}

Scripts/Services/Seasonal Events/KrampusEncounter/Mobiles/KrampusMinion.cs

@@ -0,0 +1,68 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a minion corpse")]
+    public class KrampusMinion : BaseCreature
+    {
+        [Constructable]
+        public KrampusMinion()
+           : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            Name = "Minion";
+            Body = 1485;
+            BaseSoundID = 422;
+
+            SetStr(476, 505);
+            SetDex(76, 95);
+            SetInt(301, 325);
+
+            SetHits(286, 303);
+
+            SetDamage(7, 14);
+
+            SetDamageType(ResistanceType.Physical, 50);
+            SetDamageType(ResistanceType.Cold, 50);
+
+            SetResistance(ResistanceType.Physical, 60, 70);
+            SetResistance(ResistanceType.Fire, 40, 50);
+            SetResistance(ResistanceType.Cold, 50, 60);
+            SetResistance(ResistanceType.Poison, 40, 50);
+            SetResistance(ResistanceType.Energy, 40, 50);
+
+            SetSkill(SkillName.Tactics, 110, 120);
+            SetSkill(SkillName.Wrestling, 100, 110);
+            SetSkill(SkillName.DetectHidden, 60.0, 70.0);
+            SetSkill(SkillName.MagicResist, 120);
+            SetSkill(SkillName.Parry, 60, 70);
+
+            Fame = 3000;
+            Karma = -3000;
+        }
+
+        public KrampusMinion(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Average);
+            AddLoot(LootPack.LowScrolls);
+            AddLoot(LootPack.Potions);
+        }
+
+        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();
+        }
+    }
+}