Reorganizes Project (#41)

Projects/Scripts/Items/Special/Holiday/Christmas/HolidayTree.cs

@@ -0,0 +1,300 @@
+using System;
+using System.Collections.Generic;
+using Server.Multis;
+
+namespace Server.Items
+{
+  public enum HolidayTreeType
+  {
+    Classic,
+    Modern
+  }
+
+  public class HolidayTree : Item, IAddon
+  {
+    private List<Item> m_Components;
+
+    public HolidayTree(Mobile from, HolidayTreeType type, Point3D loc) : base(1)
+    {
+      Movable = false;
+      MoveToWorld(loc, from.Map);
+
+      Placer = from;
+      m_Components = new List<Item>();
+
+      switch (type)
+      {
+        case HolidayTreeType.Classic:
+        {
+          ItemID = 0xCD7;
+
+          AddItem(0, 0, 0, new TreeTrunk(this, 0xCD6));
+
+          AddOrnament(0, 0, 2, 0xF22);
+          AddOrnament(0, 0, 9, 0xF18);
+          AddOrnament(0, 0, 15, 0xF20);
+          AddOrnament(0, 0, 19, 0xF17);
+          AddOrnament(0, 0, 20, 0xF24);
+          AddOrnament(0, 0, 20, 0xF1F);
+          AddOrnament(0, 0, 20, 0xF19);
+          AddOrnament(0, 0, 21, 0xF1B);
+          AddOrnament(0, 0, 28, 0xF2F);
+          AddOrnament(0, 0, 30, 0xF23);
+          AddOrnament(0, 0, 32, 0xF2A);
+          AddOrnament(0, 0, 33, 0xF30);
+          AddOrnament(0, 0, 34, 0xF29);
+          AddOrnament(0, 1, 7, 0xF16);
+          AddOrnament(0, 1, 7, 0xF1E);
+          AddOrnament(0, 1, 12, 0xF0F);
+          AddOrnament(0, 1, 13, 0xF13);
+          AddOrnament(0, 1, 18, 0xF12);
+          AddOrnament(0, 1, 19, 0xF15);
+          AddOrnament(0, 1, 25, 0xF28);
+          AddOrnament(0, 1, 29, 0xF1A);
+          AddOrnament(0, 1, 37, 0xF2B);
+          AddOrnament(1, 0, 13, 0xF10);
+          AddOrnament(1, 0, 14, 0xF1C);
+          AddOrnament(1, 0, 16, 0xF14);
+          AddOrnament(1, 0, 17, 0xF26);
+          AddOrnament(1, 0, 22, 0xF27);
+
+          break;
+        }
+        case HolidayTreeType.Modern:
+        {
+          ItemID = 0x1B7E;
+
+          AddOrnament(0, 0, 2, 0xF2F);
+          AddOrnament(0, 0, 2, 0xF20);
+          AddOrnament(0, 0, 2, 0xF22);
+          AddOrnament(0, 0, 5, 0xF30);
+          AddOrnament(0, 0, 5, 0xF15);
+          AddOrnament(0, 0, 5, 0xF1F);
+          AddOrnament(0, 0, 5, 0xF2B);
+          AddOrnament(0, 0, 6, 0xF0F);
+          AddOrnament(0, 0, 7, 0xF1E);
+          AddOrnament(0, 0, 7, 0xF24);
+          AddOrnament(0, 0, 8, 0xF29);
+          AddOrnament(0, 0, 9, 0xF18);
+          AddOrnament(0, 0, 14, 0xF1C);
+          AddOrnament(0, 0, 15, 0xF13);
+          AddOrnament(0, 0, 15, 0xF20);
+          AddOrnament(0, 0, 16, 0xF26);
+          AddOrnament(0, 0, 17, 0xF12);
+          AddOrnament(0, 0, 18, 0xF17);
+          AddOrnament(0, 0, 20, 0xF1B);
+          AddOrnament(0, 0, 23, 0xF28);
+          AddOrnament(0, 0, 25, 0xF18);
+          AddOrnament(0, 0, 25, 0xF2A);
+          AddOrnament(0, 1, 7, 0xF16);
+
+          break;
+        }
+      }
+    }
+
+    public HolidayTree(Serial serial) : base(serial)
+    {
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public Mobile Placer{ get; set; }
+
+    public override int LabelNumber => 1041117; // a tree for the holidays
+
+    public bool CouldFit(IPoint3D p, Map map)
+    {
+      return map.CanFit((Point3D)p, 20);
+    }
+
+    Item IAddon.Deed => new HolidayTreeDeed();
+
+    public override void OnAfterDelete()
+    {
+      for (int i = 0; i < m_Components.Count; ++i)
+        m_Components[i].Delete();
+    }
+
+    private void AddOrnament(int x, int y, int z, int itemID)
+    {
+      AddItem(x + 1, y + 1, z + 11, new Ornament(itemID));
+    }
+
+    private void AddItem(int x, int y, int z, Item item)
+    {
+      item.MoveToWorld(new Point3D(Location.X + x, Location.Y + y, Location.Z + z), Map);
+
+      m_Components.Add(item);
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(1); // version
+
+      writer.Write(Placer);
+
+      writer.Write(m_Components.Count);
+
+      for (int i = 0; i < m_Components.Count; ++i)
+        writer.Write(m_Components[i]);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 1:
+        {
+          Placer = reader.ReadMobile();
+
+          goto case 0;
+        }
+        case 0:
+        {
+          int count = reader.ReadInt();
+
+          m_Components = new List<Item>(count);
+
+          for (int i = 0; i < count; ++i)
+          {
+            Item item = reader.ReadItem();
+
+            if (item != null)
+              m_Components.Add(item);
+          }
+
+          break;
+        }
+      }
+
+      Timer.DelayCall(TimeSpan.Zero, ValidatePlacement);
+    }
+
+    public void ValidatePlacement()
+    {
+      if (BaseHouse.FindHouseAt(this) == null)
+      {
+        HolidayTreeDeed deed = new HolidayTreeDeed();
+        deed.MoveToWorld(Location, Map);
+        Delete();
+      }
+    }
+
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      if (from.InRange(GetWorldLocation(), 1))
+      {
+        if (Placer == null || from == Placer || from.AccessLevel >= AccessLevel.GameMaster)
+        {
+          from.AddToBackpack(new HolidayTreeDeed());
+
+          Delete();
+
+          BaseHouse house = BaseHouse.FindHouseAt(this);
+
+          if (house?.Addons.Contains(this) == true)
+            house.Addons.Remove(this);
+
+          from.SendLocalizedMessage(503393); // A deed for the tree has been placed in your backpack.
+        }
+        else
+        {
+          from.SendLocalizedMessage(503396); // You cannot take this tree down.
+        }
+      }
+      else
+      {
+        from.SendLocalizedMessage(500446); // That is too far away.
+      }
+    }
+
+    private class Ornament : Item
+    {
+      public Ornament(int itemID) : base(itemID)
+      {
+        Movable = false;
+      }
+
+      public Ornament(Serial serial) : base(serial)
+      {
+      }
+
+      public override int LabelNumber => 1041118; // a tree ornament
+
+      public override void Serialize(GenericWriter writer)
+      {
+        base.Serialize(writer);
+
+        writer.Write(0); // version
+      }
+
+      public override void Deserialize(GenericReader reader)
+      {
+        base.Deserialize(reader);
+
+        int version = reader.ReadInt();
+      }
+    }
+
+    private class TreeTrunk : Item
+    {
+      private HolidayTree m_Tree;
+
+      public TreeTrunk(HolidayTree tree, int itemID) : base(itemID)
+      {
+        Movable = false;
+        MoveToWorld(tree.Location, tree.Map);
+
+        m_Tree = tree;
+      }
+
+      public TreeTrunk(Serial serial) : base(serial)
+      {
+      }
+
+      public override int LabelNumber => 1041117; // a tree for the holidays
+
+      public override void OnDoubleClick(Mobile from)
+      {
+        if (m_Tree?.Deleted == false)
+          m_Tree.OnDoubleClick(from);
+      }
+
+      public override void Serialize(GenericWriter writer)
+      {
+        base.Serialize(writer);
+
+        writer.Write(0); // version
+
+        writer.Write(m_Tree);
+      }
+
+      public override void Deserialize(GenericReader reader)
+      {
+        base.Deserialize(reader);
+
+        int version = reader.ReadInt();
+
+        switch (version)
+        {
+          case 0:
+          {
+            m_Tree = reader.ReadItem() as HolidayTree;
+
+            if (m_Tree == null)
+              Delete();
+
+            break;
+          }
+        }
+      }
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/GiftBox.cs

@@ -0,0 +1,37 @@
+namespace Server.Items
+{
+  [Furniture]
+  [Flippable(0x232A, 0x232B)]
+  public class GiftBox : BaseContainer
+  {
+    [Constructible]
+    public GiftBox() : this(Utility.RandomDyedHue())
+    {
+    }
+
+    [Constructible]
+    public GiftBox(int hue) : base(Utility.Random(0x232A, 2))
+    {
+      Weight = 2.0;
+      Hue = hue;
+    }
+
+    public GiftBox(Serial serial) : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/GingerBreadHouseDeed.cs

@@ -0,0 +1,62 @@
+namespace Server.Items
+{
+  public class GingerBreadHouseAddon : BaseAddon
+  {
+    public GingerBreadHouseAddon()
+    {
+      for (int i = 0x2be5; i < 0x2be8; i++)
+      {
+        LocalizedAddonComponent laoc = new LocalizedAddonComponent(i, 1077395); // Gingerbread House
+        laoc.Light = LightType.SouthSmall;
+        AddComponent(laoc, i == 0x2be5 ? -1 : 0, i == 0x2be7 ? -1 : 0, 0);
+      }
+    }
+
+    public GingerBreadHouseAddon(Serial serial) : base(serial)
+    {
+    }
+
+    public override BaseAddonDeed Deed => new GingerBreadHouseDeed();
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class GingerBreadHouseDeed : BaseAddonDeed
+  {
+    [Constructible]
+    public GingerBreadHouseDeed()
+    {
+      Weight = 1.0;
+      LootType = LootType.Blessed;
+    }
+
+    public GingerBreadHouseDeed(Serial serial) : base(serial)
+    {
+    }
+
+    public override int LabelNumber => 1077394; //a Gingerbread House Deed
+    public override BaseAddon Addon => new GingerBreadHouseAddon();
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/HolidayBell.cs

@@ -0,0 +1,111 @@
+namespace Server.Items
+{
+  public class HolidayBell : Item
+  {
+    private static string[] m_StaffNames =
+    {
+      "Adrick",
+      "Alai",
+      "Bulldoz",
+      "Evocare",
+      "FierY-iCe",
+      "Greyburn",
+      "Hanse",
+      "Ignatz",
+      "Jalek",
+      "LadyMOI",
+      "Lord Krum",
+      "Malantus",
+      "Nimrond",
+      "Oaks",
+      "Prophet",
+      "Runesabre",
+      "Sage",
+      "Stellerex",
+      "T-Bone",
+      "Tajima",
+      "Tyrant",
+      "Vex"
+    };
+
+    private static int[] m_Hues =
+    {
+      0xA, 0x24, 0x42, 0x56, 0x1A, 0x4C, 0x3C, 0x60, 0x2E, 0x55, 0x23, 0x38, 0x482, 0x6, 0x10
+    };
+
+    private string m_Maker;
+    private int m_SoundID;
+
+    [Constructible]
+    public HolidayBell()
+      : this(m_StaffNames[Utility.Random(m_StaffNames.Length)])
+    {
+    }
+
+    [Constructible]
+    public HolidayBell(string maker)
+      : base(0x1C12)
+    {
+      m_Maker = maker;
+
+      LootType = LootType.Blessed;
+      Hue = m_Hues[Utility.Random(m_Hues.Length)];
+      SoundID = 0x0F5 + Utility.Random(14);
+    }
+
+    public HolidayBell(Serial serial)
+      : base(serial)
+    {
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public int SoundID
+    {
+      get => m_SoundID;
+      set
+      {
+        m_SoundID = value;
+        InvalidateProperties();
+      }
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public string Giver
+    {
+      get => m_Maker;
+      set => m_Maker = value;
+    }
+
+    public override string DefaultName => $"A Holiday Bell From {Giver}";
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      if (!from.InRange(GetWorldLocation(), 2))
+        from.SendLocalizedMessage(500446); // That is too far away.
+      else from.PlaySound(m_SoundID);
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+
+      writer.Write(m_Maker);
+
+      writer.WriteEncodedInt(m_SoundID);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      m_Maker = reader.ReadString();
+      m_SoundID = reader.ReadEncodedInt();
+
+      Utility.Intern(ref m_Maker);
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/HolidayFoods.cs

@@ -0,0 +1,165 @@
+using System;
+using System.Collections.Generic;
+
+namespace Server.Items
+{
+  public class CandyCane : Food
+  {
+    [Constructible]
+    public CandyCane()
+      : this(0x2bdd + Utility.Random(4))
+    {
+    }
+
+    public CandyCane(int itemID) : base(itemID, 1)
+    {
+      Stackable = false;
+      LootType = LootType.Blessed;
+    }
+
+    public CandyCane(Serial serial)
+      : base(serial)
+    {
+    }
+
+    private static Dictionary<Mobile, CandyCaneTimer> m_ToothAches = new Dictionary<Mobile, CandyCaneTimer>();
+
+    private static CandyCaneTimer EnsureTimer(Mobile from)
+    {
+      if (!m_ToothAches.TryGetValue(from, out CandyCaneTimer timer))
+        m_ToothAches[from] = timer = new CandyCaneTimer(from);
+
+      return timer;
+    }
+
+    public static int GetToothAche(Mobile from)
+    {
+      return m_ToothAches.TryGetValue(from, out CandyCaneTimer timer) ? timer.Eaten : 0;
+    }
+
+    public static void SetToothAche(Mobile from, int value)
+    {
+      EnsureTimer(from).Eaten = value;
+    }
+
+    public override bool CheckHunger(Mobile from)
+    {
+      EnsureTimer(from).Eaten += 32;
+
+      from.SendLocalizedMessage(1077387); // You feel as if you could eat as much as you wanted!
+      return true;
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+
+    public class CandyCaneTimer : Timer
+    {
+      public CandyCaneTimer(Mobile eater)
+        : base(TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(30))
+      {
+        Eater = eater;
+        Priority = TimerPriority.FiveSeconds;
+        Start();
+      }
+
+      public Mobile Eater{ get; }
+
+      public int Eaten{ get; set; }
+
+      protected override void OnTick()
+      {
+        --Eaten;
+
+        if (Eater?.Deleted != false || Eaten <= 0)
+        {
+          Stop();
+          m_ToothAches.Remove(Eater);
+        }
+        else if (Eater.Map != Map.Internal && Eater.Alive)
+        {
+          if (Eaten > 60)
+          {
+            Eater.Say(1077388 + Utility.Random(5));
+
+            /* ARRGH! My tooth hurts sooo much!
+             * You just can't find a good Britannian dentist these days...
+             * My teeth!
+             * MAKE IT STOP!
+             * AAAH! It feels like someone kicked me in the teeth!
+             */
+
+            if (Utility.RandomBool() && Eater.Body.IsHuman && !Eater.Mounted)
+              Eater.Animate(32, 5, 1, true, false, 0);
+          }
+          else if (Eaten == 60)
+          {
+            Eater.SendLocalizedMessage(1077393); // The extreme pain in your teeth subsides.
+          }
+        }
+      }
+    }
+  }
+
+  public class GingerBreadCookie : Food
+  {
+    private readonly int[] m_Messages =
+    {
+      0,
+      1077396, // Noooo!
+      1077397, // Please don't eat me... *whimper*
+      1077405, // Not the face!
+      1077406, // Ahhhhhh! My foot<6F>s gone!
+      1077407, // Please. No! I have gingerkids!
+      1077408, // No, no! I<>m really made of poison. Really.
+      1077409 // Run, run as fast as you can! You can't catch me! I'm the gingerbread man!
+    };
+
+    [Constructible]
+    public GingerBreadCookie()
+      : base(Utility.RandomBool() ? 0x2be1 : 0x2be2, 1)
+    {
+      Stackable = false;
+      LootType = LootType.Blessed;
+    }
+
+    public GingerBreadCookie(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override bool Eat(Mobile from)
+    {
+      int message = m_Messages[Utility.Random(m_Messages.Length)];
+
+      if (message != 0)
+      {
+        SendLocalizedMessageTo(from, message);
+        return false;
+      }
+
+      return base.Eat(from);
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/HolidayGiftBoxes.cs

@@ -0,0 +1,220 @@
+namespace Server.Items
+{
+  public class GiftBoxHues
+  {
+    /* there's possibly a couple more, but this is what we could verify on OSI */
+
+    private static readonly int[] m_NormalHues =
+    {
+      0x672,
+      0x454,
+      0x507,
+      0x4ac,
+      0x504,
+      0x84b,
+      0x495,
+      0x97c,
+      0x493,
+      0x4a8,
+      0x494,
+      0x4aa,
+      0xb8b,
+      0x84f,
+      0x491,
+      0x851,
+      0x503,
+      0xb8c,
+      0x4ab,
+      0x84B
+    };
+
+    private static readonly int[] m_NeonHues =
+    {
+      0x438,
+      0x424,
+      0x433,
+      0x445,
+      0x42b,
+      0x448
+    };
+
+    public static int RandomGiftBoxHue => m_NormalHues[Utility.Random(m_NormalHues.Length)];
+    public static int RandomNeonBoxHue => m_NeonHues[Utility.Random(m_NeonHues.Length)];
+  }
+
+  [Flippable(0x46A5, 0x46A6)]
+  public class GiftBoxRectangle : BaseContainer
+  {
+    [Constructible]
+    public GiftBoxRectangle()
+      : base(Utility.RandomBool() ? 0x46A5 : 0x46A6)
+    {
+      Hue = GiftBoxHues.RandomGiftBoxHue;
+    }
+
+    public GiftBoxRectangle(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override int DefaultGumpID => 0x11E;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class GiftBoxCube : BaseContainer
+  {
+    [Constructible]
+    public GiftBoxCube()
+      : base(0x46A2)
+    {
+      Hue = GiftBoxHues.RandomGiftBoxHue;
+    }
+
+    public GiftBoxCube(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override int DefaultGumpID => 0x11B;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class GiftBoxCylinder : BaseContainer
+  {
+    [Constructible]
+    public GiftBoxCylinder()
+      : base(0x46A3)
+    {
+      Hue = GiftBoxHues.RandomGiftBoxHue;
+    }
+
+    public GiftBoxCylinder(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override int DefaultGumpID => 0x11C;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class GiftBoxOctogon : BaseContainer
+  {
+    [Constructible]
+    public GiftBoxOctogon()
+      : base(0x46A4)
+    {
+      Hue = GiftBoxHues.RandomGiftBoxHue;
+    }
+
+    public GiftBoxOctogon(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override int DefaultGumpID => 0x11D;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class GiftBoxAngel : BaseContainer
+  {
+    [Constructible]
+    public GiftBoxAngel()
+      : base(0x46A7)
+    {
+      Hue = GiftBoxHues.RandomGiftBoxHue;
+    }
+
+    public GiftBoxAngel(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override int DefaultGumpID => 0x11F;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+
+  [Flippable(0x232A, 0x232B)]
+  public class GiftBoxNeon : BaseContainer
+  {
+    [Constructible]
+    public GiftBoxNeon()
+      : base(Utility.RandomBool() ? 0x232A : 0x232B)
+    {
+      Hue = GiftBoxHues.RandomNeonBoxHue;
+    }
+
+    public GiftBoxNeon(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/HolidayPottedPlant.cs

@@ -0,0 +1,153 @@
+using Server.Gumps;
+using Server.Network;
+
+namespace Server.Items
+{
+  public class HolidayPottedPlant : Item
+  {
+    [Constructible]
+    public HolidayPottedPlant()
+      : this(Utility.RandomMinMax(0x11C8, 0x11CC))
+    {
+    }
+
+    [Constructible]
+    public HolidayPottedPlant(int itemID)
+      : base(itemID)
+    {
+    }
+
+    public HolidayPottedPlant(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override bool ForceShowProperties => ObjectPropertyList.Enabled;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class PottedPlantDeed : Item
+  {
+    [Constructible]
+    public PottedPlantDeed()
+      : base(0x14F0)
+    {
+      LootType = LootType.Blessed;
+    }
+
+    public PottedPlantDeed(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override int LabelNumber => 1041114; // A deed for a potted plant.
+    public override double DefaultWeight => 1.0;
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      if (IsChildOf(from.Backpack))
+      {
+        from.CloseGump<InternalGump>();
+        from.SendGump(new InternalGump(this));
+      }
+      else
+      {
+        from.SendLocalizedMessage(1042038); // You must have the object in your backpack to use it.
+      }
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+
+    private class InternalGump : Gump
+    {
+      private PottedPlantDeed m_Deed;
+
+      public InternalGump(PottedPlantDeed deed) : base(100, 200)
+      {
+        m_Deed = deed;
+
+        Closable = true;
+        Disposable = true;
+        Draggable = true;
+        Resizable = false;
+
+        AddPage(0);
+        AddBackground(0, 0, 360, 195, 0xA28);
+
+        AddPage(1);
+        AddLabel(45, 15, 0, "Choose a Potted Plant:");
+
+        AddItem(45, 75, 0x11C8);
+        AddButton(55, 50, 0x845, 0x846, 1);
+
+        AddItem(100, 75, 0x11C9);
+        AddButton(115, 50, 0x845, 0x846, 2);
+
+        AddItem(160, 75, 0x11CA);
+        AddButton(175, 50, 0x845, 0x846, 3);
+
+        AddItem(225, 75, 0x11CB);
+        AddButton(235, 50, 0x845, 0x846, 4);
+
+        AddItem(280, 75, 0x11CC);
+        AddButton(295, 50, 0x845, 0x846, 5);
+      }
+
+      public override void OnResponse(NetState sender, RelayInfo info)
+      {
+        if (m_Deed?.Deleted != false)
+          return;
+
+        Mobile from = sender.Mobile;
+
+        if (!m_Deed.IsChildOf(from.Backpack))
+        {
+          from.SendLocalizedMessage(1042038); // You must have the object in your backpack to use it
+          return;
+        }
+
+        int index = info.ButtonID - 1;
+
+        if (index >= 0 && index <= 4)
+        {
+          HolidayPottedPlant plant = new HolidayPottedPlant(0x11C8 + index);
+
+          if (!from.PlaceInBackpack(plant))
+          {
+            plant.Delete();
+            from.SendLocalizedMessage(1078837); // Your backpack is full! Please make room and try again.
+          }
+          else
+          {
+            m_Deed.Delete();
+          }
+        }
+      }
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/HolidayTimepiece.cs

@@ -0,0 +1,36 @@
+namespace Server.Items
+{
+  public class HolidayTimepiece : Clock
+  {
+    [Constructible]
+    public HolidayTimepiece()
+      : base(0x1086)
+    {
+      Weight = DefaultWeight;
+      LootType = LootType.Blessed;
+      Layer = Layer.Bracelet;
+    }
+
+    public HolidayTimepiece(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override int LabelNumber => 1041113; // a holiday timepiece
+    public override double DefaultWeight => 1.0;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/Icecicles.cs

@@ -0,0 +1,170 @@
+namespace Server.Items
+{
+  public class IcicleLargeSouth : Item
+  {
+    [Constructible]
+    public IcicleLargeSouth()
+      : base(0x4572)
+    {
+    }
+
+    public IcicleLargeSouth(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class IcicleMedSouth : Item
+  {
+    [Constructible]
+    public IcicleMedSouth()
+      : base(0x4573)
+    {
+    }
+
+    public IcicleMedSouth(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class IcicleSmallSouth : Item
+  {
+    [Constructible]
+    public IcicleSmallSouth()
+      : base(0x4574)
+    {
+    }
+
+    public IcicleSmallSouth(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class IcicleLargeEast : Item
+  {
+    [Constructible]
+    public IcicleLargeEast()
+      : base(0x4575)
+    {
+    }
+
+    public IcicleLargeEast(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class IcicleMedEast : Item
+  {
+    [Constructible]
+    public IcicleMedEast()
+      : base(0x4576)
+    {
+    }
+
+    public IcicleMedEast(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class IcicleSmallEast : Item
+  {
+    [Constructible]
+    public IcicleSmallEast()
+      : base(0x4577)
+    {
+    }
+
+    public IcicleSmallEast(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/IcyPatch.cs

@@ -0,0 +1,112 @@
+using System;
+using Server.Mobiles;
+using Server.Spells;
+
+namespace Server.Items
+{
+  public class IcyPatch : Item
+  {
+    /* On OSI, the iceypatch with itemid 0x122a is "rarer", so we will give it 1:10 chance of creating it that way */
+
+    [Constructible]
+    public IcyPatch()
+      : this(Utility.Random(10) == 0 ? 0x122A : 0x122F)
+    {
+    }
+
+    public IcyPatch(int itemid)
+      : base(itemid)
+    {
+      Hue = 0x481;
+    }
+
+    public IcyPatch(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override int LabelNumber => 1095159; //An Icy Patch
+    public override double DefaultWeight => 5.0;
+
+    public override bool OnMoveOver(Mobile m)
+    {
+      if (m is PlayerMobile && m.Alive && m.AccessLevel == AccessLevel.Player)
+        switch (Utility.Random(3))
+        {
+          case 0:
+            RunSequence(m, 1095160, false);
+            break; //You steadily walk over the slippery surface.
+          case 1:
+            RunSequence(m, 1095161, true);
+            break; //You skillfully manage to maintain your balance.
+          default:
+            RunSequence(m, 1095162, true);
+            break; //You lose your footing and ungracefully splatter on the ground.
+        }
+      return base.OnMoveOver(m);
+    }
+
+    public virtual void RunSequence(Mobile m, int message, bool freeze)
+    {
+      if (freeze)
+      {
+        m.Frozen = true;
+        Timer.DelayCall(TimeSpan.FromSeconds(message == 1095162 ? 2.0 : 1.25), EndFall_Callback, m);
+      }
+
+      m.SendLocalizedMessage(message);
+      
+      int action = 0;
+      int sound = 0;
+
+      if (message == 1095162)
+      {
+        if (m.Mounted)
+          m.Mount.Rider = null;
+
+        Point3D p = new Point3D(Location);
+
+        if (SpellHelper.FindValidSpawnLocation(Map, ref p, true))
+          Timer.DelayCall(TimeSpan.FromSeconds(0), () => m.MoveToWorld(p, m.Map));
+
+        action = 21 + Utility.Random(2);
+        sound = m.Female ? 0x317 : 0x426;
+      }
+      else if (message == 1095161)
+      {
+        action = 17;
+        sound = m.Female ? 0x319 : 0x429;
+      }
+
+      if (action > 0)
+        Timer.DelayCall(TimeSpan.FromSeconds(0.4), from => BeginFall_Callback(from, action, sound), m);
+    }
+
+    private static void BeginFall_Callback(Mobile m, int action, int sound)
+    {
+      if (!m.Mounted)
+        m.Animate(action, 1, 1, false, true, 0);
+      
+      m.PlaySound(sound);
+    }
+
+    private static void EndFall_Callback(Mobile m)
+    {
+      m.Frozen = false;
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/PKHolidayStuff.cs

@@ -0,0 +1,89 @@
+namespace Server.Items
+{
+  public class Coal : Item
+  {
+    [Constructible]
+    public Coal() : base(0x19b9)
+    {
+      Stackable = false;
+      LootType = LootType.Blessed;
+      Hue = 0x965;
+    }
+
+    public Coal(Serial serial) : base(serial)
+    {
+    }
+
+    public override string DefaultName => "Coal";
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class BadCard : Item
+  {
+    [Constructible]
+    public BadCard() : base(0x14ef)
+    {
+      int[] m_CardHues = { 0x45, 0x27, 0x3d0 };
+      Hue = m_CardHues[Utility.Random(m_CardHues.Length)];
+      Stackable = false;
+      LootType = LootType.Blessed;
+      Movable = true;
+    }
+
+    public BadCard(Serial serial) : base(serial)
+    {
+    }
+
+    public override int LabelNumber // Maybe next year youll get a better...
+      => 1041428;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class Spam : Food
+  {
+    [Constructible]
+    public Spam() : base(0x1044, 1)
+    {
+      Stackable = false;
+      LootType = LootType.Blessed;
+    }
+
+    public Spam(Serial serial) : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/Poinsettias.cs

@@ -0,0 +1,58 @@
+namespace Server.Items
+{
+  public class RedPoinsettia : Item
+  {
+    [Constructible]
+    public RedPoinsettia() : base(0x2330)
+    {
+      Weight = 1.0;
+      LootType = LootType.Blessed;
+    }
+
+    public RedPoinsettia(Serial serial) : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class WhitePoinsettia : Item
+  {
+    [Constructible]
+    public WhitePoinsettia() : base(0x2331)
+    {
+      Weight = 1.0;
+      LootType = LootType.Blessed;
+    }
+
+    public WhitePoinsettia(Serial serial) : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/SnowGlobes.cs

@@ -0,0 +1,320 @@
+namespace Server.Items
+{
+  public class SnowGlobe : Item
+  {
+    public SnowGlobe()
+      : base(0xE2F)
+    {
+      LootType = LootType.Blessed;
+      Light = LightType.Circle150;
+    }
+
+    public SnowGlobe(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override double DefaultWeight => 1.0;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+
+  public enum SnowGlobeTypeOne
+  {
+    Britain,
+    Moonglow,
+    Minoc,
+    Magincia,
+    BuccaneersDen,
+    Trinsic,
+    Yew,
+    SkaraBrae,
+    Jhelom,
+    Nujelm,
+    Papua,
+    Delucia,
+    Cove,
+    Ocllo,
+    SerpentsHold,
+    EmpathAbbey,
+    TheLycaeum,
+    Vesper,
+    Wind
+  }
+
+  public class SnowGlobeOne : SnowGlobe
+  {
+    private SnowGlobeTypeOne m_Type;
+
+    [Constructible]
+    public SnowGlobeOne()
+      : this((SnowGlobeTypeOne)Utility.Random(19))
+    {
+    }
+
+    [Constructible]
+    public SnowGlobeOne(SnowGlobeTypeOne type)
+    {
+      m_Type = type;
+    }
+
+    public SnowGlobeOne(Serial serial)
+      : base(serial)
+    {
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public SnowGlobeTypeOne Place
+    {
+      get => m_Type;
+      set
+      {
+        m_Type = value;
+        InvalidateProperties();
+      }
+    }
+
+    public override int LabelNumber => 1041454 + (int)m_Type;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+      writer.WriteEncodedInt((int)m_Type);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 0:
+        {
+          m_Type = (SnowGlobeTypeOne)reader.ReadEncodedInt();
+          break;
+        }
+      }
+    }
+  }
+
+  public enum SnowGlobeTypeTwo
+  {
+    AncientCitadel,
+    BlackthornesCastle,
+    CityofMontor,
+    CityofMistas,
+    ExodusLair,
+    LakeofFire,
+    Lakeshire,
+    PassofKarnaugh,
+    TheEtherealFortress,
+    TwinOaksTavern,
+    ChaosShrine,
+    ShrineofHumility,
+    ShrineofSacrifice,
+    ShrineofCompassion,
+    ShrineofHonor,
+    ShrineofHonesty,
+    ShrineofSpirituality,
+    ShrineofJustice,
+    ShrineofValor
+  }
+
+  public class SnowGlobeTwo : SnowGlobe
+  {
+    /* Oddly, these are not localized. */
+    private static readonly string[] m_PlaceNames =
+    {
+      /* AncientCitadel */ "Ancient Citadel",
+      /* BlackthornesCastle */ "Blackthorne's Castle",
+      /* CityofMontor */ "City of Montor",
+      /* CityofMistas */ "City of Mistas",
+      /* ExodusLair */ "Exodus' Lair",
+      /* LakeofFire */ "Lake of Fire",
+      /* Lakeshire */ "Lakeshire",
+      /* PassofKarnaugh */ "Pass of Karnaugh",
+      /* TheEtherealFortress */ "The Etheral Fortress",
+      /* TwinOaksTavern */ "Twin Oaks Tavern",
+      /* ChaosShrine */ "Chaos Shrine",
+      /* ShrineofHumility */ "Shrine of Humility",
+      /* ShrineofSacrifice */ "Shrine of Sacrifice",
+      /* ShrineofCompassion */ "Shrine of Compassion",
+      /* ShrineofHonor */ "Shrine of Honor",
+      /* ShrineofHonesty */ "Shrine of Honesty",
+      /* ShrineofSpirituality */ "Shrine of Spirituality",
+      /* ShrineofJustice */ "Shrine of Justice",
+      /* ShrineofValor */ "Shrine of Valor"
+    };
+
+    private SnowGlobeTypeTwo m_Type;
+
+    [Constructible]
+    public SnowGlobeTwo()
+      : this((SnowGlobeTypeTwo)Utility.Random(19))
+    {
+    }
+
+    [Constructible]
+    public SnowGlobeTwo(SnowGlobeTypeTwo type)
+    {
+      m_Type = type;
+    }
+
+    public SnowGlobeTwo(Serial serial)
+      : base(serial)
+    {
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public SnowGlobeTypeTwo Place
+    {
+      get => m_Type;
+      set
+      {
+        m_Type = value;
+        InvalidateProperties();
+      }
+    }
+
+    public override string DefaultName
+    {
+      get
+      {
+        int idx = (int)m_Type;
+
+        if (idx < 0 || idx >= m_PlaceNames.Length)
+          return "a snowy scene";
+
+        return $"a snowy scene of {m_PlaceNames[idx]}";
+      }
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+      writer.WriteEncodedInt((int)m_Type);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 0:
+        {
+          m_Type = (SnowGlobeTypeTwo)reader.ReadEncodedInt();
+          break;
+        }
+      }
+    }
+  }
+
+  public enum SnowGlobeTypeThree
+  {
+    Luna,
+    Umbra,
+    Zento,
+    Heartwood,
+    Covetous,
+    Deceit,
+    Destard,
+    Hythloth,
+    Khaldun,
+    Shame,
+    Wrong,
+    Doom,
+    TheCitadel,
+    ThePalaceofParoxysmus,
+    TheBlightedGrove,
+    ThePrismofLight
+  }
+
+  public class SnowGlobeThree : SnowGlobe
+  {
+    private SnowGlobeTypeThree m_Type;
+
+    [Constructible]
+    public SnowGlobeThree()
+      : this((SnowGlobeTypeThree)Utility.Random(16))
+    {
+    }
+
+    [Constructible]
+    public SnowGlobeThree(SnowGlobeTypeThree type)
+    {
+      m_Type = type;
+    }
+
+    public SnowGlobeThree(Serial serial)
+      : base(serial)
+    {
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public SnowGlobeTypeThree Place
+    {
+      get => m_Type;
+      set
+      {
+        m_Type = value;
+        InvalidateProperties();
+      }
+    }
+
+    public override int LabelNumber
+    {
+      get
+      {
+        if (m_Type >= SnowGlobeTypeThree.Covetous)
+          return 1075440 + ((int)m_Type - 4);
+
+        return 1075294 + (int)m_Type;
+      }
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+      writer.WriteEncodedInt((int)m_Type);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 0:
+        {
+          m_Type = (SnowGlobeTypeThree)reader.ReadEncodedInt();
+          break;
+        }
+      }
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/SnowPiles.cs

@@ -0,0 +1,42 @@
+namespace Server.Items
+{
+  public class SnowPileDeco : Item
+  {
+    private static readonly int[] m_Types = { 0x8E2, 0x8E0, 0x8E6, 0x8E5, 0x8E3 };
+
+    [Constructible]
+    public SnowPileDeco()
+      : this(m_Types[Utility.Random(m_Types.Length)])
+    {
+    }
+
+    [Constructible]
+    public SnowPileDeco(int itemid)
+      : base(itemid)
+    {
+      Hue = 0x481;
+    }
+
+    public SnowPileDeco(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override string DefaultName => "Snow Pile";
+    public override double DefaultWeight => 2.0;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/SnowStatue.cs

@@ -0,0 +1,251 @@
+using Server.Gumps;
+using Server.Network;
+
+namespace Server.Items
+{
+  [Flippable(0x456E, 0x456F)]
+  public class SnowStatuePegasus : Item
+  {
+    [Constructible]
+    public SnowStatuePegasus()
+      : base(0x456E)
+    {
+    }
+
+    public SnowStatuePegasus(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override bool ForceShowProperties => ObjectPropertyList.Enabled;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  [Flippable(0x4578, 0x4579)]
+  public class SnowStatueSeahorse : Item
+  {
+    [Constructible]
+    public SnowStatueSeahorse()
+      : base(0x4578)
+    {
+    }
+
+    public SnowStatueSeahorse(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override bool ForceShowProperties => ObjectPropertyList.Enabled;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  [Flippable(0x457A, 0x457B)]
+  public class SnowStatueMermaid : Item
+  {
+    [Constructible]
+    public SnowStatueMermaid()
+      : base(0x457A)
+    {
+    }
+
+    public SnowStatueMermaid(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override bool ForceShowProperties => ObjectPropertyList.Enabled;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  [Flippable(0x457C, 0x457D)]
+  public class SnowStatueGriffon : Item
+  {
+    [Constructible]
+    public SnowStatueGriffon()
+      : base(0x457C)
+    {
+    }
+
+    public SnowStatueGriffon(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override bool ForceShowProperties => ObjectPropertyList.Enabled;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+  }
+
+  public class SnowStatueDeed : Item
+  {
+    [Constructible]
+    public SnowStatueDeed()
+      : base(0x14F0)
+    {
+      LootType = LootType.Blessed;
+    }
+
+    public SnowStatueDeed(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override int LabelNumber => 1114296; // snow statue deed
+    public override double DefaultWeight => 1.0;
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      if (IsChildOf(from.Backpack))
+      {
+        from.CloseGump<InternalGump>();
+        from.SendGump(new InternalGump(this));
+      }
+      else
+      {
+        from.SendLocalizedMessage(1042038); // You must have the object in your backpack to use it.
+      }
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+
+    private class InternalGump : Gump
+    {
+      private SnowStatueDeed m_Deed;
+
+      public InternalGump(SnowStatueDeed deed) : base(100, 200)
+      {
+        m_Deed = deed;
+
+        Closable = true;
+        Disposable = true;
+        Draggable = true;
+        Resizable = false;
+
+        AddPage(0);
+        AddBackground(0, 0, 360, 225, 0xA28);
+
+        AddPage(1);
+        AddLabel(45, 15, 0, "Select One:");
+
+        AddItem(35, 75, 0x456E);
+        AddButton(65, 50, 0x845, 0x846, 1);
+
+        AddItem(120, 75, 0x4578);
+        AddButton(135, 50, 0x845, 0x846, 2);
+
+        AddItem(190, 75, 0x457A);
+        AddButton(205, 50, 0x845, 0x846, 3);
+
+        AddItem(250, 75, 0x457C);
+        AddButton(275, 50, 0x845, 0x846, 4);
+      }
+
+      public override void OnResponse(NetState sender, RelayInfo info)
+      {
+        if (m_Deed?.Deleted != false)
+          return;
+
+        Mobile from = sender.Mobile;
+
+        if (!m_Deed.IsChildOf(from.Backpack))
+        {
+          from.SendLocalizedMessage(1042038); // You must have the object in your backpack to use it
+          return;
+        }
+
+        Item statue;
+
+        switch (info.ButtonID)
+        {
+          default:
+            return;
+          case 1:
+            statue = new SnowStatuePegasus();
+            break;
+          case 2:
+            statue = new SnowStatueSeahorse();
+            break;
+          case 3:
+            statue = new SnowStatueMermaid();
+            break;
+          case 4:
+            statue = new SnowStatueGriffon();
+            break;
+        }
+
+        if (!from.PlaceInBackpack(statue))
+        {
+          statue.Delete();
+          from.SendLocalizedMessage(1078837); // Your backpack is full! Please make room and try again.
+        }
+        else
+        {
+          m_Deed.Delete();
+        }
+      }
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/Snowflakes.cs

@@ -0,0 +1,58 @@
+namespace Server.Items
+{
+  public class BlueSnowflake : Item
+  {
+    [Constructible]
+    public BlueSnowflake() : base(0x232E)
+    {
+      Weight = 1.0;
+      LootType = LootType.Blessed;
+    }
+
+    public BlueSnowflake(Serial serial) : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+
+  public class WhiteSnowflake : Item
+  {
+    [Constructible]
+    public WhiteSnowflake() : base(0x232F)
+    {
+      Weight = 1.0;
+      LootType = LootType.Blessed;
+    }
+
+    public WhiteSnowflake(Serial serial) : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/Snowman.cs

@@ -0,0 +1,159 @@
+namespace Server.Items
+{
+  [Flippable(0x2328, 0x2329)]
+  public class Snowman : Item, IDyable
+  {
+    private string m_Title;
+
+    [Constructible]
+    public Snowman() : this(Utility.RandomDyedHue())
+    {
+    }
+
+    [Constructible]
+    public Snowman(int hue) : this(hue, GetRandomTitle())
+    {
+    }
+
+    [Constructible]
+    public Snowman(string title) : this(Utility.RandomDyedHue(), title)
+    {
+    }
+
+    [Constructible]
+    public Snowman(int hue, string title) : base(Utility.Random(0x2328, 2))
+    {
+      Weight = 10.0;
+      Hue = hue;
+      LootType = LootType.Blessed;
+
+      m_Title = title;
+    }
+
+    public Snowman(Serial serial) : base(serial)
+    {
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public string Title
+    {
+      get => m_Title;
+      set
+      {
+        m_Title = value;
+        InvalidateProperties();
+      }
+    }
+
+    public bool Dye(Mobile from, DyeTub sender)
+    {
+      if (Deleted)
+        return false;
+
+      Hue = sender.DyedHue;
+
+      return true;
+    }
+
+    public static string GetRandomTitle()
+    {
+      // All hail OSI staff
+      string[] titles =
+      {
+        /*  1 */ "Backflash",
+        /*  2 */ "Carbon",
+        /*  3 */ "Colbalistic",
+        /*  4 */ "Comforl",
+        /*  5 */ "Coppacchia",
+        /*  6 */ "Cyrus",
+        /*  7 */ "DannyB",
+        /*  8 */ "DJSoul",
+        /*  9 */ "DraconisRex",
+        /* 10 */ "Earia",
+        /* 11 */ "Foster",
+        /* 12 */ "Gonzo",
+        /* 13 */ "Haan",
+        /* 14 */ "Halona",
+        /* 15 */ "Hugo",
+        /* 16 */ "Hyacinth",
+        /* 17 */ "Imirian",
+        /* 18 */ "Jinsol",
+        /* 19 */ "Liciatia",
+        /* 20 */ "Loewen",
+        /* 21 */ "Loke",
+        /* 22 */ "Magnus",
+        /* 23 */ "Maleki",
+        /* 24 */ "Morpheus",
+        /* 25 */ "Obberron",
+        /* 26 */ "Odee",
+        /* 27 */ "Orbeus",
+        /* 28 */ "Pax",
+        /* 29 */ "Phields",
+        /* 30 */ "Pigpen",
+        /* 31 */ "Platinum",
+        /* 32 */ "Polpol",
+        /* 33 */ "Prume",
+        /* 34 */ "Quinnly",
+        /* 35 */ "Ragnarok",
+        /* 36 */ "Rend",
+        /* 37 */ "Roland",
+        /* 38 */ "RyanM",
+        /* 39 */ "Screach",
+        /* 40 */ "Seraph",
+        /* 41 */ "Silvani",
+        /* 42 */ "Sherbear",
+        /* 43 */ "SkyWalker",
+        /* 44 */ "Snark",
+        /* 45 */ "Sowl",
+        /* 46 */ "Spada",
+        /* 47 */ "Starblade",
+        /* 48 */ "Tenacious",
+        /* 49 */ "Tnez",
+        /* 50 */ "Wasia",
+        /* 51 */ "Zilo",
+        /* 52 */ "Zippy",
+        /* 53 */ "Zoer"
+      };
+
+      if (titles.Length > 0)
+        return titles[Utility.Random(titles.Length)];
+
+      return null;
+    }
+
+    public override void GetProperties(ObjectPropertyList list)
+    {
+      base.GetProperties(list);
+
+      if (m_Title != null)
+        list.Add(1062841, m_Title); // ~1_NAME~ the Snowman
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(1); // version
+
+      writer.Write(m_Title);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 1:
+        {
+          m_Title = reader.ReadString();
+          break;
+        }
+      }
+
+      Utility.Intern(ref m_Title);
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/Stockings.cs

@@ -0,0 +1,60 @@
+namespace Server.Items
+{
+  [Furniture]
+  [Flippable(0x2bd9, 0x2bda)]
+  public class GreenStocking : BaseContainer
+  {
+    [Constructible]
+    public GreenStocking() : base(Utility.Random(0x2BD9, 2))
+    {
+    }
+
+    public GreenStocking(Serial serial) : base(serial)
+    {
+    }
+
+    public override int DefaultGumpID => 0x103;
+    public override int DefaultDropSound => 0x42;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+
+  [Furniture]
+  [Flippable(0x2bdb, 0x2bdc)]
+  public class RedStocking : BaseContainer
+  {
+    [Constructible]
+    public RedStocking() : base(Utility.Random(0x2BDB, 2))
+    {
+    }
+
+    public RedStocking(Serial serial) : base(serial)
+    {
+    }
+
+    public override int DefaultGumpID => 0x103;
+    public override int DefaultDropSound => 0x42;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/WinterGiftPackage2003.cs

@@ -0,0 +1,33 @@
+namespace Server.Items
+{
+  [Flippable(0x232A, 0x232B)]
+  public class WinterGiftPackage2003 : GiftBox
+  {
+    [Constructible]
+    public WinterGiftPackage2003()
+    {
+      DropItem(new Snowman());
+      DropItem(new WreathDeed());
+      DropItem(new BlueSnowflake());
+      DropItem(new RedPoinsettia());
+    }
+
+    public WinterGiftPackage2003(Serial serial) : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/Wreath.cs

@@ -0,0 +1,316 @@
+using System;
+using Server.Gumps;
+using Server.Multis;
+using Server.Network;
+using Server.Targeting;
+
+namespace Server.Items
+{
+  public class WreathAddon : Item, IDyable, IAddon
+  {
+    [Constructible]
+    public WreathAddon() : this(Utility.RandomDyedHue())
+    {
+    }
+
+    [Constructible]
+    public WreathAddon(int hue) : base(0x232C)
+    {
+      Hue = hue;
+      Movable = false;
+    }
+
+    public WreathAddon(Serial serial) : base(serial)
+    {
+    }
+
+    public bool CouldFit(IPoint3D p, Map map)
+    {
+      if (!map.CanFit(p.X, p.Y, p.Z, ItemData.Height))
+        return false;
+
+      if (ItemID == 0x232C)
+        return BaseAddon.IsWall(p.X, p.Y - 1, p.Z, map); // North wall
+      return BaseAddon.IsWall(p.X - 1, p.Y, p.Z, map); // West wall
+    }
+
+    public Item Deed => new WreathDeed(Hue);
+
+    public virtual bool Dye(Mobile from, DyeTub sender)
+    {
+      if (Deleted)
+        return false;
+
+      BaseHouse house = BaseHouse.FindHouseAt(this);
+
+      if (house?.IsCoOwner(from) == true)
+      {
+        if (from.InRange(GetWorldLocation(), 1))
+        {
+          Hue = sender.DyedHue;
+          return true;
+        }
+
+        from.SendLocalizedMessage(500295); // You are too far away to do that.
+        return false;
+      }
+
+      return false;
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      Timer.DelayCall(TimeSpan.Zero, FixMovingCrate);
+    }
+
+    private void FixMovingCrate()
+    {
+      if (Deleted)
+        return;
+
+      if (Movable || IsLockedDown)
+      {
+        Item deed = Deed;
+
+        if (Parent is Item item)
+        {
+          item.AddItem(deed);
+          deed.Location = Location;
+        }
+        else
+        {
+          deed.MoveToWorld(Location, Map);
+        }
+
+        Delete();
+      }
+    }
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      BaseHouse house = BaseHouse.FindHouseAt(this);
+
+      if (house?.IsCoOwner(from) == true)
+      {
+        if (from.InRange(GetWorldLocation(), 3))
+        {
+          from.CloseGump<WreathAddonGump>();
+          from.SendGump(new WreathAddonGump(from, this));
+        }
+        else
+        {
+          from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1019045); // I can't reach that.
+        }
+      }
+    }
+
+    private class WreathAddonGump : Gump
+    {
+      private WreathAddon m_Addon;
+      private Mobile m_From;
+
+      public WreathAddonGump(Mobile from, WreathAddon addon) : base(150, 50)
+      {
+        m_From = from;
+        m_Addon = addon;
+
+        AddPage(0);
+
+        AddBackground(0, 0, 220, 170, 0x13BE);
+        AddBackground(10, 10, 200, 150, 0xBB8);
+        AddHtmlLocalized(20, 30, 180, 60, 1062839); // Do you wish to re-deed this decoration?
+        AddHtmlLocalized(55, 100, 160, 25, 1011011); // CONTINUE
+        AddButton(20, 100, 0xFA5, 0xFA7, 1);
+        AddHtmlLocalized(55, 125, 160, 25, 1011012); // CANCEL
+        AddButton(20, 125, 0xFA5, 0xFA7, 0);
+      }
+
+      public override void OnResponse(NetState sender, RelayInfo info)
+      {
+        if (m_Addon.Deleted)
+          return;
+
+        if (info.ButtonID == 1)
+        {
+          if (m_From.InRange(m_Addon.GetWorldLocation(), 3))
+          {
+            m_From.AddToBackpack(m_Addon.Deed);
+            m_Addon.Delete();
+          }
+          else
+          {
+            m_From.SendLocalizedMessage(500295); // You are too far away to do that.
+          }
+        }
+      }
+    }
+  }
+
+  [Flippable(0x14F0, 0x14EF)]
+  public class WreathDeed : Item
+  {
+    [Constructible]
+    public WreathDeed() : this(Utility.RandomDyedHue())
+    {
+    }
+
+    [Constructible]
+    public WreathDeed(int hue) : base(0x14F0)
+    {
+      Weight = 1.0;
+      Hue = hue;
+      LootType = LootType.Blessed;
+    }
+
+    public WreathDeed(Serial serial) : base(serial)
+    {
+    }
+
+    public override int LabelNumber => 1062837; // holiday wreath deed
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      if (IsChildOf(from.Backpack))
+      {
+        BaseHouse house = BaseHouse.FindHouseAt(from);
+
+        if (house?.IsCoOwner(from) == true)
+        {
+          from.SendLocalizedMessage(1062838); // Where would you like to place this decoration?
+          from.BeginTarget(-1, true, TargetFlags.None, Placement_OnTarget);
+        }
+        else
+        {
+          from.SendLocalizedMessage(502092); // You must be in your house to do this.
+        }
+      }
+      else
+      {
+        from.SendLocalizedMessage(1042001); // That must be in your pack for you to use it.
+      }
+    }
+
+    public void Placement_OnTarget(Mobile from, object targeted)
+    {
+      if (!(targeted is IPoint3D p))
+        return;
+
+      Point3D loc = new Point3D(p);
+
+      BaseHouse house = BaseHouse.FindHouseAt(loc, from.Map, 16);
+
+      if (house?.IsCoOwner(from) == true)
+      {
+        bool northWall = BaseAddon.IsWall(loc.X, loc.Y - 1, loc.Z, from.Map);
+        bool westWall = BaseAddon.IsWall(loc.X - 1, loc.Y, loc.Z, from.Map);
+
+        if (northWall && westWall)
+          from.SendGump(new WreathDeedGump(from, loc, this));
+        else
+          PlaceAddon(from, loc, northWall, westWall);
+      }
+      else
+      {
+        from.SendLocalizedMessage(1042036); // That location is not in your house.
+      }
+    }
+
+    private void PlaceAddon(Mobile from, Point3D loc, bool northWall, bool westWall)
+    {
+      if (Deleted)
+        return;
+
+      BaseHouse house = BaseHouse.FindHouseAt(loc, from.Map, 16);
+
+      if (house == null || !house.IsCoOwner(from))
+      {
+        from.SendLocalizedMessage(1042036); // That location is not in your house.
+        return;
+      }
+
+      int itemID = 0;
+
+      if (northWall)
+        itemID = 0x232C;
+      else if (westWall)
+        itemID = 0x232D;
+      else
+        from.SendLocalizedMessage(1062840); // The decoration must be placed next to a wall.
+
+      if (itemID > 0)
+      {
+        Item addon = new WreathAddon(Hue);
+
+        addon.ItemID = itemID;
+        addon.MoveToWorld(loc, from.Map);
+
+        house.Addons.Add(addon);
+        Delete();
+      }
+    }
+
+    private class WreathDeedGump : Gump
+    {
+      private WreathDeed m_Deed;
+      private Mobile m_From;
+      private Point3D m_Loc;
+
+      public WreathDeedGump(Mobile from, Point3D loc, WreathDeed deed) : base(150, 50)
+      {
+        m_From = from;
+        m_Loc = loc;
+        m_Deed = deed;
+
+        AddBackground(0, 0, 300, 150, 0xA28);
+
+        AddPage(0);
+
+        AddItem(90, 30, 0x232D);
+        AddItem(180, 30, 0x232C);
+        AddButton(50, 35, 0x868, 0x869, 1);
+        AddButton(145, 35, 0x868, 0x869, 2);
+      }
+
+      public override void OnResponse(NetState sender, RelayInfo info)
+      {
+        if (m_Deed.Deleted)
+          return;
+
+        switch (info.ButtonID)
+        {
+          case 1:
+            m_Deed.PlaceAddon(m_From, m_Loc, false, true);
+            break;
+          case 2:
+            m_Deed.PlaceAddon(m_From, m_Loc, true, false);
+            break;
+        }
+      }
+    }
+  }
+}

Projects/Scripts/Items/Special/Holiday/WristWatch.cs

@@ -0,0 +1,36 @@
+namespace Server.Items
+{
+  public class WristWatch : Clock
+  {
+    [Constructible]
+    public WristWatch()
+      : base(0x1086)
+    {
+      Weight = DefaultWeight;
+      LootType = LootType.Blessed;
+      Layer = Layer.Bracelet;
+    }
+
+    public WristWatch(Serial serial)
+      : base(serial)
+    {
+    }
+
+    public override int LabelNumber => 1041421; // a wrist watch
+    public override double DefaultWeight => 1.0;
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+  }
+}