ModernUO/Projects/Scripts/Items/Misc/KeyRing.cs

using System.Collections.Generic;
using System.Linq;
using Server.Targeting;

namespace Server.Items
{
  public class KeyRing : Item
  {
    public static readonly int MaxKeys = 20;

    [Constructible]
    public KeyRing() : base(0x1011)
    {
      Weight = 1.0; // They seem to have no weight on OSI ?!

      Keys = new List<Key>();
    }

    public KeyRing(Serial serial) : base(serial)
    {
    }

    public List<Key> Keys{ get; private set; }

    public override bool OnDragDrop(Mobile from, Item dropped)
    {
      if (!IsChildOf(from.Backpack))
      {
        from.SendLocalizedMessage(1060640); // The item must be in your backpack to use it.
        return false;
      }

      if (!(dropped is Key key) || key.KeyValue == 0)
      {
        from.SendLocalizedMessage(501689); // Only non-blank keys can be put on a keyring.
        return false;
      }

      if (Keys.Count >= MaxKeys)
      {
        from.SendLocalizedMessage(1008138); // This keyring is full.
        return false;
      }

      Add(key);
      from.SendLocalizedMessage(501691); // You put the key on the keyring.
      return true;
    }

    public override void OnDoubleClick(Mobile from)
    {
      if (!IsChildOf(from.Backpack))
      {
        from.SendLocalizedMessage(1060640); // The item must be in your backpack to use it.
        return;
      }

      from.SendLocalizedMessage(501680); // What do you want to unlock?
      from.Target = new InternalTarget(this);
    }

    public override void OnDelete()
    {
      base.OnDelete();

      foreach (Key key in Keys) key.Delete();

      Keys.Clear();
    }

    public void Add(Key key)
    {
      key.Internalize();
      Keys.Add(key);

      UpdateItemID();
    }

    public void Open(Mobile from)
    {
      if (!(Parent is Container cont))
        return;

      for (int i = Keys.Count - 1; i >= 0; i--)
      {
        Key key = Keys[i];

        if (!key.Deleted && !cont.TryDropItem(from, key, true))
          break;

        Keys.RemoveAt(i);
      }

      UpdateItemID();
    }

    public void RemoveKeys(uint keyValue)
    {
      for (int i = Keys.Count - 1; i >= 0; i--)
      {
        Key key = Keys[i];

        if (key.KeyValue == keyValue)
        {
          key.Delete();
          Keys.RemoveAt(i);
        }
      }

      UpdateItemID();
    }

    public bool ContainsKey(uint keyValue) => Keys.Any(key => key.KeyValue == keyValue);

    private void UpdateItemID()
    {
      if (Keys.Count < 1)
        ItemID = 0x1011;
      else if (Keys.Count < 3)
        ItemID = 0x1769;
      else if (Keys.Count < 5)
        ItemID = 0x176A;
      else
        ItemID = 0x176B;
    }

    public override void Serialize(GenericWriter writer)
    {
      base.Serialize(writer);

      writer.WriteEncodedInt(0); // version

      writer.WriteItemList(Keys);
    }

    public override void Deserialize(GenericReader reader)
    {
      base.Deserialize(reader);

      int version = reader.ReadEncodedInt();

      Keys = reader.ReadStrongItemList<Key>();
    }

    private class InternalTarget : Target
    {
      private KeyRing m_KeyRing;

      public InternalTarget(KeyRing keyRing) : base(-1, false, TargetFlags.None) => m_KeyRing = keyRing;

      protected override void OnTarget(Mobile from, object targeted)
      {
        if (m_KeyRing.Deleted || !m_KeyRing.IsChildOf(from.Backpack))
        {
          from.SendLocalizedMessage(1060640); // The item must be in your backpack to use it.
          return;
        }

        if (m_KeyRing == targeted)
        {
          m_KeyRing.Open(from);
          from.SendLocalizedMessage(501685); // You open the keyring.
        }
        else if (targeted is ILockable o)
        {
          if (m_KeyRing.Keys.Any(key => key.UseOn(from, o))) return;

          from.SendLocalizedMessage(1008140); // You do not have a key for that.
        }
        else
        {
          from.SendLocalizedMessage(501666); // You can't unlock that!
        }
      }
    }
  }
}